diff options
Diffstat (limited to 'browser/components/search')
381 files changed, 27132 insertions, 0 deletions
diff --git a/browser/components/search/.eslintrc.js b/browser/components/search/.eslintrc.js new file mode 100644 index 0000000000..39079432e7 --- /dev/null +++ b/browser/components/search/.eslintrc.js @@ -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/. */ + +"use strict"; + +module.exports = { + extends: ["plugin:mozilla/require-jsdoc"], + + rules: { + "mozilla/var-only-at-top-level": "error", + }, +}; diff --git a/browser/components/search/BrowserSearchTelemetry.sys.mjs b/browser/components/search/BrowserSearchTelemetry.sys.mjs new file mode 100644 index 0000000000..15163e38c7 --- /dev/null +++ b/browser/components/search/BrowserSearchTelemetry.sys.mjs @@ -0,0 +1,293 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + PartnerLinkAttribution: "resource:///modules/PartnerLinkAttribution.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", + SearchSERPTelemetry: "resource:///modules/SearchSERPTelemetry.sys.mjs", + UrlbarSearchUtils: "resource:///modules/UrlbarSearchUtils.sys.mjs", +}); + +// A map of known search origins. +// The keys of this map are used in the calling code to recordSearch, and in +// the SEARCH_COUNTS histogram. +// The values of this map are used in the names of scalars for the following +// scalar groups: +// browser.engagement.navigation.* +// browser.search.content.* +// browser.search.withads.* +// browser.search.adclicks.* +const KNOWN_SEARCH_SOURCES = new Map([ + ["abouthome", "about_home"], + ["contextmenu", "contextmenu"], + ["newtab", "about_newtab"], + ["searchbar", "searchbar"], + ["system", "system"], + ["urlbar", "urlbar"], + ["urlbar-handoff", "urlbar_handoff"], + ["urlbar-persisted", "urlbar_persisted"], + ["urlbar-searchmode", "urlbar_searchmode"], + ["webextension", "webextension"], +]); + +/** + * This class handles saving search telemetry related to the url bar, + * search bar and other areas as per the sources above. + */ +class BrowserSearchTelemetryHandler { + KNOWN_SEARCH_SOURCES = KNOWN_SEARCH_SOURCES; + + /** + * Determines if we should record a search for this browser instance. + * Private Browsing mode is normally skipped. + * + * @param {browser} browser + * The browser where the search was loaded. + * @returns {boolean} + * True if the search should be recorded, false otherwise. + */ + shouldRecordSearchCount(browser) { + return ( + !lazy.PrivateBrowsingUtils.isWindowPrivate(browser.ownerGlobal) || + !Services.prefs.getBoolPref("browser.engagement.search_counts.pbm", false) + ); + } + + /** + * Records the method by which the user selected a result from the urlbar or + * searchbar. + * + * @param {Event} event + * The event that triggered the selection. + * @param {string} source + * Either "urlbar" or "searchbar" depending on the source. + * @param {number} index + * The index that the user chose in the popup, or -1 if there wasn't a + * selection. + * @param {string} userSelectionBehavior + * How the user cycled through results before picking the current match. + * Could be one of "tab", "arrow" or "none". + */ + recordSearchSuggestionSelectionMethod( + event, + source, + index, + userSelectionBehavior = "none" + ) { + // If the contents of the histogram are changed then + // `UrlbarTestUtils.SELECTED_RESULT_METHODS` should also be updated. + if (source == "searchbar" && userSelectionBehavior != "none") { + throw new Error("Did not expect a selection behavior for the searchbar."); + } + + let histogram = Services.telemetry.getHistogramById( + source == "urlbar" + ? "FX_URLBAR_SELECTED_RESULT_METHOD" + : "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + // command events are from the one-off context menu. Treat them as clicks. + // Note that we don't care about MouseEvent subclasses here, since + // those are not clicks. + let isClick = + event && + (ChromeUtils.getClassName(event) == "MouseEvent" || + event.type == "command"); + let category; + if (isClick) { + category = "click"; + } else if (index >= 0) { + switch (userSelectionBehavior) { + case "tab": + category = "tabEnterSelection"; + break; + case "arrow": + category = "arrowEnterSelection"; + break; + case "rightClick": + // Selected by right mouse button. + category = "rightClickEnter"; + break; + default: + category = "enterSelection"; + } + } else { + category = "enter"; + } + histogram.add(category); + } + + /** + * Records entry into the Urlbar's search mode. + * + * Telemetry records only which search mode is entered and how it was entered. + * It does not record anything pertaining to searches made within search mode. + * + * @param {object} searchMode + * A search mode object. See UrlbarInput.setSearchMode documentation for + * details. + */ + recordSearchMode(searchMode) { + // Search mode preview is not search mode. Recording it would just create + // noise. + if (searchMode.isPreview) { + return; + } + + let scalarKey = lazy.UrlbarSearchUtils.getSearchModeScalarKey(searchMode); + Services.telemetry.keyedScalarAdd( + "urlbar.searchmode." + searchMode.entry, + scalarKey, + 1 + ); + } + + /** + * The main entry point for recording search related Telemetry. This includes + * search counts and engagement measurements. + * + * Telemetry records only search counts per engine and action origin, but + * nothing pertaining to the search contents themselves. + * + * @param {browser} browser + * The browser where the search originated. + * @param {nsISearchEngine} engine + * The engine handling the search. + * @param {string} source + * Where the search originated from. See KNOWN_SEARCH_SOURCES for allowed + * values. + * @param {object} [details] Options object. + * @param {boolean} [details.isOneOff=false] + * true if this event was generated by a one-off search. + * @param {boolean} [details.isSuggestion=false] + * true if this event was generated by a suggested search. + * @param {boolean} [details.isFormHistory=false] + * true if this event was generated by a form history result. + * @param {string} [details.alias=null] + * The search engine alias used in the search, if any. + * @param {string} [details.newtabSessionId=undefined] + * The newtab session that prompted this search, if any. + * @throws if source is not in the known sources list. + */ + recordSearch(browser, engine, source, details = {}) { + try { + if (!this.shouldRecordSearchCount(browser)) { + return; + } + if (!KNOWN_SEARCH_SOURCES.has(source)) { + console.error("Unknown source for search: ", source); + return; + } + + const countIdPrefix = `${engine.telemetryId}.`; + const countIdSource = countIdPrefix + source; + let histogram = Services.telemetry.getKeyedHistogramById("SEARCH_COUNTS"); + + if ( + details.alias && + engine.isAppProvided && + engine.aliases.includes(details.alias) + ) { + // This is a keyword search using an AppProvided engine. + // Record the source as "alias", not "urlbar". + histogram.add(countIdPrefix + "alias"); + } else { + histogram.add(countIdSource); + } + + // Dispatch the search signal to other handlers. + switch (source) { + case "urlbar": + case "searchbar": + case "urlbar-searchmode": + case "urlbar-persisted": + case "urlbar-handoff": + this._handleSearchAndUrlbar(browser, engine, source, details); + break; + case "abouthome": + case "newtab": + this._recordSearch(browser, engine, details.url, source, "enter"); + break; + default: + this._recordSearch(browser, engine, details.url, source); + break; + } + if (["urlbar-handoff", "abouthome", "newtab"].includes(source)) { + Glean.newtabSearch.issued.record({ + newtab_visit_id: details.newtabSessionId, + search_access_point: KNOWN_SEARCH_SOURCES.get(source), + telemetry_id: engine.telemetryId, + }); + lazy.SearchSERPTelemetry.recordBrowserNewtabSession( + browser, + details.newtabSessionId + ); + } + } catch (ex) { + // Catch any errors here, so that search actions are not broken if + // telemetry is broken for some reason. + console.error(ex); + } + } + + /** + * This function handles the "urlbar", "urlbar-oneoff", "searchbar" and + * "searchbar-oneoff" sources. + * + * @param {browser} browser + * The browser where the search originated. + * @param {nsISearchEngine} engine + * The engine handling the search. + * @param {string} source + * Where the search originated from. + * @param {object} details + * See {@link BrowserSearchTelemetryHandler.recordSearch} + */ + _handleSearchAndUrlbar(browser, engine, source, details) { + const isOneOff = !!details.isOneOff; + let action = "enter"; + if (isOneOff) { + action = "oneoff"; + } else if (details.isFormHistory) { + action = "formhistory"; + } else if (details.isSuggestion) { + action = "suggestion"; + } else if (details.alias) { + action = "alias"; + } + + this._recordSearch(browser, engine, details.url, source, action); + } + + _recordSearch(browser, engine, url, source, action = null) { + if (url) { + lazy.PartnerLinkAttribution.makeSearchEngineRequest(engine, url).catch( + console.error + ); + } + + let scalarSource = KNOWN_SEARCH_SOURCES.get(source); + + lazy.SearchSERPTelemetry.recordBrowserSource(browser, scalarSource); + + let scalarKey = action ? "search_" + action : "search"; + Services.telemetry.keyedScalarAdd( + "browser.engagement.navigation." + scalarSource, + scalarKey, + 1 + ); + Services.telemetry.recordEvent( + "navigation", + "search", + scalarSource, + action, + { + engine: engine.telemetryId, + } + ); + } +} + +export var BrowserSearchTelemetry = new BrowserSearchTelemetryHandler(); diff --git a/browser/components/search/SearchOneOffs.sys.mjs b/browser/components/search/SearchOneOffs.sys.mjs new file mode 100644 index 0000000000..ddab74f94a --- /dev/null +++ b/browser/components/search/SearchOneOffs.sys.mjs @@ -0,0 +1,1130 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", + SearchUIUtils: "resource:///modules/SearchUIUtils.sys.mjs", +}); + +const EMPTY_ADD_ENGINES = []; + +/** + * Defines the search one-off button elements. These are displayed at the bottom + * of the address bar and search bar. The address bar buttons are a subclass in + * browser/components/urlbar/UrlbarSearchOneOffs.jsm. If you are adding a new + * subclass, see "Methods for subclasses to override" below. + */ +export class SearchOneOffs { + constructor(container) { + this.container = container; + this.window = container.ownerGlobal; + this.document = container.ownerDocument; + + this.container.appendChild( + this.window.MozXULElement.parseXULToFragment( + ` + <hbox class="search-panel-one-offs-header search-panel-header"> + <label class="search-panel-one-offs-header-label" data-l10n-id="search-one-offs-with-title"/> + </hbox> + <box class="search-panel-one-offs-container"> + <hbox class="search-panel-one-offs" role="group"/> + <button class="searchbar-engine-one-off-item search-setting-button" tabindex="-1" data-l10n-id="search-one-offs-change-settings-compact-button"/> + </box> + <box> + <menupopup class="search-one-offs-context-menu"> + <menuitem class="search-one-offs-context-open-in-new-tab" data-l10n-id="search-one-offs-context-open-new-tab"/> + <menuitem class="search-one-offs-context-set-default" data-l10n-id="search-one-offs-context-set-as-default"/> + <menuitem class="search-one-offs-context-set-default-private" data-l10n-id="search-one-offs-context-set-as-default-private"/> + </menupopup> + </box> + ` + ) + ); + + this._popup = null; + this._textbox = null; + + this._textboxWidth = 0; + + /** + * Set this to a string that identifies your one-offs consumer. It'll + * be appended to telemetry recorded with maybeRecordTelemetry(). + */ + this.telemetryOrigin = ""; + + this._query = ""; + + this._selectedButton = null; + + this.buttons = this.querySelector(".search-panel-one-offs"); + + this.header = this.querySelector(".search-panel-one-offs-header"); + + this.settingsButton = this.querySelector(".search-setting-button"); + + this.contextMenuPopup = this.querySelector(".search-one-offs-context-menu"); + + this._engineInfo = null; + + /** + * `_rebuild()` is async, because it queries the Search Service, which means + * there is a potential for a race when it's called multiple times in succession. + */ + this._rebuilding = false; + + this.addEventListener("mousedown", this); + this.addEventListener("click", this); + this.addEventListener("command", this); + this.addEventListener("contextmenu", this); + + // Prevent popup events from the context menu from reaching the autocomplete + // binding (or other listeners). + let listener = aEvent => aEvent.stopPropagation(); + this.contextMenuPopup.addEventListener("popupshowing", listener); + this.contextMenuPopup.addEventListener("popuphiding", listener); + this.contextMenuPopup.addEventListener("popupshown", aEvent => { + aEvent.stopPropagation(); + }); + this.contextMenuPopup.addEventListener("popuphidden", aEvent => { + aEvent.stopPropagation(); + }); + + // Add weak referenced observers to invalidate our cached list of engines. + this.QueryInterface = ChromeUtils.generateQI([ + "nsIObserver", + "nsISupportsWeakReference", + ]); + Services.prefs.addObserver("browser.search.hiddenOneOffs", this, true); + Services.obs.addObserver(this, "browser-search-engine-modified", true); + Services.obs.addObserver(this, "browser-search-service", true); + + // Rebuild the buttons when the theme changes. See bug 1357800 for + // details. Summary: On Linux, switching between themes can cause a row + // of buttons to disappear. + Services.obs.addObserver(this, "lightweight-theme-changed", true); + + // This defaults to false in the Search Bar, subclasses can change their + // default in the constructor. + this.disableOneOffsHorizontalKeyNavigation = false; + } + + addEventListener(...args) { + this.container.addEventListener(...args); + } + + removeEventListener(...args) { + this.container.removeEventListener(...args); + } + + dispatchEvent(...args) { + this.container.dispatchEvent(...args); + } + + getAttribute(...args) { + return this.container.getAttribute(...args); + } + + hasAttribute(...args) { + return this.container.hasAttribute(...args); + } + + setAttribute(...args) { + this.container.setAttribute(...args); + } + + querySelector(...args) { + return this.container.querySelector(...args); + } + + handleEvent(event) { + let methodName = "_on_" + event.type; + if (methodName in this) { + this[methodName](event); + } else { + throw new Error("Unrecognized search-one-offs event: " + event.type); + } + } + + /** + * @returns {boolean} + * True if we will hide the one-offs when they are requested. + */ + async willHide() { + if (this._engineInfo?.willHide !== undefined) { + return this._engineInfo.willHide; + } + let engineInfo = await this.getEngineInfo(); + let oneOffCount = engineInfo.engines.length; + this._engineInfo.willHide = + !oneOffCount || + (oneOffCount == 1 && + engineInfo.engines[0].name == engineInfo.default.name); + return this._engineInfo.willHide; + } + + /** + * Invalidates the engine cache. After invalidating the cache, the one-offs + * will be rebuilt the next time they are shown. + */ + invalidateCache() { + if (!this._rebuilding) { + this._engineInfo = null; + } + } + + /** + * Width in pixels of the one-off buttons. + * NOTE: Used in browser/components/search/content/searchbar.js only. + * + * @returns {number} + */ + get buttonWidth() { + return 48; + } + + /** + * The popup that contains the one-offs. + * + * @param {DOMElement} val + * The new value to set. + */ + set popup(val) { + if (this._popup) { + this._popup.removeEventListener("popupshowing", this); + this._popup.removeEventListener("popuphidden", this); + } + if (val) { + val.addEventListener("popupshowing", this); + val.addEventListener("popuphidden", this); + } + this._popup = val; + + // If the popup is already open, rebuild the one-offs now. The + // popup may be opening, so check that the state is not closed + // instead of checking popupOpen. + if (val && val.state != "closed") { + this._rebuild(); + } + } + + get popup() { + return this._popup; + } + + /** + * The textbox associated with the one-offs. Set this to a textbox to + * automatically keep the related one-offs UI up to date. Otherwise you + * can leave it null/undefined, and in that case you should update the + * query property manually. + * + * @param {DOMElement} val + * The new value to set. + */ + set textbox(val) { + if (this._textbox) { + this._textbox.removeEventListener("input", this); + } + if (val) { + val.addEventListener("input", this); + } + this._textbox = val; + } + + get style() { + return this.container.style; + } + + get textbox() { + return this._textbox; + } + + /** + * The query string currently shown in the one-offs. If the textbox + * property is non-null, then this is automatically updated on + * input. + * + * @param {string} val + * The new query string to set. + */ + set query(val) { + this._query = val; + if (this.isViewOpen) { + let isOneOffSelected = + this.selectedButton && + this.selectedButton.classList.contains( + "searchbar-engine-one-off-item" + ) && + !( + this.selectedButton == this.settingsButton && + this.hasAttribute("is_searchbar") + ); + // Typing de-selects the settings or opensearch buttons at the bottom + // of the search panel, as typing shows the user intends to search. + if (this.selectedButton && !isOneOffSelected) { + this.selectedButton = null; + } + } + } + + get query() { + return this._query; + } + + /** + * The selected one-off, a xul:button, including the add-engine button + * and the search-settings button. + * + * @param {DOMElement|null} val + * The selected one-off button. Null if no one-off is selected. + */ + set selectedButton(val) { + let previousButton = this._selectedButton; + if (previousButton) { + previousButton.removeAttribute("selected"); + } + if (val) { + val.setAttribute("selected", "true"); + } + this._selectedButton = val; + + if (this.textbox) { + if (val) { + this.textbox.setAttribute("aria-activedescendant", val.id); + } else { + let active = this.textbox.getAttribute("aria-activedescendant"); + if (active && active.includes("-engine-one-off-item-")) { + this.textbox.removeAttribute("aria-activedescendant"); + } + } + } + + let event = new CustomEvent("SelectedOneOffButtonChanged", { + previousSelectedButton: previousButton, + }); + this.dispatchEvent(event); + } + + get selectedButton() { + return this._selectedButton; + } + + /** + * The index of the selected one-off, including the add-engine button + * and the search-settings button. + * + * @param {number} val + * The new index to set, -1 for nothing selected. + */ + set selectedButtonIndex(val) { + let buttons = this.getSelectableButtons(true); + this.selectedButton = buttons[val]; + } + + get selectedButtonIndex() { + let buttons = this.getSelectableButtons(true); + for (let i = 0; i < buttons.length; i++) { + if (buttons[i] == this._selectedButton) { + return i; + } + } + return -1; + } + + async getEngineInfo() { + if (this._engineInfo) { + return this._engineInfo; + } + + this._engineInfo = {}; + if (lazy.PrivateBrowsingUtils.isWindowPrivate(this.window)) { + this._engineInfo.default = await Services.search.getDefaultPrivate(); + } else { + this._engineInfo.default = await Services.search.getDefault(); + } + + let currentEngineNameToIgnore; + if (!this.getAttribute("includecurrentengine")) { + currentEngineNameToIgnore = this._engineInfo.default.name; + } + + let pref = Services.prefs.getStringPref("browser.search.hiddenOneOffs"); + let hiddenList = pref ? pref.split(",") : []; + + this._engineInfo.engines = ( + await Services.search.getVisibleEngines() + ).filter(e => { + let name = e.name; + return ( + (!currentEngineNameToIgnore || name != currentEngineNameToIgnore) && + !hiddenList.includes(name) + ); + }); + + return this._engineInfo; + } + + observe(aEngine, aTopic, aData) { + // Make sure the engine list was updated. + this.invalidateCache(); + } + + _getAddEngines() { + return this.window.gBrowser.selectedBrowser.engines || EMPTY_ADD_ENGINES; + } + + get _maxInlineAddEngines() { + return 3; + } + + /** + * Infallible, non-re-entrant version of `__rebuild()`. + */ + async _rebuild() { + if (this._rebuilding) { + return; + } + + this._rebuilding = true; + try { + await this.__rebuild(); + } catch (ex) { + console.error("Search-one-offs::_rebuild() error: " + ex); + } finally { + this._rebuilding = false; + } + } + + /** + * Builds all the UI. + */ + async __rebuild() { + // Return early if the list of engines has not changed. + if (!this.popup && this._engineInfo?.domWasUpdated) { + return; + } + + const addEngines = this._getAddEngines(); + + // Return early if the engines and panel width have not changed. + if (this.popup && this._textbox) { + let textboxWidth = await this.window.promiseDocumentFlushed(() => { + return this._textbox.clientWidth; + }); + + if ( + this._engineInfo?.domWasUpdated && + this._textboxWidth == textboxWidth && + this._addEngines == addEngines + ) { + return; + } + this._textboxWidth = textboxWidth; + this._addEngines = addEngines; + } + + const isSearchBar = this.hasAttribute("is_searchbar"); + if (isSearchBar) { + // Hide the container during updating to avoid flickering. + this.container.hidden = true; + } + + // Finally, build the list of one-off buttons. + while (this.buttons.firstElementChild) { + this.buttons.firstElementChild.remove(); + } + + let headerText = this.header.querySelector( + ".search-panel-one-offs-header-label" + ); + headerText.id = this.telemetryOrigin + "-one-offs-header-label"; + this.buttons.setAttribute("aria-labelledby", headerText.id); + + // For the search-bar, always show the one-off buttons where there is an + // option to add an engine. + let addEngineNeeded = isSearchBar && addEngines.length; + let hideOneOffs = (await this.willHide()) && !addEngineNeeded; + + // The _engineInfo cache is used by more consumers, thus it is not a good + // representation of whether this method already updated the one-off buttons + // DOM. For this reason we introduce a separate flag tracking the DOM + // updating, and use it to know when it's okay to not rebuild the one-offs. + // We set this early, since we might either rebuild the DOM or hide it. + this._engineInfo.domWasUpdated = true; + + this.container.hidden = hideOneOffs; + + if (hideOneOffs) { + return; + } + + // Ensure we can refer to the settings buttons by ID: + let origin = this.telemetryOrigin; + this.settingsButton.id = origin + "-anon-search-settings"; + + let engines = (await this.getEngineInfo()).engines; + this._rebuildEngineList(engines, addEngines); + + this.dispatchEvent(new Event("rebuild")); + } + + /** + * Adds one-offs for the given engines to the DOM. + * + * @param {Array} engines + * The engines to add. + * @param {Array} addEngines + * The engines that can be added. + */ + _rebuildEngineList(engines, addEngines) { + for (let i = 0; i < engines.length; ++i) { + let engine = engines[i]; + let button = this.document.createXULElement("button"); + button.engine = engine; + button.id = this._buttonIDForEngine(engine); + let iconURI = + engine.iconURI?.spec || + "chrome://browser/skin/search-engine-placeholder.png"; + button.setAttribute("image", iconURI); + button.setAttribute("class", "searchbar-engine-one-off-item"); + button.setAttribute("tabindex", "-1"); + this.setTooltipForEngineButton(button); + this.buttons.appendChild(button); + } + + for ( + let i = 0, len = Math.min(addEngines.length, this._maxInlineAddEngines); + i < len; + i++ + ) { + const engine = addEngines[i]; + const button = this.document.createXULElement("button"); + button.id = this._buttonIDForEngine(engine); + button.classList.add("searchbar-engine-one-off-item"); + button.classList.add("searchbar-engine-one-off-add-engine"); + button.setAttribute("tabindex", "-1"); + if (engine.icon) { + button.setAttribute("image", engine.icon); + } + button.setAttribute("data-l10n-id", "search-one-offs-add-engine"); + button.setAttribute( + "data-l10n-args", + JSON.stringify({ engineName: engine.title }) + ); + button.setAttribute("engine-name", engine.title); + button.setAttribute("uri", engine.uri); + this.buttons.appendChild(button); + } + } + + _buttonIDForEngine(engine) { + return ( + this.telemetryOrigin + + "-engine-one-off-item-engine-" + + this._engineInfo.engines.indexOf(engine) + ); + } + + getSelectableButtons(aIncludeNonEngineButtons) { + const buttons = [ + ...this.buttons.querySelectorAll(".searchbar-engine-one-off-item"), + ]; + + if (aIncludeNonEngineButtons) { + buttons.push(this.settingsButton); + } + + return buttons; + } + + /** + * Returns information on where a search results page should be loaded: in the + * current tab or a new tab. + * + * @param {event} aEvent + * The event that triggered the page load. + * @param {boolean} [aForceNewTab] + * True to force the load in a new tab. + * @returns {object} An object { where, params }. `where` is a string: + * "current" or "tab". `params` is an object further describing how + * the page should be loaded. + */ + _whereToOpen(aEvent, aForceNewTab = false) { + let where = "current"; + let params; + // Open ctrl/cmd clicks on one-off buttons in a new background tab. + if (aForceNewTab) { + where = "tab"; + if (Services.prefs.getBoolPref("browser.tabs.loadInBackground")) { + params = { + inBackground: true, + }; + } + } else { + let newTabPref = Services.prefs.getBoolPref("browser.search.openintab"); + if ( + (KeyboardEvent.isInstance(aEvent) && aEvent.altKey) ^ newTabPref && + !this.window.gBrowser.selectedTab.isEmpty + ) { + where = "tab"; + } + if ( + MouseEvent.isInstance(aEvent) && + (aEvent.button == 1 || aEvent.getModifierState("Accel")) + ) { + where = "tab"; + params = { + inBackground: true, + }; + } + } + + return { where, params }; + } + + /** + * Increments or decrements the index of the currently selected one-off. + * + * @param {boolean} aForward + * If true, the index is incremented, and if false, the index is + * decremented. + * @param {boolean} aIncludeNonEngineButtons + * If true, buttons that do not have engines are included. + * These buttons include the OpenSearch and settings buttons. For + * example, if the currently selected button is an engine button, + * the next button is the settings button, and you pass true for + * aForward, then passing true for this value would cause the + * settings to be selected. Passing false for this value would + * cause the selection to clear or wrap around, depending on what + * value you passed for the aWrapAround parameter. + * @param {boolean} aWrapAround + * If true, the selection wraps around between the first and last + * buttons. + */ + advanceSelection(aForward, aIncludeNonEngineButtons, aWrapAround) { + let buttons = this.getSelectableButtons(aIncludeNonEngineButtons); + let index; + if (this.selectedButton) { + let inc = aForward ? 1 : -1; + let oldIndex = buttons.indexOf(this.selectedButton); + index = (oldIndex + inc + buttons.length) % buttons.length; + if ( + !aWrapAround && + ((aForward && index <= oldIndex) || (!aForward && oldIndex <= index)) + ) { + // The index has wrapped around, but wrapping around isn't + // allowed. + index = -1; + } + } else { + index = aForward ? 0 : buttons.length - 1; + } + this.selectedButton = index < 0 ? null : buttons[index]; + } + + /** + * This handles key presses specific to the one-off buttons like Tab and + * Alt+Up/Down, and Up/Down keys within the buttons. Since one-off buttons + * are always used in conjunction with a list of some sort (in this.popup), + * it also handles Up/Down keys that cross the boundaries between list + * items and the one-off buttons. + * + * If this method handles the key press, then it will call + * event.preventDefault() and return true. + * + * @param {Event} event + * The key event. + * @param {number} numListItems + * The number of items in the list. The reason that this is a + * parameter at all is that the list may contain items at the end + * that should be ignored, depending on the consumer. That's true + * for the urlbar for example. + * @param {boolean} allowEmptySelection + * Pass true if it's OK that neither the list nor the one-off + * buttons contains a selection. Pass false if either the list or + * the one-off buttons (or both) should always contain a selection. + * @param {string} [textboxUserValue] + * When the last list item is selected and the user presses Down, + * the first one-off becomes selected and the textbox value is + * restored to the value that the user typed. Pass that value here. + * However, if you pass true for allowEmptySelection, you don't need + * to pass anything for this parameter. (Pass undefined or null.) + * @returns {boolean} True if the one-offs handled the key press. + */ + handleKeyDown(event, numListItems, allowEmptySelection, textboxUserValue) { + if (!this.hasView) { + return false; + } + let handled = this._handleKeyDown( + event, + numListItems, + allowEmptySelection, + textboxUserValue + ); + if (handled) { + event.preventDefault(); + event.stopPropagation(); + } + return handled; + } + + _handleKeyDown(event, numListItems, allowEmptySelection, textboxUserValue) { + if (this.container.hidden) { + return false; + } + if ( + event.keyCode == KeyEvent.DOM_VK_RIGHT && + this.selectedButton && + this.selectedButton.classList.contains("addengine-menu-button") + ) { + // If the add-engine overflow menu item is selected and the user + // presses the right arrow key, open the submenu. Unfortunately + // handling the left arrow key -- to close the popup -- isn't + // straightforward. Once the popup is open, it consumes all key + // events. Setting ignorekeys=handled on it doesn't help, since the + // popup handles all arrow keys. Setting ignorekeys=true on it does + // mean that the popup no longer consumes the left arrow key, but + // then it no longer handles up/down keys to select items in the + // popup. + this.selectedButton.open = true; + return true; + } + + // Handle the Tab key, but only if non-Shift modifiers aren't also + // pressed to avoid clobbering other shortcuts (like the Alt+Tab + // browser tab switcher). The reason this uses getModifierState() and + // checks for "AltGraph" is that when you press Shift-Alt-Tab, + // event.altKey is actually false for some reason, at least on macOS. + // getModifierState("Alt") is also false, but "AltGraph" is true. + if ( + event.keyCode == KeyEvent.DOM_VK_TAB && + !event.getModifierState("Alt") && + !event.getModifierState("AltGraph") && + !event.getModifierState("Control") && + !event.getModifierState("Meta") + ) { + if ( + this.getAttribute("disabletab") == "true" || + (event.shiftKey && this.selectedButtonIndex <= 0) || + (!event.shiftKey && + this.selectedButtonIndex == + this.getSelectableButtons(true).length - 1) + ) { + this.selectedButton = null; + return false; + } + this.selectedViewIndex = -1; + this.advanceSelection(!event.shiftKey, true, false); + return !!this.selectedButton; + } + + if (event.keyCode == KeyboardEvent.DOM_VK_UP) { + if (event.altKey) { + // Keep the currently selected result in the list (if any) as a + // secondary "alt" selection and move the selection up within the + // buttons. + this.advanceSelection(false, false, false); + return true; + } + if (numListItems == 0) { + this.advanceSelection(false, true, false); + return true; + } + if (this.selectedViewIndex > 0) { + // Moving up within the list. The autocomplete controller should + // handle this case. A button may be selected, so null it. + this.selectedButton = null; + return false; + } + if (this.selectedViewIndex == 0) { + // Moving up from the top of the list. + if (allowEmptySelection) { + // Let the autocomplete controller remove selection in the list + // and revert the typed text in the textbox. + return false; + } + // Wrap selection around to the last button. + if (this.textbox && typeof textboxUserValue == "string") { + this.textbox.value = textboxUserValue; + } + this.selectedViewIndex = -1; + this.advanceSelection(false, true, true); + return true; + } + if (!this.selectedButton) { + // Moving up from no selection in the list or the buttons, back + // down to the last button. + this.advanceSelection(false, true, true); + return true; + } + if (this.selectedButtonIndex == 0) { + // Moving up from the buttons to the bottom of the list. + this.selectedButton = null; + return false; + } + // Moving up/left within the buttons. + this.advanceSelection(false, true, false); + return true; + } + + if (event.keyCode == KeyboardEvent.DOM_VK_DOWN) { + if (event.altKey) { + // Keep the currently selected result in the list (if any) as a + // secondary "alt" selection and move the selection down within + // the buttons. + this.advanceSelection(true, false, false); + return true; + } + if (numListItems == 0) { + this.advanceSelection(true, true, false); + return true; + } + if ( + this.selectedViewIndex >= 0 && + this.selectedViewIndex < numListItems - 1 + ) { + // Moving down within the list. The autocomplete controller + // should handle this case. A button may be selected, so null it. + this.selectedButton = null; + return false; + } + if (this.selectedViewIndex == numListItems - 1) { + // Moving down from the last item in the list to the buttons. + if (!allowEmptySelection) { + this.selectedViewIndex = -1; + if (this.textbox && typeof textboxUserValue == "string") { + this.textbox.value = textboxUserValue; + } + } + this.selectedButtonIndex = 0; + if (allowEmptySelection) { + // Let the autocomplete controller remove selection in the list + // and revert the typed text in the textbox. + return false; + } + return true; + } + if (this.selectedButton) { + let buttons = this.getSelectableButtons(true); + if (this.selectedButtonIndex == buttons.length - 1) { + // Moving down from the buttons back up to the top of the list. + this.selectedButton = null; + if (allowEmptySelection) { + // Prevent the selection from wrapping around to the top of + // the list by returning true, since the list currently has no + // selection. Nothing should be selected after handling this + // Down key. + return true; + } + return false; + } + // Moving down/right within the buttons. + this.advanceSelection(true, true, false); + return true; + } + return false; + } + + if (event.keyCode == KeyboardEvent.DOM_VK_LEFT) { + if ( + this.selectedButton && + this.selectedButton.engine && + !this.disableOneOffsHorizontalKeyNavigation + ) { + // Moving left within the buttons. + this.advanceSelection(false, true, true); + return true; + } + return false; + } + + if (event.keyCode == KeyboardEvent.DOM_VK_RIGHT) { + if ( + this.selectedButton && + this.selectedButton.engine && + !this.disableOneOffsHorizontalKeyNavigation + ) { + // Moving right within the buttons. + this.advanceSelection(true, true, true); + return true; + } + return false; + } + + return false; + } + + /** + * Determines if the target of the event is a one-off button or + * context menu on a one-off button. + * + * @param {Event} event + * An event, like a click on a one-off button. + * @returns {boolean} True if telemetry was recorded and false if not. + */ + eventTargetIsAOneOff(event) { + if (!event) { + return false; + } + + let target = event.originalTarget; + + if (KeyboardEvent.isInstance(event) && this.selectedButton) { + return true; + } + if ( + MouseEvent.isInstance(event) && + target.classList.contains("searchbar-engine-one-off-item") + ) { + return true; + } + if ( + this.window.XULCommandEvent.isInstance(event) && + target.classList.contains("search-one-offs-context-open-in-new-tab") + ) { + return true; + } + + return false; + } + + // Methods for subclasses to override + + /** + * @returns {boolean} True if the one-offs are connected to a view. + */ + get hasView() { + return !!this.popup; + } + + /** + * @returns {boolean} True if the view is open. + */ + get isViewOpen() { + return this.popup && this.popup.popupOpen; + } + + /** + * @returns {number} The selected index in the view or -1 if no selection. + */ + get selectedViewIndex() { + return this.popup.selectedIndex; + } + + /** + * Sets the selected index in the view. + * + * @param {number} val + * The selected index or -1 if no selection. + */ + set selectedViewIndex(val) { + this.popup.selectedIndex = val; + } + + /** + * Closes the view. + */ + closeView() { + this.popup.hidePopup(); + } + + /** + * Called when a one-off is clicked or the "Search in New Tab" context menu + * item is picked. This is not called for the settings button. + * + * @param {event} event + * The event that triggered the pick. + * @param {nsISearchEngine|SearchEngine} engine + * The engine that was picked. + * @param {boolean} forceNewTab + * True if the search results page should be loaded in a new tab. + */ + handleSearchCommand(event, engine, forceNewTab = false) { + let { where, params } = this._whereToOpen(event, forceNewTab); + this.popup.handleOneOffSearch(event, engine, where, params); + } + + /** + * Sets the tooltip for a one-off button with an engine. This should set + * either the `tooltiptext` attribute or the relevant l10n ID. + * + * @param {element} button + * The one-off button. + */ + setTooltipForEngineButton(button) { + button.setAttribute("tooltiptext", button.engine.name); + } + + // Event handlers below. + + _on_mousedown(event) { + // This is necessary to prevent the input from losing focus and closing the + // popup. Unfortunately it also has the side effect of preventing the + // buttons from receiving the `:active` pseudo-class. + event.preventDefault(); + } + + _on_click(event) { + if (event.button == 2) { + return; // ignore right clicks. + } + + let button = event.originalTarget; + let engine = button.engine; + + if (!engine) { + return; + } + + // Select the clicked button so that consumers can easily tell which + // button was acted on. + this.selectedButton = button; + this.handleSearchCommand(event, engine); + } + + _on_command(event) { + let target = event.target; + + if (target == this.settingsButton) { + this.window.openPreferences("paneSearch"); + + // If the preference tab was already selected, the panel doesn't + // close itself automatically. + this.closeView(); + return; + } + + if (target.classList.contains("searchbar-engine-one-off-add-engine")) { + // On success, hide the panel and tell event listeners to reshow it to + // show the new engine. + lazy.SearchUIUtils.addOpenSearchEngine( + target.getAttribute("uri"), + target.getAttribute("image"), + this.window.gBrowser.selectedBrowser.browsingContext + ) + .then(result => { + if (result) { + this._rebuild(); + } + }) + .catch(console.error); + return; + } + + if (target.classList.contains("search-one-offs-context-open-in-new-tab")) { + // Select the context-clicked button so that consumers can easily + // tell which button was acted on. + this.selectedButton = target.closest("menupopup")._triggerButton; + this.handleSearchCommand(event, this.selectedButton.engine, true); + } + + const isPrivateButton = target.classList.contains( + "search-one-offs-context-set-default-private" + ); + if ( + target.classList.contains("search-one-offs-context-set-default") || + isPrivateButton + ) { + const engineType = isPrivateButton + ? "defaultPrivateEngine" + : "defaultEngine"; + let currentEngine = Services.search[engineType]; + + const isPrivateWin = lazy.PrivateBrowsingUtils.isWindowPrivate( + this.window + ); + let button = target.closest("menupopup")._triggerButton; + // We're about to replace this, so it must be stored now. + let newDefaultEngine = button.engine; + if ( + !this.getAttribute("includecurrentengine") && + isPrivateButton == isPrivateWin + ) { + // Make the target button of the context menu reflect the current + // search engine first. Doing this as opposed to rebuilding all the + // one-off buttons avoids flicker. + let uri = "chrome://browser/skin/search-engine-placeholder.png"; + if (currentEngine.iconURI) { + uri = currentEngine.iconURI.spec; + } + button.setAttribute("image", uri); + button.setAttribute("tooltiptext", currentEngine.name); + button.engine = currentEngine; + } + + if (isPrivateButton) { + Services.search.setDefaultPrivate( + newDefaultEngine, + Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR_CONTEXT + ); + } else { + Services.search.setDefault( + newDefaultEngine, + Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR_CONTEXT + ); + } + } + } + + _on_contextmenu(event) { + let target = event.originalTarget; + // Prevent the context menu from appearing except on the one off buttons. + if ( + !target.classList.contains("searchbar-engine-one-off-item") || + target.classList.contains("search-setting-button") + ) { + event.preventDefault(); + return; + } + this.contextMenuPopup + .querySelector(".search-one-offs-context-set-default") + .setAttribute( + "disabled", + target.engine == Services.search.defaultEngine.wrappedJSObject + ); + + const privateDefaultItem = this.contextMenuPopup.querySelector( + ".search-one-offs-context-set-default-private" + ); + + if ( + Services.prefs.getBoolPref( + "browser.search.separatePrivateDefault.ui.enabled", + false + ) && + Services.prefs.getBoolPref("browser.search.separatePrivateDefault", false) + ) { + privateDefaultItem.hidden = false; + privateDefaultItem.setAttribute( + "disabled", + target.engine == Services.search.defaultPrivateEngine.wrappedJSObject + ); + } else { + privateDefaultItem.hidden = true; + } + + // When a context menu is opened on a one-off button, this is set to the + // button to be used for the command. + this.contextMenuPopup._triggerButton = target; + this.contextMenuPopup.openPopupAtScreen(event.screenX, event.screenY, true); + event.preventDefault(); + } + + _on_input(event) { + // Allow the consumer's input to override its value property with + // a oneOffSearchQuery property. That way if the value is not + // actually what the user typed (e.g., it's autofilled, or it's a + // mozaction URI), the consumer has some way of providing it. + this.query = event.target.oneOffSearchQuery || event.target.value; + } + + _on_popupshowing() { + this._rebuild(); + } + + _on_popuphidden() { + this.selectedButton = null; + } +} diff --git a/browser/components/search/SearchSERPTelemetry.sys.mjs b/browser/components/search/SearchSERPTelemetry.sys.mjs new file mode 100644 index 0000000000..1f7af4385b --- /dev/null +++ b/browser/components/search/SearchSERPTelemetry.sys.mjs @@ -0,0 +1,1312 @@ +/* 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/. */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + BrowserSearchTelemetry: "resource:///modules/BrowserSearchTelemetry.sys.mjs", + RemoteSettings: "resource://services-settings/remote-settings.sys.mjs", + SearchUtils: "resource://gre/modules/SearchUtils.sys.mjs", +}); + +// The various histograms and scalars that we report to. +const SEARCH_CONTENT_SCALAR_BASE = "browser.search.content."; +const SEARCH_WITH_ADS_SCALAR_BASE = "browser.search.withads."; +const SEARCH_AD_CLICKS_SCALAR_BASE = "browser.search.adclicks."; +const SEARCH_DATA_TRANSFERRED_SCALAR = "browser.search.data_transferred"; +const SEARCH_TELEMETRY_PRIVATE_BROWSING_KEY_SUFFIX = "pb"; + +// Exported for tests. +export const TELEMETRY_SETTINGS_KEY = "search-telemetry-v2"; + +const impressionIdsWithoutEngagementsSet = new Set(); + +XPCOMUtils.defineLazyGetter(lazy, "logConsole", () => { + return console.createInstance({ + prefix: "SearchTelemetry", + maxLogLevel: lazy.SearchUtils.loggingEnabled ? "Debug" : "Warn", + }); +}); + +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "serpEventsEnabled", + "browser.search.serpEventTelemetry.enabled", + false +); + +export var SearchSERPTelemetryUtils = { + ACTIONS: { + CLICKED: "clicked", + EXPANDED: "expanded", + SUBMITTED: "submitted", + }, + COMPONENTS: { + AD_CAROUSEL: "ad_carousel", + AD_LINK: "ad_link", + AD_SIDEBAR: "ad_sidebar", + AD_SITELINK: "ad_sitelink", + INCONTENT_SEARCHBOX: "incontent_searchbox", + NON_ADS_LINK: "non_ads_link", + REFINED_SEARCH_BUTTONS: "refined_search_buttons", + SHOPPING_TAB: "shopping_tab", + }, + ABANDONMENTS: { + NAVIGATION: "navigation", + TAB_CLOSE: "tab_close", + WINDOW_CLOSE: "window_close", + }, + INCONTENT_SOURCES: { + OPENED_IN_NEW_TAB: "opened_in_new_tab", + REFINE_ON_SERP: "follow_on_from_refine_on_SERP", + SEARCHBOX: "follow_on_from_refine_on_incontent_search", + }, +}; + +/** + * TelemetryHandler is the main class handling Search Engine Result Page (SERP) + * telemetry. It primarily deals with tracking of what pages are loaded into tabs. + * + * It handles the *in-content:sap* keys of the SEARCH_COUNTS histogram. + */ +class TelemetryHandler { + // Whether or not this class is initialised. + _initialized = false; + + // An instance of ContentHandler. + _contentHandler; + + // The original provider information, mainly used for tests. + _originalProviderInfo = null; + + // The current search provider info. + _searchProviderInfo = null; + + // An instance of remote settings that is used to access the provider info. + _telemetrySettings; + + // _browserInfoByURL is a map of tracked search urls to objects containing: + // * {object} info + // the search provider information associated with the url. + // * {WeakMap} browserTelemetryStateMap + // a weak map of browsers that have the url loaded, their ad report state, + // and their impression id. + // * {integer} count + // a manual count of browsers logged. + // We keep a weak map of browsers, in case we miss something on our counts + // and cause a memory leak - worst case our map is slightly bigger than it + // needs to be. + // The manual count is because WeakMap doesn't give us size/length + // information, but we want to know when we can clean up our associated + // entry. + _browserInfoByURL = new Map(); + + // _browserSourceMap is a map of the latest search source for a particular + // browser - one of the KNOWN_SEARCH_SOURCES in BrowserSearchTelemetry. + _browserSourceMap = new WeakMap(); + + /** + * A WeakMap whose key is a browser with value of a source type found in + * INCONTENT_SOURCES. Kept separate to avoid overlapping with legacy + * search sources. These sources are specific to the content of a search + * provider page rather than something from within the browser itself. + */ + #browserContentSourceMap = new WeakMap(); + + /** + * Sets the source of a SERP visit from something that occured in content + * rather than from the browser. + * + * @param {browser} browser + * The browser object associated with the page that should be a SERP. + * @param {string} source + * The source that started the load. One of + * SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + * SearchSERPTelemetryUtils.INCONTENT_SOURCES.OPENED_IN_NEW_TAB or + * SearchSERPTelemetryUtils.INCONTENT_SOURCES.REFINE_ON_SERP. + */ + setBrowserContentSource(browser, source) { + this.#browserContentSourceMap.set(browser, source); + } + + // _browserNewtabSessionMap is a map of the newtab session id for particular + // browsers. + _browserNewtabSessionMap = new WeakMap(); + + constructor() { + this._contentHandler = new ContentHandler({ + browserInfoByURL: this._browserInfoByURL, + findBrowserItemForURL: (...args) => this._findBrowserItemForURL(...args), + checkURLForSerpMatch: (...args) => this._checkURLForSerpMatch(...args), + }); + } + + /** + * Initializes the TelemetryHandler and its ContentHandler. It will add + * appropriate listeners to the window so that window opening and closing + * can be tracked. + */ + async init() { + if (this._initialized) { + return; + } + + this._telemetrySettings = lazy.RemoteSettings(TELEMETRY_SETTINGS_KEY); + let rawProviderInfo = []; + try { + rawProviderInfo = await this._telemetrySettings.get(); + } catch (ex) { + lazy.logConsole.error("Could not get settings:", ex); + } + + // Send the provider info to the child handler. + this._contentHandler.init(rawProviderInfo); + this._originalProviderInfo = rawProviderInfo; + + // Now convert the regexps into + this._setSearchProviderInfo(rawProviderInfo); + + for (let win of Services.wm.getEnumerator("navigator:browser")) { + this._registerWindow(win); + } + Services.wm.addListener(this); + + this._initialized = true; + } + + /** + * Uninitializes the TelemetryHandler and its ContentHandler. + */ + uninit() { + if (!this._initialized) { + return; + } + + this._contentHandler.uninit(); + + for (let win of Services.wm.getEnumerator("navigator:browser")) { + this._unregisterWindow(win); + } + Services.wm.removeListener(this); + + this._initialized = false; + } + + /** + * Records the search source for particular browsers, in case it needs + * to be associated with a SERP. + * + * @param {browser} browser + * The browser where the search originated. + * @param {string} source + * Where the search originated from. + */ + recordBrowserSource(browser, source) { + this._browserSourceMap.set(browser, source); + } + + /** + * Records the newtab source for particular browsers, in case it needs + * to be associated with a SERP. + * + * @param {browser} browser + * The browser where the search originated. + * @param {string} newtabSessionId + * The sessionId of the newtab session the search originated from. + */ + recordBrowserNewtabSession(browser, newtabSessionId) { + this._browserNewtabSessionMap.set(browser, newtabSessionId); + } + + /** + * Helper function for recording the reason for a Glean abandonment event. + * + * @param {string} impressionId + * The impression id for the abandonment event about to be recorded. + * @param {string} reason + * The reason the SERP is deemed abandoned. + * One of SearchSERPTelemetryUtils.ABANDONMENTS. + */ + recordAbandonmentTelemetry(impressionId, reason) { + impressionIdsWithoutEngagementsSet.delete(impressionId); + + lazy.logConsole.debug( + `Recording an abandonment event for impression id ${impressionId} with reason: ${reason}` + ); + + Glean.serp.abandonment.record({ + impression_id: impressionId, + reason, + }); + } + + /** + * Handles the TabClose event received from the listeners. + * + * @param {object} event + * The event object provided by the listener. + */ + handleEvent(event) { + if (event.type != "TabClose") { + console.error(`Received unexpected event type ${event.type}`); + return; + } + + this._browserNewtabSessionMap.delete(event.target.linkedBrowser); + this.stopTrackingBrowser( + event.target.linkedBrowser, + SearchSERPTelemetryUtils.ABANDONMENTS.TAB_CLOSE + ); + } + + /** + * Test-only function, used to override the provider information, so that + * unit tests can set it to easy to test values. + * + * @param {Array} providerInfo + * See {@link https://searchfox.org/mozilla-central/search?q=search-telemetry-schema.json} + * for type information. + */ + overrideSearchTelemetryForTests(providerInfo) { + let info = providerInfo ? providerInfo : this._originalProviderInfo; + this._contentHandler.overrideSearchTelemetryForTests(info); + this._setSearchProviderInfo(info); + } + + /** + * Used to set the local version of the search provider information. + * This automatically maps the regexps to RegExp objects so that + * we don't have to create a new instance each time. + * + * @param {Array} providerInfo + * A raw array of provider information to set. + */ + _setSearchProviderInfo(providerInfo) { + this._searchProviderInfo = providerInfo.map(provider => { + let newProvider = { + ...provider, + searchPageRegexp: new RegExp(provider.searchPageRegexp), + }; + if (provider.extraAdServersRegexps) { + newProvider.extraAdServersRegexps = provider.extraAdServersRegexps.map( + r => new RegExp(r) + ); + } + + newProvider.nonAdsLinkRegexps = provider.nonAdsLinkRegexps?.length + ? provider.nonAdsLinkRegexps.map(r => new RegExp(r)) + : []; + if (provider.shoppingTab?.regexp) { + newProvider.shoppingTab = { + selector: provider.shoppingTab.selector, + regexp: new RegExp(provider.shoppingTab.regexp), + }; + } + return newProvider; + }); + this._contentHandler._searchProviderInfo = this._searchProviderInfo; + } + + reportPageAction(info, browser) { + this._contentHandler._reportPageAction(info, browser); + } + + reportPageWithAds(info, browser) { + this._contentHandler._reportPageWithAds(info, browser); + } + + reportPageWithAdImpressions(info, browser) { + this._contentHandler._reportPageWithAdImpressions(info, browser); + } + + reportPageImpression(info, browser) { + this._contentHandler._reportPageImpression(info, browser); + } + + /** + * This may start tracking a tab based on the URL. If the URL matches a search + * partner, and it has a code, then we'll start tracking it. This will aid + * determining if it is a page we should be tracking for adverts. + * + * @param {object} browser + * The browser associated with the page. + * @param {string} url + * The url that was loaded in the browser. + * @param {nsIDocShell.LoadCommand} loadType + * The load type associated with the page load. + */ + updateTrackingStatus(browser, url, loadType) { + if ( + !lazy.BrowserSearchTelemetry.shouldRecordSearchCount( + browser.getTabBrowser() + ) + ) { + return; + } + let info = this._checkURLForSerpMatch(url); + if (!info) { + this._browserNewtabSessionMap.delete(browser); + this.stopTrackingBrowser(browser); + return; + } + + let source = "unknown"; + if (loadType & Ci.nsIDocShell.LOAD_CMD_RELOAD) { + source = "reload"; + } else if (loadType & Ci.nsIDocShell.LOAD_CMD_HISTORY) { + source = "tabhistory"; + } else if (this._browserSourceMap.has(browser)) { + source = this._browserSourceMap.get(browser); + this._browserSourceMap.delete(browser); + } + + // If it's a SERP but doesn't have a browser source, the source might be + // from something that happened in content. We keep this separate from + // source because legacy telemetry should not change its reporting. + let inContentSource; + if ( + lazy.serpEventsEnabled && + info.hasComponents && + this.#browserContentSourceMap.has(browser) + ) { + inContentSource = this.#browserContentSourceMap.get(browser); + this.#browserContentSourceMap.delete(browser); + } + + let newtabSessionId; + if (this._browserNewtabSessionMap.has(browser)) { + newtabSessionId = this._browserNewtabSessionMap.get(browser); + // We leave the newtabSessionId in the map for this browser + // until we stop loading SERP pages or the tab is closed. + } + + let impressionId; + if (lazy.serpEventsEnabled && info.hasComponents) { + // The UUID generated by Services.uuid contains leading and trailing braces. + // Need to trim them first. + impressionId = Services.uuid.generateUUID().toString().slice(1, -1); + + impressionIdsWithoutEngagementsSet.add(impressionId); + } + + this._reportSerpPage(info, source, url); + + let item = this._browserInfoByURL.get(url); + + let impressionInfo; + if (lazy.serpEventsEnabled && info.hasComponents) { + let partnerCode = ""; + if (info.code != "none" && info.code != null) { + partnerCode = info.code; + } + impressionInfo = { + provider: info.provider, + tagged: info.type.startsWith("tagged"), + partnerCode, + source: inContentSource ?? source, + isShoppingPage: info.isShoppingPage, + }; + } + + if (item) { + item.browserTelemetryStateMap.set(browser, { + adsReported: false, + adImpressionsReported: false, + impressionId, + hrefToComponentMap: null, + impressionInfo, + searchBoxSubmitted: false, + }); + item.count++; + item.source = source; + item.newtabSessionId = newtabSessionId; + } else { + item = this._browserInfoByURL.set(url, { + browserTelemetryStateMap: new WeakMap().set(browser, { + adsReported: false, + adImpressionsReported: false, + impressionId, + hrefToComponentMap: null, + impressionInfo, + searchBoxSubmitted: false, + }), + info, + count: 1, + source, + newtabSessionId, + }); + } + } + + /** + * Stops tracking of a tab, for example the tab has loaded a different URL. + * Also records a Glean abandonment event if appropriate. + * + * @param {object} browser The browser associated with the tab to stop being + * tracked. + * @param {string} abandonmentReason + * An optional parameter that specifies why the browser is deemed abandoned. + * The reason will be recorded as part of Glean abandonment telemetry. + * One of SearchSERPTelemetryUtils.ABANDONMENTS. + */ + stopTrackingBrowser(browser, abandonmentReason) { + for (let [url, item] of this._browserInfoByURL) { + if (item.browserTelemetryStateMap.has(browser)) { + let impressionId = + item.browserTelemetryStateMap.get(browser).impressionId; + if (impressionIdsWithoutEngagementsSet.has(impressionId)) { + this.recordAbandonmentTelemetry(impressionId, abandonmentReason); + } + + item.browserTelemetryStateMap.delete(browser); + item.count--; + } + + if (!item.count) { + this._browserInfoByURL.delete(url); + } + } + } + + /** + * Parts of the URL, like search params and hashes, may be mutated by scripts + * on a page we're tracking. Since we don't want to keep track of that + * ourselves in order to keep the list of browser objects a weak-referenced + * set, we do optional fuzzy matching of URLs to fetch the most relevant item + * that contains tracking information. + * + * @param {string} url URL to fetch the tracking data for. + * @returns {object} Map containing the following members: + * - {WeakMap} browsers + * Map of browser elements that belong to `url` and their ad report state. + * - {object} info + * Info dictionary as returned by `_checkURLForSerpMatch`. + * - {number} count + * The number of browser element we can most accurately tell we're + * tracking, since they're inside a WeakMap. + */ + _findBrowserItemForURL(url) { + try { + url = new URL(url); + } catch (ex) { + return null; + } + + const compareURLs = (url1, url2) => { + // In case of an exact match, well, that's an obvious winner. + if (url1.href == url2.href) { + return Infinity; + } + + // Each step we get closer to the two URLs being the same, we increase the + // score. The consumer of this method will use these scores to see which + // of the URLs is the best match. + let score = 0; + if (url1.hostname == url2.hostname) { + ++score; + if (url1.pathname == url2.pathname) { + ++score; + for (let [key1, value1] of url1.searchParams) { + // Let's not fuss about the ordering of search params, since the + // score effect will solve that. + if (url2.searchParams.has(key1)) { + ++score; + if (url2.searchParams.get(key1) == value1) { + ++score; + } + } + } + if (url1.hash == url2.hash) { + ++score; + } + } + } + return score; + }; + + let item; + let currentBestMatch = 0; + for (let [trackingURL, candidateItem] of this._browserInfoByURL) { + if (currentBestMatch === Infinity) { + break; + } + try { + // Make sure to cache the parsed URL object, since there's no reason to + // do it twice. + trackingURL = + candidateItem._trackingURL || + (candidateItem._trackingURL = new URL(trackingURL)); + } catch (ex) { + continue; + } + let score = compareURLs(url, trackingURL); + if (score > currentBestMatch) { + item = candidateItem; + currentBestMatch = score; + } + } + + return item; + } + + // nsIWindowMediatorListener + + /** + * This is called when a new window is opened, and handles registration of + * that window if it is a browser window. + * + * @param {nsIAppWindow} appWin The xul window that was opened. + */ + onOpenWindow(appWin) { + let win = appWin.docShell.domWindow; + win.addEventListener( + "load", + () => { + if ( + win.document.documentElement.getAttribute("windowtype") != + "navigator:browser" + ) { + return; + } + + this._registerWindow(win); + }, + { once: true } + ); + } + + /** + * Listener that is called when a window is closed, and handles deregistration of + * that window if it is a browser window. + * + * @param {nsIAppWindow} appWin The xul window that was closed. + */ + onCloseWindow(appWin) { + let win = appWin.docShell.domWindow; + + if ( + win.document.documentElement.getAttribute("windowtype") != + "navigator:browser" + ) { + return; + } + + this._unregisterWindow(win); + } + + /** + * Adds event listeners for the window and registers it with the content handler. + * + * @param {object} win The window to register. + */ + _registerWindow(win) { + win.gBrowser.tabContainer.addEventListener("TabClose", this); + } + + /** + * Removes event listeners for the window and unregisters it with the content + * handler. + * + * @param {object} win The window to unregister. + */ + _unregisterWindow(win) { + for (let tab of win.gBrowser.tabs) { + this.stopTrackingBrowser( + tab.linkedBrowser, + SearchSERPTelemetryUtils.ABANDONMENTS.WINDOW_CLOSE + ); + } + + win.gBrowser.tabContainer.removeEventListener("TabClose", this); + } + + /** + * Searches for provider information for a given url. + * + * @param {string} url The url to match for a provider. + * @returns {Array | null} Returns an array of provider name and the provider information. + */ + _getProviderInfoForURL(url) { + return this._searchProviderInfo.find(info => + info.searchPageRegexp.test(url) + ); + } + + /** + * Checks to see if a url is a search partner location, and determines the + * provider and codes used. + * + * @param {string} url The url to match. + * @returns {null|object} Returns null if there is no match found. Otherwise, + * returns an object of strings for provider, code and type. + */ + _checkURLForSerpMatch(url) { + let searchProviderInfo = this._getProviderInfoForURL(url); + if (!searchProviderInfo) { + return null; + } + // Some URLs can match provider info but also be the provider's homepage + // instead of a SERP. + // e.g. https://example.com/ vs. https://example.com/?foo=bar + // To check this, we look for the presence of the query parameter + // that contains a search term. + let queries = new URLSearchParams(url.split("#")[0].split("?")[1]); + if (!queries.get(searchProviderInfo.queryParamName)) { + return null; + } + // Default to organic to simplify things. + // We override type in the sap cases. + let type = "organic"; + let code; + if (searchProviderInfo.codeParamName) { + code = queries.get(searchProviderInfo.codeParamName); + if (code) { + // The code is only included if it matches one of the specific ones. + if (searchProviderInfo.taggedCodes.includes(code)) { + type = "tagged"; + if ( + searchProviderInfo.followOnParamNames && + searchProviderInfo.followOnParamNames.some(p => queries.has(p)) + ) { + type += "-follow-on"; + } + } else if (searchProviderInfo.organicCodes.includes(code)) { + type = "organic"; + } else if (searchProviderInfo.expectedOrganicCodes?.includes(code)) { + code = "none"; + } else { + code = "other"; + } + } else if (searchProviderInfo.followOnCookies) { + // Especially Bing requires lots of extra work related to cookies. + for (let followOnCookie of searchProviderInfo.followOnCookies) { + if (followOnCookie.extraCodeParamName) { + let eCode = queries.get(followOnCookie.extraCodeParamName); + if ( + !eCode || + !followOnCookie.extraCodePrefixes.some(p => eCode.startsWith(p)) + ) { + continue; + } + } + + // If this cookie is present, it's probably an SAP follow-on. + // This might be an organic follow-on in the same session, but there + // is no way to tell the difference. + for (let cookie of Services.cookies.getCookiesFromHost( + followOnCookie.host, + {} + )) { + if (cookie.name != followOnCookie.name) { + continue; + } + + let [cookieParam, cookieValue] = cookie.value + .split("=") + .map(p => p.trim()); + if ( + cookieParam == followOnCookie.codeParamName && + searchProviderInfo.taggedCodes.includes(cookieValue) + ) { + type = "tagged-follow-on"; + code = cookieValue; + break; + } + } + } + } + } + let isShoppingPage = false; + let hasComponents = false; + if (lazy.serpEventsEnabled) { + if (searchProviderInfo.shoppingTab?.regexp) { + isShoppingPage = searchProviderInfo.shoppingTab.regexp.test(url); + } + if (searchProviderInfo.components?.length) { + hasComponents = true; + } + } + return { + provider: searchProviderInfo.telemetryId, + type, + code, + isShoppingPage, + hasComponents, + }; + } + + /** + * Logs telemetry for a search provider visit. + * + * @param {object} info The search provider information. + * @param {string} info.provider The name of the provider. + * @param {string} info.type The type of search. + * @param {string} [info.code] The code for the provider. + * @param {string} source Where the search originated from. + * @param {string} url The url that was matched (for debug logging only). + */ + _reportSerpPage(info, source, url) { + let payload = `${info.provider}:${info.type}:${info.code || "none"}`; + Services.telemetry.keyedScalarAdd( + SEARCH_CONTENT_SCALAR_BASE + source, + payload, + 1 + ); + lazy.logConsole.debug("Impression:", payload, url); + } +} + +/** + * ContentHandler deals with handling telemetry of the content within a tab - + * when ads detected and when they are selected. + */ +class ContentHandler { + /** + * Constructor. + * + * @param {object} options + * The options for the handler. + * @param {Map} options.browserInfoByURL + * The map of urls from TelemetryHandler. + * @param {Function} options.getProviderInfoForURL + * A function that obtains the provider information for a url. + */ + constructor(options) { + this._browserInfoByURL = options.browserInfoByURL; + this._findBrowserItemForURL = options.findBrowserItemForURL; + this._checkURLForSerpMatch = options.checkURLForSerpMatch; + } + + /** + * Initializes the content handler. This will also set up the shared data that is + * shared with the SearchTelemetryChild actor. + * + * @param {Array} providerInfo + * The provider information for the search telemetry to record. + */ + init(providerInfo) { + Services.ppmm.sharedData.set("SearchTelemetry:ProviderInfo", providerInfo); + + Services.obs.addObserver(this, "http-on-examine-response"); + Services.obs.addObserver(this, "http-on-examine-cached-response"); + Services.obs.addObserver(this, "http-on-stop-request"); + } + + /** + * Uninitializes the content handler. + */ + uninit() { + Services.obs.removeObserver(this, "http-on-examine-response"); + Services.obs.removeObserver(this, "http-on-examine-cached-response"); + Services.obs.removeObserver(this, "http-on-stop-request"); + } + + /** + * Test-only function to override the search provider information for use + * with tests. Passes it to the SearchTelemetryChild actor. + * + * @param {object} providerInfo @see SEARCH_PROVIDER_INFO for type information. + */ + overrideSearchTelemetryForTests(providerInfo) { + Services.ppmm.sharedData.set("SearchTelemetry:ProviderInfo", providerInfo); + } + + /** + * Reports bandwidth used by the given channel if it is used by search requests. + * + * @param {object} aChannel The channel that generated the activity. + */ + _reportChannelBandwidth(aChannel) { + if (!(aChannel instanceof Ci.nsIChannel)) { + return; + } + let wrappedChannel = ChannelWrapper.get(aChannel); + + let getTopURL = channel => { + // top-level document + if ( + channel.loadInfo && + channel.loadInfo.externalContentPolicyType == + Ci.nsIContentPolicy.TYPE_DOCUMENT + ) { + return channel.finalURL; + } + + // iframe + let frameAncestors; + try { + frameAncestors = channel.frameAncestors; + } catch (e) { + frameAncestors = null; + } + if (frameAncestors) { + let ancestor = frameAncestors.find(obj => obj.frameId == 0); + if (ancestor) { + return ancestor.url; + } + } + + // top-level resource + if (channel.loadInfo && channel.loadInfo.loadingPrincipal) { + return channel.loadInfo.loadingPrincipal.spec; + } + + return null; + }; + + let topUrl = getTopURL(wrappedChannel); + if (!topUrl) { + return; + } + + let info = this._checkURLForSerpMatch(topUrl); + if (!info) { + return; + } + + let bytesTransferred = + wrappedChannel.requestSize + wrappedChannel.responseSize; + let { provider } = info; + + let isPrivate = + wrappedChannel.loadInfo && + wrappedChannel.loadInfo.originAttributes.privateBrowsingId > 0; + if (isPrivate) { + provider += `-${SEARCH_TELEMETRY_PRIVATE_BROWSING_KEY_SUFFIX}`; + } + + Services.telemetry.keyedScalarAdd( + SEARCH_DATA_TRANSFERRED_SCALAR, + provider, + bytesTransferred + ); + } + + observe(aSubject, aTopic, aData) { + switch (aTopic) { + case "http-on-stop-request": + this._reportChannelBandwidth(aSubject); + break; + case "http-on-examine-response": + case "http-on-examine-cached-response": + this.observeActivity(aSubject); + break; + } + } + + /** + * Listener that observes network activity, so that we can determine if a link + * from a search provider page was followed, and if then if that link was an + * ad click or not. + * + * @param {nsIChannel} channel The channel that generated the activity. + */ + observeActivity(channel) { + if (!(channel instanceof Ci.nsIChannel)) { + return; + } + + let wrappedChannel = ChannelWrapper.get(channel); + // The channel we're observing might be a redirect of a channel we've + // observed before. + if (wrappedChannel._adClickRecorded) { + lazy.logConsole.debug("Ad click already recorded"); + return; + // When _adClickRecorded is false but _recordedClick is true, it means we + // recorded a non-ad link click, and it is being re-directed. + } else if (wrappedChannel._recordedClick) { + lazy.logConsole.debug("Non ad-click already recorded"); + return; + } + + Services.tm.dispatchToMainThread(() => { + // We suspect that No Content (204) responses are used to transfer or + // update beacons. They used to lead to double-counting ad-clicks, so let's + // ignore them. + if (wrappedChannel.statusCode == 204) { + lazy.logConsole.debug("Ignoring activity from ambiguous responses"); + return; + } + + // The wrapper is consistent across redirects, so we can use it to track state. + let originURL = wrappedChannel.originURI && wrappedChannel.originURI.spec; + let item = this._findBrowserItemForURL(originURL); + if (!originURL || !item) { + return; + } + + let URL = wrappedChannel.finalURL; + + let providerInfo = item.info.provider; + let info = this._searchProviderInfo.find(provider => { + return provider.telemetryId == providerInfo; + }); + + // Some channels re-direct by loading pages that return 200. The result + // is the channel will have an originURL that changes from the SERP to + // either a nonAdsRegexp or an extraAdServersRegexps. This is typical + // for loading a page in a new tab. The channel will have changed so any + // properties attached to them to record state (e.g. _recordedClick) + // won't be present. + if ( + info.nonAdsLinkRegexps.some(r => r.test(originURL)) || + info.extraAdServersRegexps.some(r => r.test(originURL)) + ) { + return; + } + + // A click event is recorded if a user loads a resource from an + // originURL that is a SERP. + // + // Typically, we only want top level loads containing documents to avoid + // recording any event on an in-page resource a SERP might load + // (e.g. CSS files). + // + // The exception to this is if a subframe loads a resource that matches + // a non ad link. Some SERPs encode non ad search results with a URL + // that gets loaded into an iframe, which then tells the container of + // the iframe to change the location of the page. + if ( + lazy.serpEventsEnabled && + channel.isDocument && + (channel.loadInfo.isTopLevelLoad || + info.nonAdsLinkRegexps.some(r => r.test(URL))) + ) { + let browser = wrappedChannel.browserElement; + // If the load is from history, don't record an event. + if ( + browser?.browsingContext.webProgress?.loadType & + Ci.nsIDocShell.LOAD_CMD_HISTORY + ) { + lazy.logConsole.debug("Ignoring load from history"); + return; + } + + // Step 1: Check if the browser associated with the request was a + // tracked SERP. + let start = Cu.now(); + let telemetryState; + let isFromNewtab = false; + if (item.browserTelemetryStateMap.has(browser)) { + // Current browser is tracked. + telemetryState = item.browserTelemetryStateMap.get(browser); + } else if (browser) { + // Current browser might have been created by a browser in a + // different tab. + let tabBrowser = browser.getTabBrowser(); + let tab = tabBrowser.getTabForBrowser(browser).openerTab; + telemetryState = item.browserTelemetryStateMap.get(tab.linkedBrowser); + if (telemetryState) { + isFromNewtab = true; + } + } + + // Step 2: If we have telemetryState, the browser object must be + // associated with another browser that is tracked. Try to find the + // component type on the SERP responsible for the request. + // Exceptions: + // - If a searchbox was used to initiate the load, don't record another + // engagement because the event was logged elsewhere. + // - If the ad impression hasn't been recorded yet, we have no way of + // knowing precisely what kind of component was selected. + let isSerp = false; + if ( + telemetryState && + telemetryState.adImpressionsReported && + !telemetryState.searchBoxSubmitted + ) { + if (info.searchPageRegexp?.test(originURL)) { + isSerp = true; + } + + // Determine the "type" of the link. + let type = telemetryState.hrefToComponentMap?.get(URL); + // The SERP provider may have modified the url with different query + // parameters, so try checking all the recorded hrefs to see if any + // look similar. + if (!type) { + for (let [ + href, + componentType, + ] of telemetryState.hrefToComponentMap.entries()) { + if (URL.startsWith(href)) { + type = componentType; + break; + } + } + } + + // Default value for URLs that don't match any components categorized + // on the page. + if (!type) { + type = SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK; + } + + if ( + type == SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS + ) { + SearchSERPTelemetry.setBrowserContentSource( + browser, + SearchSERPTelemetryUtils.INCONTENT_SOURCES.REFINE_ON_SERP + ); + } else if (isSerp && isFromNewtab) { + SearchSERPTelemetry.setBrowserContentSource( + browser, + SearchSERPTelemetryUtils.INCONTENT_SOURCES.OPENED_IN_NEW_TAB + ); + } + + // Step 3: Record the engagement. + impressionIdsWithoutEngagementsSet.delete( + telemetryState.impressionId + ); + Glean.serp.engagement.record({ + impression_id: telemetryState.impressionId, + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: type, + }); + lazy.logConsole.debug("Counting click:", { + impressionId: telemetryState.impressionId, + type, + URL, + }); + // Prevent re-directed channels from being examined more than once. + wrappedChannel._recordedClick = true; + } + ChromeUtils.addProfilerMarker( + "SearchSERPTelemetry._observeActivity", + start, + "Maybe record user engagement." + ); + } + + if (!info.extraAdServersRegexps?.some(regex => regex.test(URL))) { + return; + } + + try { + Services.telemetry.keyedScalarAdd( + SEARCH_AD_CLICKS_SCALAR_BASE + item.source, + `${info.telemetryId}:${item.info.type}`, + 1 + ); + wrappedChannel._adClickRecorded = true; + if (item.newtabSessionId) { + Glean.newtabSearchAd.click.record({ + newtab_visit_id: item.newtabSessionId, + search_access_point: item.source, + is_follow_on: item.info.type.endsWith("follow-on"), + is_tagged: item.info.type.startsWith("tagged"), + telemetry_id: item.info.provider, + }); + } + + lazy.logConsole.debug("Counting ad click in page for:", { + source: item.source, + originURL, + URL, + }); + } catch (e) { + console.error(e); + } + }); + } + + /** + * Logs telemetry for a page with adverts, if it is one of the partner search + * provider pages that we're tracking. + * + * @param {object} info + * The search provider information for the page. + * @param {boolean} info.hasAds + * Whether or not the page has adverts. + * @param {string} info.url + * The url of the page. + * @param {object} browser + * The browser associated with the page. + */ + _reportPageWithAds(info, browser) { + let item = this._findBrowserItemForURL(info.url); + if (!item) { + lazy.logConsole.warn( + "Expected to report URI for", + info.url, + "with ads but couldn't find the information" + ); + return; + } + + let telemetryState = item.browserTelemetryStateMap.get(browser); + if (telemetryState.adsReported) { + lazy.logConsole.debug( + "Ad was previously reported for browser with URI", + info.url + ); + return; + } + + lazy.logConsole.debug( + "Counting ads in page for", + item.info.provider, + item.info.type, + item.source, + info.url + ); + Services.telemetry.keyedScalarAdd( + SEARCH_WITH_ADS_SCALAR_BASE + item.source, + `${item.info.provider}:${item.info.type}`, + 1 + ); + + telemetryState.adsReported = true; + + if (item.newtabSessionId) { + Glean.newtabSearchAd.impression.record({ + newtab_visit_id: item.newtabSessionId, + search_access_point: item.source, + is_follow_on: item.info.type.endsWith("follow-on"), + is_tagged: item.info.type.startsWith("tagged"), + telemetry_id: item.info.provider, + }); + } + } + + /** + * Logs ad impression telemetry for a page with adverts, if it is + * one of the partner search provider pages that we're tracking. + * + * @param {object} info + * The search provider information for the page. + * @param {string} info.url + * The url of the page. + * @param {Map<string, object>} info.adImpressions + * A map of ad impressions found for the page, where the key + * is the type of ad component and the value is an object + * containing the number of ads that were loaded, visible, + * and hidden. + * @param {Map<string, string>} info.hrefToComponentMap + * A map of hrefs to their component type. Contains both ads + * and non-ads. + * @param {object} browser + * The browser associated with the page. + */ + _reportPageWithAdImpressions(info, browser) { + let item = this._findBrowserItemForURL(info.url); + if (!item) { + return; + } + let telemetryState = item.browserTelemetryStateMap.get(browser); + if ( + lazy.serpEventsEnabled && + info.adImpressions && + telemetryState && + !telemetryState.adImpressionsReported + ) { + for (let [componentType, data] of info.adImpressions.entries()) { + lazy.logConsole.debug("Counting ad:", { type: componentType, ...data }); + Glean.serp.adImpression.record({ + impression_id: telemetryState.impressionId, + component: componentType, + ads_loaded: data.adsLoaded, + ads_visible: data.adsVisible, + ads_hidden: data.adsHidden, + }); + } + telemetryState.hrefToComponentMap = info.hrefToComponentMap; + telemetryState.adImpressionsReported = true; + Services.obs.notifyObservers(null, "reported-page-with-ad-impressions"); + } + } + + /** + * Records a page action from a SERP page. Normally, actions are tracked in + * parent process by observing network events but some actions are not + * possible to detect outside of subscribing to the child process. + * + * @param {object} info + * The search provider infomation for the page. + * @param {string} info.type + * The component type that was clicked on. + * @param {string} info.action + * The action taken on the page. + * @param {object} browser + * The browser associated with the page. + */ + _reportPageAction(info, browser) { + let item = this._findBrowserItemForURL(info.url); + if (!item) { + return; + } + let telemetryState = item.browserTelemetryStateMap.get(browser); + let impressionId = telemetryState?.impressionId; + if (info.type && impressionId) { + lazy.logConsole.debug(`Recorded page action:`, { + impressionId: telemetryState.impressionId, + type: info.type, + action: info.action, + }); + Glean.serp.engagement.record({ + impression_id: impressionId, + action: info.action, + target: info.type, + }); + impressionIdsWithoutEngagementsSet.delete(impressionId); + // In-content searches are not be categorized with a type, so they will + // not be picked up in the network processes. + if ( + info.type == SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX && + info.action == SearchSERPTelemetryUtils.ACTIONS.SUBMITTED + ) { + telemetryState.searchBoxSubmitted = true; + SearchSERPTelemetry.setBrowserContentSource( + browser, + SearchSERPTelemetryUtils.INCONTENT_SOURCES.SEARCHBOX + ); + } + } else { + lazy.logConsole.warn( + "Expected to report a", + info.action, + "engagement for", + info.url, + "but couldn't find an impression id." + ); + } + } + + _reportPageImpression(info, browser) { + let item = this._findBrowserItemForURL(info.url); + let telemetryState = item.browserTelemetryStateMap.get(browser); + if (!telemetryState?.impressionInfo) { + lazy.logConsole.debug( + "Could not find telemetry state or impression info." + ); + return; + } + let impressionId = telemetryState.impressionId; + if (impressionId) { + let impressionInfo = telemetryState.impressionInfo; + Glean.serp.impression.record({ + impression_id: impressionId, + provider: impressionInfo.provider, + tagged: impressionInfo.tagged, + partner_code: impressionInfo.partnerCode, + source: impressionInfo.source, + shopping_tab_displayed: info.shoppingTabDisplayed, + is_shopping_page: impressionInfo.isShoppingPage, + }); + lazy.logConsole.debug(`Reported Impression:`, { + impressionId, + ...impressionInfo, + shoppingTabDisplayed: info.shoppingTabDisplayed, + }); + } else { + lazy.logConsole.debug("Could not find an impression id."); + } + } +} + +export var SearchSERPTelemetry = new TelemetryHandler(); diff --git a/browser/components/search/SearchUIUtils.sys.mjs b/browser/components/search/SearchUIUtils.sys.mjs new file mode 100644 index 0000000000..aa1c3f50a1 --- /dev/null +++ b/browser/components/search/SearchUIUtils.sys.mjs @@ -0,0 +1,122 @@ +/* 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/. */ + +/** + * Various utilities for search related UI. + */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +XPCOMUtils.defineLazyGetter(lazy, "SearchUIUtilsL10n", () => { + return new Localization(["browser/search.ftl", "branding/brand.ftl"]); +}); + +export var SearchUIUtils = { + initialized: false, + + init() { + if (!this.initialized) { + Services.obs.addObserver(this, "browser-search-engine-modified"); + + this.initialized = true; + } + }, + + observe(engine, topic, data) { + switch (data) { + case "engine-default": + this.updatePlaceholderNamePreference(engine, false); + break; + case "engine-default-private": + this.updatePlaceholderNamePreference(engine, true); + break; + } + }, + + /** + * Adds an open search engine and handles error UI. + * + * @param {string} locationURL + * The URL where the OpenSearch definition is located. + * @param {string} image + * A URL string to an icon file to be used as the search engine's + * icon. This value may be overridden by an icon specified in the + * engine description file. + * @param {object} browsingContext + * The browsing context any error prompt should be opened for. + */ + async addOpenSearchEngine(locationURL, image, browsingContext) { + try { + await Services.search.addOpenSearchEngine(locationURL, image); + } catch (ex) { + let titleMsgName; + let descMsgName; + switch (ex.result) { + case Ci.nsISearchService.ERROR_DUPLICATE_ENGINE: + titleMsgName = "opensearch-error-duplicate-title"; + descMsgName = "opensearch-error-duplicate-desc"; + break; + case Ci.nsISearchService.ERROR_ENGINE_CORRUPTED: + titleMsgName = "opensearch-error-format-title"; + descMsgName = "opensearch-error-format-desc"; + break; + default: + // i.e. ERROR_DOWNLOAD_FAILURE + titleMsgName = "opensearch-error-download-title"; + descMsgName = "opensearch-error-download-desc"; + break; + } + + let [title, text] = await lazy.SearchUIUtilsL10n.formatValues([ + { + id: titleMsgName, + }, + { + id: descMsgName, + args: { + "location-url": locationURL, + }, + }, + ]); + + Services.prompt.alertBC( + browsingContext, + Ci.nsIPrompt.MODAL_TYPE_CONTENT, + title, + text + ); + return false; + } + return true; + }, + + /** + * Returns the URL to use for where to get more search engines. + * + * @returns {string} + */ + get searchEnginesURL() { + return Services.urlFormatter.formatURLPref( + "browser.search.searchEnginesURL" + ); + }, + + /** + * Update the placeholderName preference for the default search engine. + * + * @param {SearchEngine} engine The new default search engine. + * @param {boolean} isPrivate Whether this change applies to private windows. + */ + updatePlaceholderNamePreference(engine, isPrivate) { + const prefName = + "browser.urlbar.placeholderName" + (isPrivate ? ".private" : ""); + if (engine.isAppProvided) { + Services.prefs.setStringPref(prefName, engine.name); + } else { + Services.prefs.clearUserPref(prefName); + } + }, +}; diff --git a/browser/components/search/content/autocomplete-popup.js b/browser/components/search/content/autocomplete-popup.js new file mode 100644 index 0000000000..7732f2bbb2 --- /dev/null +++ b/browser/components/search/content/autocomplete-popup.js @@ -0,0 +1,289 @@ +/* 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"; + +// Wrap in a block to prevent leaking to window scope. +{ + ChromeUtils.defineESModuleGetters(this, { + SearchOneOffs: "resource:///modules/SearchOneOffs.sys.mjs", + }); + + /** + * A richlistbox popup custom element for for a browser search autocomplete + * widget. + */ + class MozSearchAutocompleteRichlistboxPopup extends MozElements.MozAutocompleteRichlistboxPopup { + constructor() { + super(); + + this.addEventListener("popupshowing", event => { + // First handle deciding if we are showing the reduced version of the + // popup containing only the preferences button. We do this if the + // glass icon has been clicked if the text field is empty. + if (this.searchbar.hasAttribute("showonlysettings")) { + this.searchbar.removeAttribute("showonlysettings"); + this.setAttribute("showonlysettings", "true"); + + // Setting this with an xbl-inherited attribute gets overridden the + // second time the user clicks the glass icon for some reason... + this.richlistbox.collapsed = true; + } else { + this.removeAttribute("showonlysettings"); + // Uncollapse as long as we have a view which has >= 1 row. + // The autocomplete binding itself will take care of uncollapsing later, + // if we currently have no rows but end up having some in the future + // when the search string changes + this.richlistbox.collapsed = this.matchCount == 0; + } + + // Show the current default engine in the top header of the panel. + this.updateHeader().catch(console.error); + + this._oneOffButtons.addEventListener( + "SelectedOneOffButtonChanged", + this + ); + }); + + this.addEventListener("popuphiding", event => { + this._oneOffButtons.removeEventListener( + "SelectedOneOffButtonChanged", + this + ); + }); + + /** + * This handles clicks on the topmost "Foo Search" header in the + * popup (hbox.search-panel-header]). + */ + this.addEventListener("click", event => { + if (event.button == 2) { + // Ignore right clicks. + return; + } + let button = event.originalTarget; + let engine = button.parentNode.engine; + if (!engine) { + return; + } + this.oneOffButtons.handleSearchCommand(event, engine); + }); + + this._bundle = null; + } + + static get inheritedAttributes() { + return { + ".search-panel-current-engine": "showonlysettings", + ".searchbar-engine-image": "src", + }; + } + + // We override this because even though we have a shadow root, we want our + // inheritance to be done on the light tree. + getElementForAttrInheritance(selector) { + return this.querySelector(selector); + } + + initialize() { + super.initialize(); + this.initializeAttributeInheritance(); + + this._searchOneOffsContainer = this.querySelector(".search-one-offs"); + this._searchbarEngine = this.querySelector(".search-panel-header"); + this._searchbarEngineName = this.querySelector(".searchbar-engine-name"); + this._oneOffButtons = new SearchOneOffs(this._searchOneOffsContainer); + this._searchbar = document.getElementById("searchbar"); + } + + get oneOffButtons() { + if (!this._oneOffButtons) { + this.initialize(); + } + return this._oneOffButtons; + } + + static get markup() { + return ` + <hbox class="search-panel-header search-panel-current-engine"> + <image class="searchbar-engine-image"/> + <label class="searchbar-engine-name" flex="1" crop="end" role="presentation"/> + </hbox> + <menuseparator class="searchbar-separator"/> + <richlistbox class="autocomplete-richlistbox search-panel-tree"/> + <menuseparator class="searchbar-separator"/> + <hbox class="search-one-offs" is_searchbar="true"/> + `; + } + + get searchOneOffsContainer() { + if (!this._searchOneOffsContainer) { + this.initialize(); + } + return this._searchOneOffsContainer; + } + + get searchbarEngine() { + if (!this._searchbarEngine) { + this.initialize(); + } + return this._searchbarEngine; + } + + get searchbarEngineName() { + if (!this._searchbarEngineName) { + this.initialize(); + } + return this._searchbarEngineName; + } + + get searchbar() { + if (!this._searchbar) { + this.initialize(); + } + return this._searchbar; + } + + get bundle() { + if (!this._bundle) { + const kBundleURI = "chrome://browser/locale/search.properties"; + this._bundle = Services.strings.createBundle(kBundleURI); + } + return this._bundle; + } + + openAutocompletePopup(aInput, aElement) { + // initially the panel is hidden + // to avoid impacting startup / new window performance + aInput.popup.hidden = false; + + // this method is defined on the base binding + this._openAutocompletePopup(aInput, aElement); + } + + onPopupClick(aEvent) { + // Ignore all right-clicks + if (aEvent.button == 2) { + return; + } + + this.searchbar.telemetrySelectedIndex = this.selectedIndex; + + // Check for unmodified left-click, and use default behavior + if ( + aEvent.button == 0 && + !aEvent.shiftKey && + !aEvent.ctrlKey && + !aEvent.altKey && + !aEvent.metaKey + ) { + this.input.controller.handleEnter(true, aEvent); + return; + } + + // Check for middle-click or modified clicks on the search bar + BrowserSearchTelemetry.recordSearchSuggestionSelectionMethod( + aEvent, + "searchbar", + this.selectedIndex + ); + + // Handle search bar popup clicks + let search = this.input.controller.getValueAt(this.selectedIndex); + + // open the search results according to the clicking subtlety + let where = whereToOpenLink(aEvent, false, true); + let params = {}; + + // But open ctrl/cmd clicks on autocomplete items in a new background tab. + let modifier = + AppConstants.platform == "macosx" ? aEvent.metaKey : aEvent.ctrlKey; + if ( + where == "tab" && + MouseEvent.isInstance(aEvent) && + (aEvent.button == 1 || modifier) + ) { + params.inBackground = true; + } + + // leave the popup open for background tab loads + if (!(where == "tab" && params.inBackground)) { + // close the autocomplete popup and revert the entered search term + this.closePopup(); + this.input.controller.handleEscape(); + } + + this.searchbar.doSearch(search, where, null, params); + if (where == "tab" && params.inBackground) { + this.searchbar.focus(); + } else { + this.searchbar.value = search; + } + } + + async updateHeader(engine) { + if (!engine) { + if (PrivateBrowsingUtils.isWindowPrivate(window)) { + engine = await Services.search.getDefaultPrivate(); + } else { + engine = await Services.search.getDefault(); + } + } + + let uri = engine.iconURI; + if (uri) { + this.setAttribute("src", uri.spec); + } else { + // If the default has just been changed to a provider without icon, + // avoid showing the icon of the previous default provider. + this.removeAttribute("src"); + } + + let headerText = this.bundle.formatStringFromName("searchHeader", [ + engine.name, + ]); + this.searchbarEngineName.setAttribute("value", headerText); + this.searchbarEngine.engine = engine; + } + + /** + * This is called when a one-off is clicked and when "search in new tab" + * is selected from a one-off context menu. + */ + /* eslint-disable-next-line valid-jsdoc */ + handleOneOffSearch(event, engine, where, params) { + this.searchbar.handleSearchCommandWhere(event, engine, where, params); + } + + /** + * Passes DOM events for the popup to the _on_<event type> methods. + * + * @param {Event} event + * DOM event from the <popup>. + */ + handleEvent(event) { + let methodName = "_on_" + event.type; + if (methodName in this) { + this[methodName](event); + } else { + throw new Error("Unrecognized UrlbarView event: " + event.type); + } + } + _on_SelectedOneOffButtonChanged() { + let engine = + this.oneOffButtons.selectedButton && + this.oneOffButtons.selectedButton.engine; + this.updateHeader(engine).catch(console.error); + } + } + + customElements.define( + "search-autocomplete-richlistbox-popup", + MozSearchAutocompleteRichlistboxPopup, + { + extends: "panel", + } + ); +} diff --git a/browser/components/search/content/contentSearchHandoffUI.js b/browser/components/search/content/contentSearchHandoffUI.js new file mode 100644 index 0000000000..7c2aaa71b7 --- /dev/null +++ b/browser/components/search/content/contentSearchHandoffUI.js @@ -0,0 +1,152 @@ +/* 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"; + +function ContentSearchHandoffUIController() { + this._isPrivateEngine = false; + this._isAboutPrivateBrowsing = false; + this._engineIcon = null; + + window.addEventListener("ContentSearchService", this); + this._sendMsg("GetEngine"); + this._sendMsg("GetHandoffSearchModePrefs"); +} + +ContentSearchHandoffUIController.prototype = { + handleEvent(event) { + let methodName = "_onMsg" + event.detail.type; + if (methodName in this) { + this[methodName](event.detail.data); + } + }, + + get defaultEngine() { + return this._defaultEngine; + }, + + _onMsgEngine({ isPrivateEngine, isAboutPrivateBrowsing, engine }) { + this._isPrivateEngine = isPrivateEngine; + this._isAboutPrivateBrowsing = isAboutPrivateBrowsing; + this._updateEngine(engine); + }, + + _onMsgCurrentEngine(engine) { + if (!this._isPrivateEngine) { + this._updateEngine(engine); + } + }, + + _onMsgCurrentPrivateEngine(engine) { + if (this._isPrivateEngine) { + this._updateEngine(engine); + } + }, + + _onMsgHandoffSearchModePrefs(pref) { + this._shouldHandOffToSearchMode = pref; + this._updatel10nIds(); + }, + + _updateEngine(engine) { + this._defaultEngine = engine; + if (this._engineIcon) { + URL.revokeObjectURL(this._engineIcon); + } + + // We only show the engines icon for app provided engines, otherwise show + // a default. xref https://bugzilla.mozilla.org/show_bug.cgi?id=1449338#c19 + if (!engine.isAppProvided) { + this._engineIcon = "chrome://global/skin/icons/search-glass.svg"; + } else if (engine.iconData) { + this._engineIcon = this._getFaviconURIFromIconData(engine.iconData); + } else { + this._engineIcon = "chrome://global/skin/icons/defaultFavicon.svg"; + } + + document.body.style.setProperty( + "--newtab-search-icon", + "url(" + this._engineIcon + ")" + ); + this._updatel10nIds(); + }, + + _updatel10nIds() { + let engine = this._defaultEngine; + let fakeButton = document.querySelector(".search-handoff-button"); + let fakeInput = document.querySelector(".fake-textbox"); + if (!fakeButton || !fakeInput) { + return; + } + if (!engine || this._shouldHandOffToSearchMode) { + document.l10n.setAttributes( + fakeButton, + this._isAboutPrivateBrowsing + ? "about-private-browsing-search-btn" + : "newtab-search-box-input" + ); + document.l10n.setAttributes( + fakeInput, + this._isAboutPrivateBrowsing + ? "about-private-browsing-search-placeholder" + : "newtab-search-box-text" + ); + } else if (!engine.isAppProvided) { + document.l10n.setAttributes( + fakeButton, + this._isAboutPrivateBrowsing + ? "about-private-browsing-handoff-no-engine" + : "newtab-search-box-handoff-input-no-engine" + ); + document.l10n.setAttributes( + fakeInput, + this._isAboutPrivateBrowsing + ? "about-private-browsing-handoff-text-no-engine" + : "newtab-search-box-handoff-text-no-engine" + ); + } else { + document.l10n.setAttributes( + fakeButton, + this._isAboutPrivateBrowsing + ? "about-private-browsing-handoff" + : "newtab-search-box-handoff-input", + { + engine: engine.name, + } + ); + document.l10n.setAttributes( + fakeInput, + this._isAboutPrivateBrowsing + ? "about-private-browsing-handoff-text" + : "newtab-search-box-handoff-text", + { + engine: engine.name, + } + ); + } + }, + + // If the favicon is an array buffer, convert it into a Blob URI. + // Otherwise just return the plain URI. + _getFaviconURIFromIconData(data) { + if (typeof data === "string") { + return data; + } + + // If typeof(data) != "string", we assume it's an ArrayBuffer + let blob = new Blob([data]); + return URL.createObjectURL(blob); + }, + + _sendMsg(type, data = null) { + dispatchEvent( + new CustomEvent("ContentSearchClient", { + detail: { + type, + data, + }, + }) + ); + }, +}; diff --git a/browser/components/search/content/contentSearchUI.css b/browser/components/search/content/contentSearchUI.css new file mode 100644 index 0000000000..85b718a3eb --- /dev/null +++ b/browser/components/search/content/contentSearchUI.css @@ -0,0 +1,160 @@ +/* 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/. */ + +.contentSearchSuggestionTable { + background-color: hsla(0,0%,100%,.99); + color: black; + border: 1px solid hsla(0, 0%, 0%, .2); + border-top: none; + box-shadow: 0 5px 10px hsla(0, 0%, 0%, .1); + position: absolute; + inset-inline-start: 0; + z-index: 1001; + user-select: none; + cursor: default; +} + +.contentSearchSuggestionsList { + border-bottom: 1px solid hsl(0, 0%, 92%); + width: 100%; + height: 100%; +} + +.contentSearchSuggestionTable, +.contentSearchSuggestionsList { + border-spacing: 0; + overflow: hidden; + padding: 0; + margin: 0; + text-align: start; +} + +.contentSearchHeaderRow, +.contentSearchSuggestionRow { + margin: 0; + max-width: inherit; + padding: 0; +} + +.contentSearchHeaderRow > td > img, +.contentSearchSuggestionRow > td > .historyIcon { + margin-inline-end: 8px; + margin-bottom: -3px; +} + +.contentSearchSuggestionTable .historyIcon { + width: 16px; + height: 16px; + display: inline-block; + background-image: url("chrome://browser/skin/history.svg"); + -moz-context-properties: fill; + fill: graytext; +} + +.contentSearchSuggestionRow.selected > td > .historyIcon { + fill: HighlightText; +} + +.contentSearchHeader > img { + height: 16px; + width: 16px; + margin: 0; + padding: 0; +} + +.contentSearchSuggestionRow.remote > td > .historyIcon { + visibility: hidden; +} + +.contentSearchSuggestionRow.selected { + background-color: SelectedItem; + color: SelectedItemText; +} + +.contentSearchHeader, +.contentSearchSuggestionEntry { + margin: 0; + max-width: inherit; + overflow: hidden; + padding: 4px 10px; + text-overflow: ellipsis; + white-space: nowrap; + font-size: 75%; +} + +.contentSearchHeader { + background-color: hsl(0, 0%, 97%); + color: #666; + border-bottom: 1px solid hsl(0, 0%, 92%); +} + +.contentSearchSuggestionsContainer { + margin: 0; + padding: 0; + border-spacing: 0; + width: 100%; +} + +.contentSearchSearchWithHeaderSearchText { + white-space: pre; + font-weight: bold; +} + +.contentSearchOneOffItem { + appearance: none; + height: 32px; + margin: 0; + padding: 0; + border: none; + background: none; + background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAWCAYAAAABxvaqAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3gofECQNNVW2/AAAABBJREFUGFdjOHPmzH8GehEA/KpKg9YTf4AAAAAASUVORK5CYII='); + background-repeat: no-repeat; + background-position: right center; +} + +.contentSearchOneOffItem:dir(rtl) { + background-position-x: left; +} + +.contentSearchOneOffItem > img { + width: 16px; + height: 16px; + margin-bottom: -2px; + pointer-events: none; +} + +.contentSearchOneOffItem:not(.last-row) { + border-bottom: 1px solid hsl(0, 0%, 92%); +} + +.contentSearchOneOffItem.end-of-row { + background-image: none; +} + +.contentSearchOneOffItem.selected { + background-color: SelectedItem; + background-image: none; +} + +.contentSearchOneOffsTable { + width: 100%; +} + +.contentSearchSettingsButton { + margin: 0; + padding: 0; + height: 32px; + border: none; + border-top: 1px solid hsla(0, 0%, 0%, .08); + text-align: center; + width: 100%; +} + +.contentSearchSettingsButton.selected { + background-color: hsl(0, 0%, 90%); +} + +.contentSearchSettingsButton:active { + background-color: hsl(0, 0%, 85%); +} diff --git a/browser/components/search/content/contentSearchUI.js b/browser/components/search/content/contentSearchUI.js new file mode 100644 index 0000000000..9c7387d364 --- /dev/null +++ b/browser/components/search/content/contentSearchUI.js @@ -0,0 +1,1021 @@ +/* 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"; + +this.ContentSearchUIController = (function () { + const MAX_DISPLAYED_SUGGESTIONS = 6; + const SUGGESTION_ID_PREFIX = "searchSuggestion"; + const ONE_OFF_ID_PREFIX = "oneOff"; + const HTML_NS = "http://www.w3.org/1999/xhtml"; + + /** + * Creates a new object that manages search suggestions and their UI for a text + * box. + * + * The UI consists of an html:table that's inserted into the DOM after the given + * text box and styled so that it appears as a dropdown below the text box. + * + * @param {DOMElement} inputElement + * Search suggestions will be based on the text in this text box. + * Assumed to be an html:input. + * @param {DOMElement} tableParent + * The suggestion table is appended as a child to this element. Since + * the table is absolutely positioned and its top and left values are set + * to be relative to the top and left of the page, either the parent and + * all its ancestors should not be positioned elements (i.e., their + * positions should be "static"), or the parent's position should be the + * top left of the page. + * @param {string} healthReportKey + * This will be sent with the search data for BrowserUsageTelemetry to + * record the search. + * @param {string} searchPurpose + * Sent with search data, see nsISearchEngine.getSubmission. + * @param {sring} idPrefix + * The IDs of elements created by the object will be prefixed with this + * string. + */ + function ContentSearchUIController( + inputElement, + tableParent, + healthReportKey, + searchPurpose, + idPrefix = "" + ) { + this.input = inputElement; + this._idPrefix = idPrefix; + this._healthReportKey = healthReportKey; + this._searchPurpose = searchPurpose; + this._isPrivateEngine = false; + + let tableID = idPrefix + "searchSuggestionTable"; + this.input.autocomplete = "off"; + this.input.setAttribute("aria-autocomplete", "true"); + this.input.setAttribute("aria-controls", tableID); + tableParent.appendChild(this._makeTable(tableID)); + + this.input.addEventListener("keydown", this); + this.input.addEventListener("input", this); + this.input.addEventListener("focus", this); + this.input.addEventListener("blur", this); + window.addEventListener("ContentSearchService", this); + + this._stickyInputValue = ""; + this._hideSuggestions(); + + this._getSearchEngines(); + this._getStrings(); + } + + ContentSearchUIController.prototype = { + _oneOffButtons: [], + // Setting up the one off buttons causes an uninterruptible reflow. If we + // receive the list of engines while the newtab page is loading, this reflow + // may regress performance - so we set this flag and only set up the buttons + // if it's set when the suggestions table is actually opened. + _pendingOneOffRefresh: undefined, + + get defaultEngine() { + return this._defaultEngine; + }, + + set defaultEngine(engine) { + if (this._defaultEngine && this._defaultEngine.icon) { + URL.revokeObjectURL(this._defaultEngine.icon); + } + let icon; + if (engine.iconData) { + icon = this._getFaviconURIFromIconData(engine.iconData); + } else { + icon = "chrome://global/skin/icons/defaultFavicon.svg"; + } + this._defaultEngine = { + name: engine.name, + icon, + isAppProvided: engine.isAppProvided, + }; + this._updateDefaultEngineHeader(); + this._updateDefaultEngineIcon(); + + if (engine && document.activeElement == this.input) { + this._speculativeConnect(); + } + }, + + get engines() { + return this._engines; + }, + + set engines(val) { + this._engines = val; + this._pendingOneOffRefresh = true; + }, + + // The selectedIndex is the index of the element with the "selected" class in + // the list obtained by concatenating the suggestion rows, one-off buttons, and + // search settings button. + get selectedIndex() { + let allElts = [ + ...this._suggestionsList.children, + ...this._oneOffButtons, + document.getElementById("contentSearchSettingsButton"), + ]; + for (let i = 0; i < allElts.length; ++i) { + let elt = allElts[i]; + if (elt.classList.contains("selected")) { + return i; + } + } + return -1; + }, + + set selectedIndex(idx) { + // Update the table's rows, and the input when there is a selection. + this._table.removeAttribute("aria-activedescendant"); + this.input.removeAttribute("aria-activedescendant"); + + let allElts = [ + ...this._suggestionsList.children, + ...this._oneOffButtons, + document.getElementById("contentSearchSettingsButton"), + ]; + // If we are selecting a suggestion and a one-off is selected, don't deselect it. + let excludeIndex = + idx < this.numSuggestions && this.selectedButtonIndex > -1 + ? this.numSuggestions + this.selectedButtonIndex + : -1; + for (let i = 0; i < allElts.length; ++i) { + let elt = allElts[i]; + let ariaSelectedElt = i < this.numSuggestions ? elt.firstChild : elt; + if (i == idx) { + elt.classList.add("selected"); + ariaSelectedElt.setAttribute("aria-selected", "true"); + this.input.setAttribute("aria-activedescendant", ariaSelectedElt.id); + } else if (i != excludeIndex) { + elt.classList.remove("selected"); + ariaSelectedElt.setAttribute("aria-selected", "false"); + } + } + }, + + get selectedButtonIndex() { + let elts = [ + ...this._oneOffButtons, + document.getElementById("contentSearchSettingsButton"), + ]; + for (let i = 0; i < elts.length; ++i) { + if (elts[i].classList.contains("selected")) { + return i; + } + } + return -1; + }, + + set selectedButtonIndex(idx) { + let elts = [ + ...this._oneOffButtons, + document.getElementById("contentSearchSettingsButton"), + ]; + for (let i = 0; i < elts.length; ++i) { + let elt = elts[i]; + if (i == idx) { + elt.classList.add("selected"); + elt.setAttribute("aria-selected", "true"); + } else { + elt.classList.remove("selected"); + elt.setAttribute("aria-selected", "false"); + } + } + }, + + get selectedEngineName() { + let selectedElt = this._oneOffsTable.querySelector(".selected"); + if (selectedElt) { + return selectedElt.engineName; + } + return this.defaultEngine.name; + }, + + get numSuggestions() { + return this._suggestionsList.children.length; + }, + + selectAndUpdateInput(idx) { + this.selectedIndex = idx; + let newValue = this.suggestionAtIndex(idx) || this._stickyInputValue; + // Setting the input value when the value has not changed commits the current + // IME composition, which we don't want to do. + if (this.input.value != newValue) { + this.input.value = newValue; + } + this._updateSearchWithHeader(); + }, + + suggestionAtIndex(idx) { + let row = this._suggestionsList.children[idx]; + return row ? row.textContent : null; + }, + + deleteSuggestionAtIndex(idx) { + // Only form history suggestions can be deleted. + if (this.isFormHistorySuggestionAtIndex(idx)) { + let suggestionStr = this.suggestionAtIndex(idx); + this._sendMsg("RemoveFormHistoryEntry", suggestionStr); + this._suggestionsList.children[idx].remove(); + this.selectAndUpdateInput(-1); + } + }, + + isFormHistorySuggestionAtIndex(idx) { + let row = this._suggestionsList.children[idx]; + return row && row.classList.contains("formHistory"); + }, + + addInputValueToFormHistory() { + let entry = { + value: this.input.value, + engineName: this.selectedEngineName, + }; + this._sendMsg("AddFormHistoryEntry", entry); + return entry; + }, + + handleEvent(event) { + // The event handler is triggered by external events while the search + // element may no longer be present + if (!document.contains(this.input)) { + return; + } + this["_on" + event.type[0].toUpperCase() + event.type.substr(1)](event); + }, + + _onCommand(aEvent) { + if (this.selectedButtonIndex == this._oneOffButtons.length) { + // Settings button was selected. + this._sendMsg("ManageEngines"); + return; + } + + this.search(aEvent); + + if (aEvent) { + aEvent.preventDefault(); + } + }, + + search(aEvent) { + if (!this.defaultEngine) { + return; // Not initialized yet. + } + + let searchText = this.input; + let searchTerms; + if ( + this._table.hidden || + (aEvent.originalTarget && + aEvent.originalTarget.id == "contentSearchDefaultEngineHeader") || + aEvent instanceof KeyboardEvent + ) { + searchTerms = searchText.value; + } else { + searchTerms = + this.suggestionAtIndex(this.selectedIndex) || searchText.value; + } + // Send an event that will perform a search and Firefox Health Report will + // record that a search from the healthReportKey passed to the constructor. + let eventData = { + engineName: this.selectedEngineName, + searchString: searchTerms, + healthReportKey: this._healthReportKey, + searchPurpose: this._searchPurpose, + originalEvent: { + shiftKey: aEvent.shiftKey, + ctrlKey: aEvent.ctrlKey, + metaKey: aEvent.metaKey, + altKey: aEvent.altKey, + }, + }; + if ("button" in aEvent) { + eventData.originalEvent.button = aEvent.button; + } + + if (this.suggestionAtIndex(this.selectedIndex)) { + eventData.selection = { + index: this.selectedIndex, + kind: undefined, + }; + if (aEvent instanceof MouseEvent) { + eventData.selection.kind = "mouse"; + } else if (aEvent instanceof KeyboardEvent) { + eventData.selection.kind = "key"; + } + } + + this._sendMsg("Search", eventData); + this.addInputValueToFormHistory(); + }, + + _onInput() { + if (!this.input.value) { + this._stickyInputValue = ""; + this._hideSuggestions(); + } else if (this.input.value != this._stickyInputValue) { + // Only fetch new suggestions if the input value has changed. + this._getSuggestions(); + this.selectAndUpdateInput(-1); + } + this._updateSearchWithHeader(); + }, + + _onKeydown(event) { + let selectedIndexDelta = 0; + let selectedSuggestionDelta = 0; + let selectedOneOffDelta = 0; + + switch (event.keyCode) { + case event.DOM_VK_UP: + if (this._table.hidden) { + return; + } + if (event.getModifierState("Accel")) { + if (event.shiftKey) { + selectedSuggestionDelta = -1; + break; + } + this._cycleCurrentEngine(true); + break; + } + if (event.altKey) { + selectedOneOffDelta = -1; + break; + } + selectedIndexDelta = -1; + break; + case event.DOM_VK_DOWN: + if (this._table.hidden) { + this._getSuggestions(); + return; + } + if (event.getModifierState("Accel")) { + if (event.shiftKey) { + selectedSuggestionDelta = 1; + break; + } + this._cycleCurrentEngine(false); + break; + } + if (event.altKey) { + selectedOneOffDelta = 1; + break; + } + selectedIndexDelta = 1; + break; + case event.DOM_VK_TAB: + if (this._table.hidden) { + return; + } + // Shift+tab when either the first or no one-off is selected, as well as + // tab when the settings button is selected, should change focus as normal. + if ( + (this.selectedButtonIndex <= 0 && event.shiftKey) || + (this.selectedButtonIndex == this._oneOffButtons.length && + !event.shiftKey) + ) { + return; + } + selectedOneOffDelta = event.shiftKey ? -1 : 1; + break; + case event.DOM_VK_RIGHT: + // Allow normal caret movement until the caret is at the end of the input. + if ( + this.input.selectionStart != this.input.selectionEnd || + this.input.selectionEnd != this.input.value.length + ) { + return; + } + if ( + this.numSuggestions && + this.selectedIndex >= 0 && + this.selectedIndex < this.numSuggestions + ) { + this.input.value = this.suggestionAtIndex(this.selectedIndex); + this.input.setAttribute("selection-index", this.selectedIndex); + this.input.setAttribute("selection-kind", "key"); + } else { + // If we didn't select anything, make sure to remove the attributes + // in case they were populated last time. + this.input.removeAttribute("selection-index"); + this.input.removeAttribute("selection-kind"); + } + this._stickyInputValue = this.input.value; + this._hideSuggestions(); + return; + case event.DOM_VK_RETURN: + this._onCommand(event); + return; + case event.DOM_VK_DELETE: + if (this.selectedIndex >= 0) { + this.deleteSuggestionAtIndex(this.selectedIndex); + } + return; + case event.DOM_VK_ESCAPE: + if (!this._table.hidden) { + this._hideSuggestions(); + } + return; + default: + return; + } + + let currentIndex = this.selectedIndex; + if (selectedIndexDelta) { + let newSelectedIndex = currentIndex + selectedIndexDelta; + if (newSelectedIndex < -1) { + newSelectedIndex = this.numSuggestions + this._oneOffButtons.length; + } + // If are moving up from the first one off, we have to deselect the one off + // manually because the selectedIndex setter tries to exclude the selected + // one-off (which is desirable for accel+shift+up/down). + if (currentIndex == this.numSuggestions && selectedIndexDelta == -1) { + this.selectedButtonIndex = -1; + } + this.selectAndUpdateInput(newSelectedIndex); + } else if (selectedSuggestionDelta) { + let newSelectedIndex; + if (currentIndex >= this.numSuggestions || currentIndex == -1) { + // No suggestion already selected, select the first/last one appropriately. + newSelectedIndex = + selectedSuggestionDelta == 1 ? 0 : this.numSuggestions - 1; + } else { + newSelectedIndex = currentIndex + selectedSuggestionDelta; + } + if (newSelectedIndex >= this.numSuggestions) { + newSelectedIndex = -1; + } + this.selectAndUpdateInput(newSelectedIndex); + } else if (selectedOneOffDelta) { + let newSelectedIndex; + let currentButton = this.selectedButtonIndex; + if ( + currentButton == -1 || + currentButton == this._oneOffButtons.length + ) { + // No one-off already selected, select the first/last one appropriately. + newSelectedIndex = + selectedOneOffDelta == 1 ? 0 : this._oneOffButtons.length - 1; + } else { + newSelectedIndex = currentButton + selectedOneOffDelta; + } + // Allow selection of the settings button via the tab key. + if ( + newSelectedIndex == this._oneOffButtons.length && + event.keyCode != event.DOM_VK_TAB + ) { + newSelectedIndex = -1; + } + this.selectedButtonIndex = newSelectedIndex; + } + + // Prevent the input's caret from moving. + event.preventDefault(); + }, + + _currentEngineIndex: -1, + _cycleCurrentEngine(aReverse) { + if ( + (this._currentEngineIndex == this._engines.length - 1 && !aReverse) || + (this._currentEngineIndex == 0 && aReverse) + ) { + return; + } + this._currentEngineIndex += aReverse ? -1 : 1; + let engineName = this._engines[this._currentEngineIndex].name; + this._sendMsg("SetCurrentEngine", engineName); + }, + + _onFocus() { + if (this._mousedown) { + return; + } + // When the input box loses focus to something in our table, we refocus it + // immediately. This causes the focus highlight to flicker, so we set a + // custom attribute which consumers should use for focus highlighting. This + // attribute is removed only when we do not immediately refocus the input + // box, thus eliminating flicker. + this.input.setAttribute("keepfocus", "true"); + this._speculativeConnect(); + }, + + _onBlur() { + if (this._mousedown) { + // At this point, this.input has lost focus, but a new element has not yet + // received it. If we re-focus this.input directly, the new element will + // steal focus immediately, so we queue it instead. + setTimeout(() => this.input.focus(), 0); + return; + } + this.input.removeAttribute("keepfocus"); + this._hideSuggestions(); + }, + + _onMousemove(event) { + let idx = this._indexOfTableItem(event.target); + if (idx >= this.numSuggestions) { + // Deselect any search suggestion that has been selected. + this.selectedIndex = -1; + this.selectedButtonIndex = idx - this.numSuggestions; + return; + } + this.selectedIndex = idx; + }, + + _onMouseup(event) { + if (event.button == 2) { + return; + } + this._onCommand(event); + }, + + _onMouseout(event) { + // We only deselect one-off buttons and the settings button when they are + // moused out. + let idx = this._indexOfTableItem(event.originalTarget); + if (idx >= this.numSuggestions) { + this.selectedButtonIndex = -1; + } + }, + + _onClick(event) { + this._onMouseup(event); + }, + + _onContentSearchService(event) { + let methodName = "_onMsg" + event.detail.type; + if (methodName in this) { + this[methodName](event.detail.data); + } + }, + + _onMsgFocusInput(event) { + this.input.focus(); + }, + + _onMsgBlur(event) { + this.input.blur(); + this._hideSuggestions(); + }, + + _onMsgSuggestions(suggestions) { + // Ignore the suggestions if their search string or engine doesn't match + // ours. Due to the async nature of message passing, this can easily happen + // when the user types quickly. + if ( + this._stickyInputValue != suggestions.searchString || + this.defaultEngine.name != suggestions.engineName + ) { + return; + } + + this._clearSuggestionRows(); + + // Position and size the table. + let { left } = this.input.getBoundingClientRect(); + this._table.style.top = this.input.offsetHeight + "px"; + this._table.style.minWidth = this.input.offsetWidth + "px"; + this._table.style.maxWidth = window.innerWidth - left - 40 + "px"; + + // Add the suggestions to the table. + let searchWords = new Set( + suggestions.searchString.trim().toLowerCase().split(/\s+/) + ); + for (let i = 0; i < MAX_DISPLAYED_SUGGESTIONS; i++) { + let type, idx; + if (i < suggestions.formHistory.length) { + [type, idx] = ["formHistory", i]; + } else { + let j = i - suggestions.formHistory.length; + if (j < suggestions.remote.length) { + [type, idx] = ["remote", j]; + } else { + break; + } + } + this._suggestionsList.appendChild( + this._makeTableRow(type, suggestions[type][idx], i, searchWords) + ); + } + + if (this._table.hidden) { + this.selectedIndex = -1; + if (this._pendingOneOffRefresh) { + this._setUpOneOffButtons(); + delete this._pendingOneOffRefresh; + } + this._currentEngineIndex = this._engines.findIndex( + aEngine => aEngine.name == this.defaultEngine.name + ); + this._table.hidden = false; + this.input.setAttribute("aria-expanded", "true"); + } + }, + + _onMsgSuggestionsCancelled() { + if (!this._table.hidden) { + this._hideSuggestions(); + } + }, + + _onMsgState(state) { + // Not all state messages broadcast the windows' privateness info. + if ("isPrivateWindow" in state) { + this._isPrivateEngine = state.isPrivateEngine; + } + + this.engines = state.engines; + + let currentEngine = state.currentEngine; + if (this._isPrivateEngine) { + currentEngine = state.currentPrivateEngine; + } + + // No point updating the default engine (and the header) if there's no change. + if ( + this.defaultEngine && + this.defaultEngine.name == currentEngine.name && + this.defaultEngine.icon == currentEngine.icon + ) { + return; + } + this.defaultEngine = currentEngine; + }, + + _onMsgCurrentState(state) { + this._onMsgState(state); + }, + + _onMsgCurrentEngine(engine) { + if (this._isPrivateEngine) { + return; + } + this.defaultEngine = engine; + this._pendingOneOffRefresh = true; + }, + + _onMsgCurrentPrivateEngine(engine) { + if (!this._isPrivateEngine) { + return; + } + this.defaultEngine = engine; + this._pendingOneOffRefresh = true; + }, + + _onMsgStrings(strings) { + this._strings = strings; + this._updateDefaultEngineHeader(); + this._updateSearchWithHeader(); + document.getElementById("contentSearchSettingsButton").textContent = + this._strings.searchSettings; + }, + + _updateDefaultEngineIcon() { + // We only show the engine's own icon for app provided engines, otherwise show + // a default. xref https://bugzilla.mozilla.org/show_bug.cgi?id=1449338#c19 + let icon = this.defaultEngine.isAppProvided + ? this.defaultEngine.icon + : "chrome://global/skin/icons/search-glass.svg"; + + document.body.style.setProperty( + "--newtab-search-icon", + "url(" + icon + ")" + ); + }, + + _updateDefaultEngineHeader() { + let header = document.getElementById("contentSearchDefaultEngineHeader"); + header.firstChild.setAttribute("src", this.defaultEngine.icon); + if (!this._strings) { + return; + } + while (header.firstChild.nextSibling) { + header.firstChild.nextSibling.remove(); + } + header.appendChild( + document.createTextNode( + this._strings.searchHeader.replace("%S", this.defaultEngine.name) + ) + ); + }, + + _updateSearchWithHeader() { + if (!this._strings) { + return; + } + let searchWithHeader = document.getElementById( + "contentSearchSearchWithHeader" + ); + let labels = searchWithHeader.querySelectorAll("label"); + if (this.input.value) { + let header = this._strings.searchForSomethingWith2; + // Translators can use both %S and %1$S. + header = header.replace("%1$S", "%S").split("%S"); + labels[0].textContent = header[0]; + labels[1].textContent = this.input.value; + labels[2].textContent = header[1]; + } else { + labels[0].textContent = this._strings.searchWithHeader; + labels[1].textContent = ""; + labels[2].textContent = ""; + } + }, + + _speculativeConnect() { + if (this.defaultEngine) { + this._sendMsg("SpeculativeConnect", this.defaultEngine.name); + } + }, + + _makeTableRow(type, suggestionStr, currentRow, searchWords) { + let row = document.createElementNS(HTML_NS, "tr"); + row.dir = "auto"; + row.classList.add("contentSearchSuggestionRow"); + row.classList.add(type); + row.setAttribute("role", "presentation"); + row.addEventListener("mousemove", this); + row.addEventListener("mouseup", this); + + let entry = document.createElementNS(HTML_NS, "td"); + let img = document.createElementNS(HTML_NS, "div"); + img.setAttribute("class", "historyIcon"); + entry.appendChild(img); + entry.classList.add("contentSearchSuggestionEntry"); + entry.setAttribute("role", "option"); + entry.id = this._idPrefix + SUGGESTION_ID_PREFIX + currentRow; + entry.setAttribute("aria-selected", "false"); + + let suggestionWords = suggestionStr.trim().toLowerCase().split(/\s+/); + for (let i = 0; i < suggestionWords.length; i++) { + let word = suggestionWords[i]; + let wordSpan = document.createElementNS(HTML_NS, "span"); + if (searchWords.has(word)) { + wordSpan.classList.add("typed"); + } + wordSpan.textContent = word; + entry.appendChild(wordSpan); + if (i < suggestionWords.length - 1) { + entry.appendChild(document.createTextNode(" ")); + } + } + + row.appendChild(entry); + return row; + }, + + // If the favicon is an array buffer, convert it into a Blob URI. + // Otherwise just return the plain URI. + _getFaviconURIFromIconData(data) { + if (typeof data == "string") { + return data; + } + + // If typeof(data) != "string", we assume it's an ArrayBuffer + let blob = new Blob([data]); + return URL.createObjectURL(blob); + }, + + // Adds "@2x" to the name of the given PNG url for "retina" screens. + _getImageURIForCurrentResolution(uri) { + if (window.devicePixelRatio > 1) { + return uri.replace(/\.png$/, "@2x.png"); + } + return uri; + }, + + _getSearchEngines() { + this._sendMsg("GetState"); + }, + + _getStrings() { + this._sendMsg("GetStrings"); + }, + + _getSuggestions() { + this._stickyInputValue = this.input.value; + if (this.defaultEngine) { + this._sendMsg("GetSuggestions", { + engineName: this.defaultEngine.name, + searchString: this.input.value, + }); + } + }, + + _clearSuggestionRows() { + while (this._suggestionsList.firstElementChild) { + this._suggestionsList.firstElementChild.remove(); + } + }, + + _hideSuggestions() { + this.input.setAttribute("aria-expanded", "false"); + this.selectedIndex = -1; + this.selectedButtonIndex = -1; + this._currentEngineIndex = -1; + this._table.hidden = true; + }, + + _indexOfTableItem(elt) { + if (elt.classList.contains("contentSearchOneOffItem")) { + return this.numSuggestions + this._oneOffButtons.indexOf(elt); + } + if (elt.classList.contains("contentSearchSettingsButton")) { + return this.numSuggestions + this._oneOffButtons.length; + } + while (elt && elt.localName != "tr") { + elt = elt.parentNode; + } + if (!elt) { + throw new Error("Element is not a row"); + } + return elt.rowIndex; + }, + + _makeTable(id) { + this._table = document.createElementNS(HTML_NS, "table"); + this._table.id = id; + this._table.hidden = true; + this._table.classList.add("contentSearchSuggestionTable"); + this._table.setAttribute("role", "presentation"); + + // When the search input box loses focus, we want to immediately give focus + // back to it if the blur was because the user clicked somewhere in the table. + // onBlur uses the _mousedown flag to detect this. + this._table.addEventListener("mousedown", () => { + this._mousedown = true; + }); + document.addEventListener("mouseup", () => { + delete this._mousedown; + }); + + // Deselect the selected element on mouseout if it wasn't a suggestion. + this._table.addEventListener("mouseout", this); + + let headerRow = document.createElementNS(HTML_NS, "tr"); + let header = document.createElementNS(HTML_NS, "td"); + headerRow.setAttribute("class", "contentSearchHeaderRow"); + header.setAttribute("class", "contentSearchHeader"); + let iconImg = document.createElementNS(HTML_NS, "img"); + header.appendChild(iconImg); + header.id = "contentSearchDefaultEngineHeader"; + headerRow.appendChild(header); + headerRow.addEventListener("click", this); + this._table.appendChild(headerRow); + + let row = document.createElementNS(HTML_NS, "tr"); + row.setAttribute("class", "contentSearchSuggestionsContainer"); + let cell = document.createElementNS(HTML_NS, "td"); + cell.setAttribute("class", "contentSearchSuggestionsContainer"); + this._suggestionsList = document.createElementNS(HTML_NS, "table"); + this._suggestionsList.setAttribute( + "class", + "contentSearchSuggestionsList" + ); + cell.appendChild(this._suggestionsList); + row.appendChild(cell); + this._table.appendChild(row); + this._suggestionsList.setAttribute("role", "listbox"); + + this._oneOffsTable = document.createElementNS(HTML_NS, "table"); + this._oneOffsTable.setAttribute("class", "contentSearchOneOffsTable"); + this._oneOffsTable.classList.add("contentSearchSuggestionsContainer"); + this._oneOffsTable.setAttribute("role", "group"); + this._table.appendChild(this._oneOffsTable); + + headerRow = document.createElementNS(HTML_NS, "tr"); + header = document.createElementNS(HTML_NS, "td"); + headerRow.setAttribute("class", "contentSearchHeaderRow"); + header.setAttribute("class", "contentSearchHeader"); + headerRow.appendChild(header); + header.id = "contentSearchSearchWithHeader"; + let start = document.createElement("label"); + let inputLabel = document.createElement("label"); + inputLabel.setAttribute( + "class", + "contentSearchSearchWithHeaderSearchText" + ); + let end = document.createElement("label"); + header.appendChild(start); + header.appendChild(inputLabel); + header.appendChild(end); + this._oneOffsTable.appendChild(headerRow); + + let button = document.createElementNS(HTML_NS, "button"); + button.setAttribute("class", "contentSearchSettingsButton"); + button.classList.add("contentSearchHeaderRow"); + button.classList.add("contentSearchHeader"); + button.id = "contentSearchSettingsButton"; + button.addEventListener("click", this); + button.addEventListener("mousemove", this); + this._table.appendChild(button); + + return this._table; + }, + + _setUpOneOffButtons() { + // Sometimes we receive a CurrentEngine message from the ContentSearch service + // before we've received a State message - i.e. before we have our engines. + if (!this._engines) { + return; + } + + while (this._oneOffsTable.firstChild.nextSibling) { + this._oneOffsTable.firstChild.nextSibling.remove(); + } + + this._oneOffButtons = []; + + let engines = this._engines + .filter(aEngine => aEngine.name != this.defaultEngine.name) + .filter(aEngine => !aEngine.hidden); + if (!engines.length) { + this._oneOffsTable.hidden = true; + return; + } + + const kDefaultButtonWidth = 49; // 48px + 1px border. + let rowWidth = this.input.offsetWidth - 2; // 2px border. + let enginesPerRow = Math.floor(rowWidth / kDefaultButtonWidth); + let buttonWidth = Math.floor(rowWidth / enginesPerRow); + + let row = document.createElementNS(HTML_NS, "tr"); + let cell = document.createElementNS(HTML_NS, "td"); + row.setAttribute("class", "contentSearchSuggestionsContainer"); + cell.setAttribute("class", "contentSearchSuggestionsContainer"); + + for (let i = 0; i < engines.length; ++i) { + let engine = engines[i]; + if (i > 0 && i % enginesPerRow == 0) { + row.appendChild(cell); + this._oneOffsTable.appendChild(row); + row = document.createElementNS(HTML_NS, "tr"); + cell = document.createElementNS(HTML_NS, "td"); + row.setAttribute("class", "contentSearchSuggestionsContainer"); + cell.setAttribute("class", "contentSearchSuggestionsContainer"); + } + let button = document.createElementNS(HTML_NS, "button"); + button.setAttribute("class", "contentSearchOneOffItem"); + let img = document.createElementNS(HTML_NS, "img"); + let uri; + if (engine.iconData) { + uri = this._getFaviconURIFromIconData(engine.iconData); + } else { + uri = this._getImageURIForCurrentResolution( + "chrome://browser/skin/search-engine-placeholder.png" + ); + } + img.setAttribute("src", uri); + img.addEventListener( + "load", + function () { + URL.revokeObjectURL(uri); + }, + { once: true } + ); + button.appendChild(img); + button.style.width = buttonWidth + "px"; + button.setAttribute("engine-name", engine.name); + + button.engineName = engine.name; + button.addEventListener("click", this); + button.addEventListener("mousemove", this); + + if (engines.length - i <= enginesPerRow - (i % enginesPerRow)) { + button.classList.add("last-row"); + } + + if ((i + 1) % enginesPerRow == 0) { + button.classList.add("end-of-row"); + } + + button.id = ONE_OFF_ID_PREFIX + i; + cell.appendChild(button); + this._oneOffButtons.push(button); + } + row.appendChild(cell); + this._oneOffsTable.appendChild(row); + this._oneOffsTable.hidden = false; + }, + + _sendMsg(type, data = null) { + dispatchEvent( + new CustomEvent("ContentSearchClient", { + detail: { + type, + data, + }, + }) + ); + }, + }; + + return ContentSearchUIController; +})(); diff --git a/browser/components/search/content/searchbar.js b/browser/components/search/content/searchbar.js new file mode 100644 index 0000000000..e8b2dd5045 --- /dev/null +++ b/browser/components/search/content/searchbar.js @@ -0,0 +1,895 @@ +/* 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"; + +/* globals XULCommandEvent */ + +// This is loaded into chrome windows with the subscript loader. Wrap in +// a block to prevent accidentally leaking globals onto `window`. +{ + const lazy = {}; + + ChromeUtils.defineESModuleGetters(lazy, { + FormHistory: "resource://gre/modules/FormHistory.sys.mjs", + SearchSuggestionController: + "resource://gre/modules/SearchSuggestionController.sys.mjs", + }); + + /** + * Defines the search bar element. + */ + class MozSearchbar extends MozXULElement { + static get inheritedAttributes() { + return { + ".searchbar-textbox": + "disabled,disableautocomplete,searchengine,src,newlines", + ".searchbar-search-button": "addengines", + }; + } + + static get markup() { + return ` + <stringbundle src="chrome://browser/locale/search.properties"></stringbundle> + <hbox class="searchbar-search-button" data-l10n-id="searchbar-icon"> + <image class="searchbar-search-icon"></image> + <image class="searchbar-search-icon-overlay"></image> + </hbox> + <html:input class="searchbar-textbox" is="autocomplete-input" type="search" data-l10n-id="searchbar-input" autocompletepopup="PopupSearchAutoComplete" autocompletesearch="search-autocomplete" autocompletesearchparam="searchbar-history" maxrows="10" completeselectedindex="true" minresultsforpopup="0"/> + <menupopup class="textbox-contextmenu"></menupopup> + <hbox class="search-go-container" align="center"> + <image class="search-go-button urlbar-icon" hidden="true" onclick="handleSearchCommand(event);" data-l10n-id="searchbar-submit"></image> + </hbox> + `; + } + + constructor() { + super(); + + MozXULElement.insertFTLIfNeeded("browser/search.ftl"); + + this.destroy = this.destroy.bind(this); + this._setupEventListeners(); + let searchbar = this; + this.observer = { + observe(aEngine, aTopic, aVerb) { + if ( + aTopic == "browser-search-engine-modified" || + (aTopic == "browser-search-service" && aVerb == "init-complete") + ) { + // Make sure the engine list is refetched next time it's needed + searchbar._engines = null; + + // Update the popup header and update the display after any modification. + searchbar._textbox.popup.updateHeader(); + searchbar.updateDisplay(); + } + }, + QueryInterface: ChromeUtils.generateQI(["nsIObserver"]), + }; + + this._ignoreFocus = false; + this._engines = null; + this.telemetrySelectedIndex = -1; + } + + connectedCallback() { + // Don't initialize if this isn't going to be visible + if (this.closest("#BrowserToolbarPalette")) { + return; + } + + this.appendChild(this.constructor.fragment); + this.initializeAttributeInheritance(); + + // Don't go further if in Customize mode. + if (this.parentNode.parentNode.localName == "toolbarpaletteitem") { + return; + } + + // Ensure we get persisted widths back, if we've been in the palette: + let storedWidth = Services.xulStore.getValue( + document.documentURI, + this.parentNode.id, + "width" + ); + if (storedWidth) { + this.parentNode.setAttribute("width", storedWidth); + this.parentNode.style.width = storedWidth + "px"; + } + + this._stringBundle = this.querySelector("stringbundle"); + this._textbox = this.querySelector(".searchbar-textbox"); + + this._menupopup = null; + this._pasteAndSearchMenuItem = null; + + this._setupTextboxEventListeners(); + this._initTextbox(); + + window.addEventListener("unload", this.destroy); + + Services.obs.addObserver(this.observer, "browser-search-engine-modified"); + Services.obs.addObserver(this.observer, "browser-search-service"); + + this._initialized = true; + + (window.delayedStartupPromise || Promise.resolve()).then(() => { + window.requestIdleCallback(() => { + Services.search + .init() + .then(aStatus => { + // Bail out if the binding's been destroyed + if (!this._initialized) { + return; + } + + // Refresh the display (updating icon, etc) + this.updateDisplay(); + BrowserSearch.updateOpenSearchBadge(); + }) + .catch(status => + console.error( + "Cannot initialize search service, bailing out: " + status + ) + ); + }); + }); + + // Wait until the popupshowing event to avoid forcing immediate + // attachment of the search-one-offs binding. + this.textbox.popup.addEventListener( + "popupshowing", + () => { + let oneOffButtons = this.textbox.popup.oneOffButtons; + // Some accessibility tests create their own <searchbar> that doesn't + // use the popup binding below, so null-check oneOffButtons. + if (oneOffButtons) { + oneOffButtons.telemetryOrigin = "searchbar"; + // Set .textbox first, since the popup setter will cause + // a _rebuild call that uses it. + oneOffButtons.textbox = this.textbox; + oneOffButtons.popup = this.textbox.popup; + } + }, + { capture: true, once: true } + ); + } + + async getEngines() { + if (!this._engines) { + this._engines = await Services.search.getVisibleEngines(); + } + return this._engines; + } + + set currentEngine(val) { + if (PrivateBrowsingUtils.isWindowPrivate(window)) { + Services.search.setDefaultPrivate( + val, + Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR + ); + } else { + Services.search.setDefault( + val, + Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR + ); + } + } + + get currentEngine() { + let currentEngine; + if (PrivateBrowsingUtils.isWindowPrivate(window)) { + currentEngine = Services.search.defaultPrivateEngine; + } else { + currentEngine = Services.search.defaultEngine; + } + // Return a dummy engine if there is no currentEngine + return currentEngine || { name: "", uri: null }; + } + + /** + * textbox is used by sanitize.js to clear the undo history when + * clearing form information. + * + * @returns {HTMLInputElement} + */ + get textbox() { + return this._textbox; + } + + set value(val) { + this._textbox.value = val; + } + + get value() { + return this._textbox.value; + } + + destroy() { + if (this._initialized) { + this._initialized = false; + window.removeEventListener("unload", this.destroy); + + Services.obs.removeObserver( + this.observer, + "browser-search-engine-modified" + ); + Services.obs.removeObserver(this.observer, "browser-search-service"); + } + + // Make sure to break the cycle from _textbox to us. Otherwise we leak + // the world. But make sure it's actually pointing to us. + // Also make sure the textbox has ever been constructed, otherwise the + // _textbox getter will cause the textbox constructor to run, add an + // observer, and leak the world too. + if ( + this._textbox && + this._textbox.mController && + this._textbox.mController.input && + this._textbox.mController.input.wrappedJSObject == + this.nsIAutocompleteInput + ) { + this._textbox.mController.input = null; + } + } + + focus() { + this._textbox.focus(); + } + + select() { + this._textbox.select(); + } + + setIcon(element, uri) { + element.setAttribute("src", uri); + } + + updateDisplay() { + this._textbox.title = this._stringBundle.getFormattedString("searchtip", [ + this.currentEngine.name, + ]); + } + + updateGoButtonVisibility() { + this.querySelector(".search-go-button").hidden = !this._textbox.value; + } + + openSuggestionsPanel(aShowOnlySettingsIfEmpty) { + if (this._textbox.open) { + return; + } + + this._textbox.showHistoryPopup(); + + if (this._textbox.value) { + // showHistoryPopup does a startSearch("") call, ensure the + // controller handles the text from the input box instead: + this._textbox.mController.handleText(); + } else if (aShowOnlySettingsIfEmpty) { + this.setAttribute("showonlysettings", "true"); + } + } + + async selectEngine(aEvent, isNextEngine) { + // Stop event bubbling now, because the rest of this method is async. + aEvent.preventDefault(); + aEvent.stopPropagation(); + + // Find the new index. + let engines = await this.getEngines(); + let currentName = this.currentEngine.name; + let newIndex = -1; + let lastIndex = engines.length - 1; + for (let i = lastIndex; i >= 0; --i) { + if (engines[i].name == currentName) { + // Check bounds to cycle through the list of engines continuously. + if (!isNextEngine && i == 0) { + newIndex = lastIndex; + } else if (isNextEngine && i == lastIndex) { + newIndex = 0; + } else { + newIndex = i + (isNextEngine ? 1 : -1); + } + break; + } + } + + this.currentEngine = engines[newIndex]; + + this.openSuggestionsPanel(); + } + + handleSearchCommand(aEvent, aEngine, aForceNewTab) { + let where = "current"; + let params; + const newTabPref = Services.prefs.getBoolPref("browser.search.openintab"); + + // Open ctrl/cmd clicks on one-off buttons in a new background tab. + if ( + aEvent && + aEvent.originalTarget.classList.contains("search-go-button") + ) { + if (aEvent.button == 2) { + return; + } + where = whereToOpenLink(aEvent, false, true); + if ( + newTabPref && + !aEvent.altKey && + !aEvent.getModifierState("AltGraph") && + where == "current" && + !gBrowser.selectedTab.isEmpty + ) { + where = "tab"; + } + } else if (aForceNewTab) { + where = "tab"; + if (Services.prefs.getBoolPref("browser.tabs.loadInBackground")) { + where += "-background"; + } + } else { + if ( + (KeyboardEvent.isInstance(aEvent) && + (aEvent.altKey || aEvent.getModifierState("AltGraph"))) ^ + newTabPref && + !gBrowser.selectedTab.isEmpty + ) { + where = "tab"; + } + if ( + MouseEvent.isInstance(aEvent) && + (aEvent.button == 1 || aEvent.getModifierState("Accel")) + ) { + where = "tab"; + params = { + inBackground: true, + }; + } + } + this.handleSearchCommandWhere(aEvent, aEngine, where, params); + } + + handleSearchCommandWhere(aEvent, aEngine, aWhere, aParams = {}) { + let textBox = this._textbox; + let textValue = textBox.value; + + let selectedIndex = this.telemetrySelectedIndex; + let isOneOff = false; + + BrowserSearchTelemetry.recordSearchSuggestionSelectionMethod( + aEvent, + "searchbar", + selectedIndex + ); + + if (selectedIndex == -1) { + isOneOff = + this.textbox.popup.oneOffButtons.eventTargetIsAOneOff(aEvent); + } + + if (aWhere === "tab" && !!aParams.inBackground) { + // Keep the focus in the search bar. + aParams.avoidBrowserFocus = true; + } else if ( + aWhere !== "window" && + aEvent.keyCode === KeyEvent.DOM_VK_RETURN + ) { + // Move the focus to the selected browser when keyup the Enter. + aParams.avoidBrowserFocus = true; + this._needBrowserFocusAtEnterKeyUp = true; + } + + // This is a one-off search only if oneOffRecorded is true. + this.doSearch(textValue, aWhere, aEngine, aParams, isOneOff); + } + + doSearch(aData, aWhere, aEngine, aParams, isOneOff = false) { + let textBox = this._textbox; + let engine = aEngine || this.currentEngine; + + // Save the current value in the form history + if ( + aData && + !PrivateBrowsingUtils.isWindowPrivate(window) && + lazy.FormHistory.enabled && + aData.length <= + lazy.SearchSuggestionController.SEARCH_HISTORY_MAX_VALUE_LENGTH + ) { + lazy.FormHistory.update({ + op: "bump", + fieldname: textBox.getAttribute("autocompletesearchparam"), + value: aData, + source: engine.name, + }).catch(error => + console.error( + "Saving search to form history failed: " + error.message + ) + ); + } + + let submission = engine.getSubmission(aData, null, "searchbar"); + + // If we hit here, we come either from a one-off, a plain search or a suggestion. + const details = { + isOneOff, + isSuggestion: !isOneOff && this.telemetrySelectedIndex != -1, + url: submission.uri, + }; + + this.telemetrySelectedIndex = -1; + + BrowserSearchTelemetry.recordSearch( + gBrowser.selectedBrowser, + engine, + "searchbar", + details + ); + // null parameter below specifies HTML response for search + let params = { + postData: submission.postData, + globalHistoryOptions: { + triggeringSearchEngine: engine.name, + }, + }; + if (aParams) { + for (let key in aParams) { + params[key] = aParams[key]; + } + } + openTrustedLinkIn(submission.uri.spec, aWhere, params); + } + + disconnectedCallback() { + this.destroy(); + while (this.firstChild) { + this.firstChild.remove(); + } + } + + /** + * Determines if we should select all the text in the searchbar based on the + * searchbar state, and whether the selection is empty. + */ + _maybeSelectAll() { + if ( + !this._preventClickSelectsAll && + document.activeElement == this._textbox && + this._textbox.selectionStart == this._textbox.selectionEnd + ) { + this.select(); + } + } + + _setupEventListeners() { + this.addEventListener("click", event => { + this._maybeSelectAll(); + }); + + this.addEventListener( + "DOMMouseScroll", + event => { + if (event.getModifierState("Accel")) { + this.selectEngine(event, event.detail > 0); + } + }, + true + ); + + this.addEventListener("input", event => { + this.updateGoButtonVisibility(); + }); + + this.addEventListener("drop", event => { + this.updateGoButtonVisibility(); + }); + + this.addEventListener( + "blur", + event => { + // Reset the flag since we can't capture enter keyup event if the event happens + // after moving the focus. + this._needBrowserFocusAtEnterKeyUp = false; + + // If the input field is still focused then a different window has + // received focus, ignore the next focus event. + this._ignoreFocus = document.activeElement == this._textbox; + }, + true + ); + + this.addEventListener( + "focus", + event => { + // Speculatively connect to the current engine's search URI (and + // suggest URI, if different) to reduce request latency + this.currentEngine.speculativeConnect({ + window, + originAttributes: gBrowser.contentPrincipal.originAttributes, + }); + + if (this._ignoreFocus) { + // This window has been re-focused, don't show the suggestions + this._ignoreFocus = false; + return; + } + + // Don't open the suggestions if there is no text in the textbox. + if (!this._textbox.value) { + return; + } + + // Don't open the suggestions if the mouse was used to focus the + // textbox, that will be taken care of in the click handler. + if ( + Services.focus.getLastFocusMethod(window) & + Services.focus.FLAG_BYMOUSE + ) { + return; + } + + this.openSuggestionsPanel(); + }, + true + ); + + this.addEventListener("mousedown", event => { + this._preventClickSelectsAll = this._textbox.focused; + // Ignore right clicks + if (event.button != 0) { + return; + } + + // Ignore clicks on the search go button. + if (event.originalTarget.classList.contains("search-go-button")) { + return; + } + + // Ignore clicks on menu items in the input's context menu. + if (event.originalTarget.localName == "menuitem") { + return; + } + + let isIconClick = event.originalTarget.classList.contains( + "searchbar-search-button" + ); + + // Hide popup when icon is clicked while popup is open + if (isIconClick && this.textbox.popup.popupOpen) { + this.textbox.popup.closePopup(); + } else if (isIconClick || this._textbox.value) { + // Open the suggestions whenever clicking on the search icon or if there + // is text in the textbox. + this.openSuggestionsPanel(true); + } + }); + } + + _setupTextboxEventListeners() { + this.textbox.addEventListener("input", event => { + this.textbox.popup.removeAttribute("showonlysettings"); + }); + + this.textbox.addEventListener("dragover", event => { + let types = event.dataTransfer.types; + if ( + types.includes("text/plain") || + types.includes("text/x-moz-text-internal") + ) { + event.preventDefault(); + } + }); + + this.textbox.addEventListener("drop", event => { + let dataTransfer = event.dataTransfer; + let data = dataTransfer.getData("text/plain"); + if (!data) { + data = dataTransfer.getData("text/x-moz-text-internal"); + } + if (data) { + event.preventDefault(); + this.textbox.value = data; + this.openSuggestionsPanel(); + } + }); + + this.textbox.addEventListener("contextmenu", event => { + if (!this._menupopup) { + this._buildContextMenu(); + } + + this._textbox.closePopup(); + + // Make sure the context menu isn't opened via keyboard shortcut. Check for text selection + // before updating the state of any menu items. + if (event.button) { + this._maybeSelectAll(); + } + + // Update disabled state of menu items + for (let item of this._menupopup.querySelectorAll("menuitem[cmd]")) { + let command = item.getAttribute("cmd"); + let controller = + document.commandDispatcher.getControllerForCommand(command); + item.disabled = !controller.isCommandEnabled(command); + } + + let pasteEnabled = document.commandDispatcher + .getControllerForCommand("cmd_paste") + .isCommandEnabled("cmd_paste"); + this._pasteAndSearchMenuItem.disabled = !pasteEnabled; + + this._menupopup.openPopupAtScreen(event.screenX, event.screenY, true); + + event.preventDefault(); + }); + } + + _initTextbox() { + if (this.parentNode.parentNode.localName == "toolbarpaletteitem") { + return; + } + + this.setAttribute("role", "combobox"); + this.setAttribute("aria-owns", this.textbox.popup.id); + + // This overrides the searchParam property in autocomplete.xml. We're + // hijacking this property as a vehicle for delivering the privacy + // information about the window into the guts of nsSearchSuggestions. + // Note that the setter is the same as the parent. We were not sure whether + // we can override just the getter. If that proves to be the case, the setter + // can be removed. + Object.defineProperty(this.textbox, "searchParam", { + get() { + return ( + this.getAttribute("autocompletesearchparam") + + (PrivateBrowsingUtils.isWindowPrivate(window) ? "|private" : "") + ); + }, + set(val) { + this.setAttribute("autocompletesearchparam", val); + }, + }); + + Object.defineProperty(this.textbox, "selectedButton", { + get() { + return this.popup.oneOffButtons.selectedButton; + }, + set(val) { + this.popup.oneOffButtons.selectedButton = val; + }, + }); + + // This is implemented so that when textbox.value is set directly (e.g., + // by tests), the one-off query is updated. + this.textbox.onBeforeValueSet = aValue => { + if (this.textbox.popup._oneOffButtons) { + this.textbox.popup.oneOffButtons.query = aValue; + } + return aValue; + }; + + // Returns true if the event is handled by us, false otherwise. + this.textbox.onBeforeHandleKeyDown = aEvent => { + if (aEvent.getModifierState("Accel")) { + if ( + aEvent.keyCode == KeyEvent.DOM_VK_DOWN || + aEvent.keyCode == KeyEvent.DOM_VK_UP + ) { + this.selectEngine(aEvent, aEvent.keyCode == KeyEvent.DOM_VK_DOWN); + return true; + } + return false; + } + + if ( + (AppConstants.platform == "macosx" && + aEvent.keyCode == KeyEvent.DOM_VK_F4) || + (aEvent.getModifierState("Alt") && + (aEvent.keyCode == KeyEvent.DOM_VK_DOWN || + aEvent.keyCode == KeyEvent.DOM_VK_UP)) + ) { + if (!this.textbox.openSearch()) { + aEvent.preventDefault(); + aEvent.stopPropagation(); + return true; + } + } + + let popup = this.textbox.popup; + if (popup.popupOpen) { + let suggestionsHidden = + popup.richlistbox.getAttribute("collapsed") == "true"; + let numItems = suggestionsHidden ? 0 : popup.matchCount; + return popup.oneOffButtons.handleKeyDown(aEvent, numItems, true); + } else if (aEvent.keyCode == KeyEvent.DOM_VK_ESCAPE) { + if (this.textbox.editor.canUndo) { + this.textbox.editor.undoAll(); + } else { + this.textbox.select(); + } + return true; + } + return false; + }; + + // This method overrides the autocomplete binding's openPopup (essentially + // duplicating the logic from the autocomplete popup binding's + // openAutocompletePopup method), modifying it so that the popup is aligned with + // the inner textbox, but sized to not extend beyond the search bar border. + this.textbox.openPopup = () => { + // Entering customization mode after the search bar had focus causes + // the popup to appear again, due to focus returning after the + // hamburger panel closes. Don't open in that spurious event. + if (document.documentElement.getAttribute("customizing") == "true") { + return; + } + + let popup = this.textbox.popup; + if (!popup.mPopupOpen) { + // Initially the panel used for the searchbar (PopupSearchAutoComplete + // in browser.xhtml) is hidden to avoid impacting startup / new + // window performance. The base binding's openPopup would normally + // call the overriden openAutocompletePopup in + // browser-search-autocomplete-result-popup binding to unhide the popup, + // but since we're overriding openPopup we need to unhide the panel + // ourselves. + popup.hidden = false; + + // Don't roll up on mouse click in the anchor for the search UI. + if (popup.id == "PopupSearchAutoComplete") { + popup.setAttribute("norolluponanchor", "true"); + } + + popup.mInput = this.textbox; + // clear any previous selection, see bugs 400671 and 488357 + popup.selectedIndex = -1; + + // Ensure the panel has a meaningful initial size and doesn't grow + // unconditionally. + let { width } = window.windowUtils.getBoundsWithoutFlushing(this); + if (popup.oneOffButtons) { + // We have a min-width rule on search-panel-one-offs to show at + // least 4 buttons, so take that into account here. + width = Math.max(width, popup.oneOffButtons.buttonWidth * 4); + } + + popup.style.setProperty("--panel-width", width + "px"); + popup._invalidate(); + popup.openPopup(this, "after_start"); + } + }; + + this.textbox.openSearch = () => { + if (!this.textbox.popupOpen) { + this.openSuggestionsPanel(); + return false; + } + return true; + }; + + this.textbox.handleEnter = event => { + // Toggle the open state of the add-engine menu button if it's + // selected. We're using handleEnter for this instead of listening + // for the command event because a command event isn't fired. + if ( + this.textbox.selectedButton && + this.textbox.selectedButton.getAttribute("anonid") == + "addengine-menu-button" + ) { + this.textbox.selectedButton.open = !this.textbox.selectedButton.open; + return true; + } + // Otherwise, "call super": do what the autocomplete binding's + // handleEnter implementation does. + return this.textbox.mController.handleEnter(false, event || null); + }; + + // override |onTextEntered| in autocomplete.xml + this.textbox.onTextEntered = event => { + this.textbox.editor.clearUndoRedo(); + + let engine; + let oneOff = this.textbox.selectedButton; + if (oneOff) { + if (!oneOff.engine) { + oneOff.doCommand(); + return; + } + engine = oneOff.engine; + } + if (this.textbox.popupSelectedIndex != -1) { + this.telemetrySelectedIndex = this.textbox.popupSelectedIndex; + this.textbox.popupSelectedIndex = -1; + } + this.handleSearchCommand(event, engine); + }; + + this.textbox.onbeforeinput = event => { + if (event.data && this._needBrowserFocusAtEnterKeyUp) { + // Ignore char key input while processing enter key. + event.preventDefault(); + } + }; + + this.textbox.onkeyup = event => { + // Pressing Enter key while pressing Meta key, and next, even when + // releasing Enter key before releasing Meta key, the keyup event is not + // fired. Therefore, if Enter keydown is detecting, continue the post + // processing for Enter key when any keyup event is detected. + if (this._needBrowserFocusAtEnterKeyUp) { + this._needBrowserFocusAtEnterKeyUp = false; + gBrowser.selectedBrowser.focus(); + } + }; + } + + _buildContextMenu() { + const raw = ` + <menuitem data-l10n-id="text-action-undo" cmd="cmd_undo"/> + <menuitem data-l10n-id="text-action-redo" cmd="cmd_redo"/> + <menuseparator/> + <menuitem data-l10n-id="text-action-cut" cmd="cmd_cut"/> + <menuitem data-l10n-id="text-action-copy" cmd="cmd_copy"/> + <menuitem data-l10n-id="text-action-paste" cmd="cmd_paste"/> + <menuitem class="searchbar-paste-and-search"/> + <menuitem data-l10n-id="text-action-delete" cmd="cmd_delete"/> + <menuitem data-l10n-id="text-action-select-all" cmd="cmd_selectAll"/> + <menuseparator/> + <menuitem class="searchbar-clear-history"/> + `; + + this._menupopup = this.querySelector(".textbox-contextmenu"); + + let frag = MozXULElement.parseXULToFragment(raw); + + // Insert attributes that come from localized properties + this._pasteAndSearchMenuItem = frag.querySelector( + ".searchbar-paste-and-search" + ); + this._pasteAndSearchMenuItem.setAttribute( + "label", + this._stringBundle.getString("cmd_pasteAndSearch") + ); + + let clearHistoryItem = frag.querySelector(".searchbar-clear-history"); + clearHistoryItem.setAttribute( + "label", + this._stringBundle.getString("cmd_clearHistory") + ); + clearHistoryItem.setAttribute( + "accesskey", + this._stringBundle.getString("cmd_clearHistory_accesskey") + ); + + this._menupopup.appendChild(frag); + + this._menupopup.addEventListener("command", event => { + switch (event.originalTarget) { + case this._pasteAndSearchMenuItem: + this.select(); + goDoCommand("cmd_paste"); + this.handleSearchCommand(event); + break; + case clearHistoryItem: + let param = this.textbox.getAttribute("autocompletesearchparam"); + lazy.FormHistory.update({ op: "remove", fieldname: param }); + this.textbox.value = ""; + break; + default: + let cmd = event.originalTarget.getAttribute("cmd"); + if (cmd) { + let controller = + document.commandDispatcher.getControllerForCommand(cmd); + controller.doCommand(cmd); + } + break; + } + }); + } + } + + customElements.define("searchbar", MozSearchbar); +} diff --git a/browser/components/search/docs/Preferences.rst b/browser/components/search/docs/Preferences.rst new file mode 100644 index 0000000000..43e509165d --- /dev/null +++ b/browser/components/search/docs/Preferences.rst @@ -0,0 +1,28 @@ +Preferences +=========== + +This document describes preferences affecting Firefox's Search UI code. For information +on the toolkit search service, see the :doc:`/toolkit/search/Preferences` document. +Preferences that are generated and updated by code won't be described here. + +User Exposed +------------ +These preferences are exposed through the Firefox UI + +browser.search.hiddenOneOffs (string, default: "") + A comma-separated list of search engines names that are hidden on the toolbar. + +browser.search.widget.inNavBar (boolean, default: false) + Whether the search bar widget is displayed in the navigation bar. + +Hidden +------ +These preferences are normally hidden, and should not be used unless you really +know what you are doing. + +browser.search.openintab (boolean, default: false) + Whether or not items opened from the search bar are opened in a new tab. + +browser.search.context.loadInBackground (boolean, default: false) + Whether or not tabs opened from searching in the context menu are loaded in + the foreground or background. diff --git a/browser/components/search/docs/application-search-engines.rst b/browser/components/search/docs/application-search-engines.rst new file mode 100644 index 0000000000..30bc0b7575 --- /dev/null +++ b/browser/components/search/docs/application-search-engines.rst @@ -0,0 +1,41 @@ +Application Search Engines +========================== + +Firefox defines various application search engines that are shipped to users. + +The extensions for the definitions of these engines live in +:searchfox:`browser/components/search/extensions <browser/components/search/extensions>` + +Icons +----- + +Icon Requirements +~~~~~~~~~~~~~~~~~ + +It is preferred that each engine is shipped with a ``.ico`` file with two sizes +of image contained within the file: + + * 16 x 16 pixels + * 32 x 32 pixels + +Some engines also have icons in +:searchfox:`browser/components/newtab/data/content/tippytop <browser/components/newtab/data/content/tippytop>`. +For these engines, there are two sizes depending on the subdirectory: + + * ``favicons/``: 32 x 32 pixels + * ``images/``: preferred minimum of 192 x 192 pixels + +Updating Icons +~~~~~~~~~~~~~~ + +To update icons for application search engines: + + * Place the new icon file in the :searchfox:`folder associated with the search engine <browser/components/search/extensions>`. + * Increase the version number in the associated manifest file. This ensures + that the add-on manager properly updates the engine. + * Be aware that the :searchfox:`allowed-dupes.mn file <browser/installer/allowed-dupes.mn>` + lists some icons that are intended as duplicates. + +To update icons for tippytop: + + * Place the new icon file in :searchfox:`both the sub-folders within the tippytop directory <browser/components/newtab/data/content/tippytop>`. diff --git a/browser/components/search/docs/index.rst b/browser/components/search/docs/index.rst new file mode 100644 index 0000000000..a608a12876 --- /dev/null +++ b/browser/components/search/docs/index.rst @@ -0,0 +1,23 @@ +Search +====== + +This document describes the implementation of parts of Firefox's search interfaces. + +The search area covers: + + * Search bar on the toolbar + * In-content search + * One-off search buttons on both the search and address bars + +Search Engine handling is taken care of with the `toolkit Search Service`_. + +Most of the search code lives in `browser/components/search`_. + +.. toctree:: + + application-search-engines + Preferences + telemetry + +.. _toolkit Search Service: /toolkit/search/index.html +.. _browser/components/search: https://searchfox.org/mozilla-central/source/browser/components/search diff --git a/browser/components/search/docs/telemetry.rst b/browser/components/search/docs/telemetry.rst new file mode 100644 index 0000000000..b00e7eb911 --- /dev/null +++ b/browser/components/search/docs/telemetry.rst @@ -0,0 +1,183 @@ +Telemetry +========= + +This section describes existing telemetry probes measuring interaction with +search engines from the browser UI. + +Other search-related telemetry is recorded by Toolkit such as search service +telemetry and telemetry related to fetching search suggestions. Toolkit search +telemetry is relevant to Firefox as well as other consumers of Toolkit. See +:doc:`/toolkit/search/Telemetry` in the Toolkit documentation for details. + +.. contents:: + :depth: 2 + + +Glossary +-------- + +SAP + Search Access Point, a search that a user performs by visiting + via one of Firefox's access points using the associated partner codes. + +SERP + A search engine results page. + +Persisted Search + When a user has the following preference values: + + - ``browser.urlbar.showSearchTerms.enabled``: ``true`` + - ``browser.urlbar.showSearchTerms.featureGate``: ``true`` + - ``browser.search.widget.inNavBar``: ``false`` + + and does the following: + + - Starts a search from the urlbar or context menu. + - Loads the default search engine results page. + + the search term will persist in the Urlbar, causing it to enter a Persisted Search state. + +Definitions +----------- + +``organic`` + A search that a user performs by visiting a search engine directly. + +``tagged`` + Refers to a page that is tagged with an associated partner code. + It may or may not have originated via a SAP. + +``tagged-follow-on`` + Refers to a page that is tagged with an associated partner code and has been identified + as a follow-on search. It may or may not have originated via a SAP. + +Search probes relevant to front-end searches +-------------------------------------------- + +The Address Bar is an integral part of search and has `additional telemetry of its own`_. + +BrowserSearchTelemetry.sys.mjs +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +This telemetry is handled by `BrowserSearchTelemetry.sys.mjs`_. + +SEARCH_COUNTS - SAP usage +^^^^^^^^^^^^^^^^^^^^^^^^^ + + This histogram tracks search engines and Search Access Points. It is augmented + by multiple SAPs, including the urlbar. + It's a keyed histogram, the keys are strings made up of search engine names + and SAP names, for example ``google.urlbar``. + For each key, this records the count of searches made using that engine and SAP. + SAP names can be: + + - ``alias`` This is when using an alias (like ``@google``) in the urlbar. + Note there is often confusion between the terms alias and keyword, and + they may be used inappropriately: aliases refer to search engines, while + keywords refer to bookmarks. We expect no results for this SAP in Firefox + 83+, since urlbar-searchmode replaces it. + - ``abouthome`` + - ``contextmenu`` + - ``newtab`` + - ``searchbar`` + - ``system`` + - ``urlbar`` Except aliases and search mode. + - ``urlbar-handoff`` Used when searching from about:newtab. + - ``urlbar-persisted`` Used when searching from the Urlbar while it + was in a Persisted Search state. + - ``urlbar-searchmode`` Used when the Urlbar is in search mode. + - ``webextension`` + +browser.engagement.navigation.* +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + These keyed scalars track search through different SAPs, for example the + urlbar is tracked by ``browser.engagement.navigation.urlbar``. + It counts loads triggered in a subsession from the specified SAP, broken down + by the originating action. + Possible SAPs are: + + - ``urlbar`` Except search mode. + - ``urlbar_handoff`` Used when searching from about:newtab. + - ``urlbar_persisted`` Used when searching from the Urlbar while it + was in a Persisted Search state. + - ``urlbar_searchmode`` Used when the Urlbar is in search mode. + - ``searchbar`` + - ``about_home`` + - ``about_newtab`` + - ``contextmenu`` + - ``webextension`` + - ``system`` Indicates a search from the command line. + + Recorded actions may be: + + - ``search`` + Used for any search from ``contextmenu``, ``system`` and ``webextension``. + - ``search_alias`` + For ``urlbar``, indicates the user confirmed a search through an alias. + - ``search_enter`` + For ``about_home`` and ``about:newtab`` this counts any search. + For the other SAPs it tracks typing and then pressing Enter. + - ``search_formhistory`` + For ``urlbar``, indicates the user picked a form history result. + - ``search_oneoff`` + For ``urlbar`` or ``searchbar``, indicates the user confirmed a search + using a one-off button. + - ``search_suggestion`` + For ``urlbar`` or ``searchbar``, indicates the user confirmed a search + suggestion. + +navigation.search (OBSOLETE) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + This is a legacy and disabled event telemetry that is currently under + discussion for removal or modernization. It can't be enabled through a pref. + it's more or less equivalent to browser.engagement.navigation, but can also + report the picked search engine. + +SearchSERPTelemetry.sys.mjs +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +This telemetry is handled by `SearchSERPTelemetry.sys.mjs and the associated parent/child actors`_. + +browser.search.content.* +^^^^^^^^^^^^^^^^^^^^^^^^ + + These keyed scalar track counts of SERP page loads. The key format is + ``<provider>:[tagged|tagged-follow-on|organic]:[<code>|other|none]``. + + They are broken down by the originating SAP where known: + + - ``urlbar`` Except search mode. + - ``urlbar_handoff`` Used when searching from about:newtab. + - ``urlbar_persisted`` Used when searching from the Urlbar while it + was in a Persisted Search state. + - ``urlbar_searchmode`` Used when the Urlbar is in search mode. + - ``searchbar`` + - ``about_home`` + - ``about_newtab`` + - ``contextmenu`` + - ``webextension`` + - ``system`` Indicates a search from the command line. + - ``tabhistory`` Indicates a search was counted as a result of the user loading it from the tab history. + - ``reload`` Indicates a search was counted as a result of reloading the page. + - ``unknown`` Indicates the origin was unknown. + +browser.search.withads.* +^^^^^^^^^^^^^^^^^^^^^^^^ + + These keyed scalar track counts of SERP pages with adverts displayed. The key + format is ``<provider>:<tagged|organic>``. + + They are broken down by the originating SAP where known, the list of SAP + is the same as for ``browser.search.content.*``. + +browser.search.adclicks.* +^^^^^^^^^^^^^^^^^^^^^^^^^ + + This is the same as ```browser.search.withads.*`` but tracks counts for them + clicks of adverts on SERP pages. + +.. _additional telemetry of its own: /browser/urlbar/telemetry.html +.. _SearchSERPTelemetry.sys.mjs and the associated parent/child actors: https://searchfox.org/mozilla-central/search?q=&path=SearchSERPTelemetry*.sys.mjs&case=false®exp=false +.. _BrowserSearchTelemetry: https://searchfox.org/mozilla-central/source/browser/components/search/BrowserSearchTelemetry.sys.mjs diff --git a/browser/components/search/extensions/1und1/favicon.ico b/browser/components/search/extensions/1und1/favicon.ico Binary files differnew file mode 100644 index 0000000000..ac5a2bbb0a --- /dev/null +++ b/browser/components/search/extensions/1und1/favicon.ico diff --git a/browser/components/search/extensions/1und1/manifest.json b/browser/components/search/extensions/1und1/manifest.json new file mode 100644 index 0000000000..929da0f485 --- /dev/null +++ b/browser/components/search/extensions/1und1/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "1&1 Suche", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "1und1@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "1&1 Suche", + "search_url": "https://go.1und1.de/br/moz_search_web/", + "search_url_get_params": "q={searchTerms}&enc=UTF-8", + "suggest_url": "https://suggestplugin.ui-portal.de/s", + "suggest_url_get_params": "q={searchTerms}&brand=1und1&origin=br_splugin_ff_sg" + } + } +} diff --git a/browser/components/search/extensions/allegro-pl/favicon.ico b/browser/components/search/extensions/allegro-pl/favicon.ico Binary files differnew file mode 100644 index 0000000000..42b4f90149 --- /dev/null +++ b/browser/components/search/extensions/allegro-pl/favicon.ico diff --git a/browser/components/search/extensions/allegro-pl/manifest.json b/browser/components/search/extensions/allegro-pl/manifest.json new file mode 100644 index 0000000000..845c2d8fef --- /dev/null +++ b/browser/components/search/extensions/allegro-pl/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Allegro", + "description": "Wyszukiwanie w aukcjach Allegro", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "allegro-pl@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Allegro", + "search_url": "https://allegro.pl/listing", + "search_form": "https://allegro.pl", + "search_url_get_params": "string={searchTerms}&sourceid=Mozilla-search" + } + } +} diff --git a/browser/components/search/extensions/amazon/_locales/au/messages.json b/browser/components/search/extensions/amazon/_locales/au/messages.json new file mode 100644 index 0000000000..a8e6721e28 --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/au/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.com.au" + }, + "extensionDescription": { + "message": "Amazon.com.au Search" + }, + "searchUrl": { + "message": "https://www.amazon.com.au/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.com.au/exec/obidos/external-search/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended" + }, + "suggestUrl": { + "message": "https://completion.amazon.com.au/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=111172" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/ca/messages.json b/browser/components/search/extensions/amazon/_locales/ca/messages.json new file mode 100644 index 0000000000..2f81dc8b77 --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/ca/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.ca" + }, + "extensionDescription": { + "message": "Amazon.ca Search" + }, + "searchUrl": { + "message": "https://www.amazon.ca/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.ca/exec/obidos/external-search/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=mozillacanada-20&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.ca/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=7" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/de/messages.json b/browser/components/search/extensions/amazon/_locales/de/messages.json new file mode 100644 index 0000000000..ccf22b776e --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/de/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.de" + }, + "extensionDescription": { + "message": "Amazon.de Suche" + }, + "searchUrl": { + "message": "https://www.amazon.de/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.de/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=firefox-de-21&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.de/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=4" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/en-GB/messages.json b/browser/components/search/extensions/amazon/_locales/en-GB/messages.json new file mode 100644 index 0000000000..5e1f8d2ece --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/en-GB/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.co.uk" + }, + "extensionDescription": { + "message": "Amazon.co.uk Search" + }, + "searchUrl": { + "message": "https://www.amazon.co.uk/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.co.uk/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=firefox-uk-21&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.co.uk/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=3" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/france/messages.json b/browser/components/search/extensions/amazon/_locales/france/messages.json new file mode 100644 index 0000000000..c8c80cb541 --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/france/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.fr" + }, + "extensionDescription": { + "message": "Recherche Amazon.fr" + }, + "searchUrl": { + "message": "https://www.amazon.fr/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.fr/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=firefox-fr-21&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.fr/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=5" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/in/messages.json b/browser/components/search/extensions/amazon/_locales/in/messages.json new file mode 100644 index 0000000000..8cfa57bfb6 --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/in/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.in" + }, + "extensionDescription": { + "message": "Amazon.in Search" + }, + "searchUrl": { + "message": "https://www.amazon.in/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.in/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.in/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=44571" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/it/messages.json b/browser/components/search/extensions/amazon/_locales/it/messages.json new file mode 100644 index 0000000000..cd923f076c --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/it/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.it" + }, + "extensionDescription": { + "message": "Ricerca Amazon.it" + }, + "searchUrl": { + "message": "https://www.amazon.it/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.it/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=firefoxit-21&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.it/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=35691" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/jp/messages.json b/browser/components/search/extensions/amazon/_locales/jp/messages.json new file mode 100644 index 0000000000..f8b43951ff --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/jp/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.co.jp" + }, + "extensionDescription": { + "message": "Amazon.co.jp Search" + }, + "searchUrl": { + "message": "https://www.amazon.co.jp/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.co.jp/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&mode=blended&tag=mozillajapan-fx-22&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.co.jp/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=6" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/nl/messages.json b/browser/components/search/extensions/amazon/_locales/nl/messages.json new file mode 100644 index 0000000000..17e5330df6 --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/nl/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.nl" + }, + "extensionDescription": { + "message": "Amazon.nl Search" + }, + "searchUrl": { + "message": "https://www.amazon.nl/gp/search" + }, + "searchForm": { + "message": "https://www.amazon.nl/" + }, + "searchUrlGetParams": { + "message": "ie={inputEncoding}&tag=mozillanether-21&index=aps&keywords={searchTerms}" + }, + "suggestUrl": { + "message": "https://completion.amazon.nl/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=328451" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/spain/messages.json b/browser/components/search/extensions/amazon/_locales/spain/messages.json new file mode 100644 index 0000000000..932b16c2f1 --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/spain/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.es" + }, + "extensionDescription": { + "message": "Amazon.es" + }, + "searchUrl": { + "message": "https://www.amazon.es/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.es/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=mozillaspain-21&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.es/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=44551" + } +} diff --git a/browser/components/search/extensions/amazon/_locales/sweden/messages.json b/browser/components/search/extensions/amazon/_locales/sweden/messages.json new file mode 100644 index 0000000000..91cce43cf3 --- /dev/null +++ b/browser/components/search/extensions/amazon/_locales/sweden/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Amazon.se" + }, + "extensionDescription": { + "message": "Amazon.se" + }, + "searchUrl": { + "message": "https://www.amazon.se/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.se/" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=mozillasweede-21&sourceid=Mozilla-search" + }, + "suggestUrl": { + "message": "https://completion.amazon.se/search/complete" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&search-alias=aps&mkt=704403121" + } +} diff --git a/browser/components/search/extensions/amazon/favicon.ico b/browser/components/search/extensions/amazon/favicon.ico Binary files differnew file mode 100644 index 0000000000..1c39eaf8fe --- /dev/null +++ b/browser/components/search/extensions/amazon/favicon.ico diff --git a/browser/components/search/extensions/amazon/manifest.json b/browser/components/search/extensions/amazon/manifest.json new file mode 100644 index 0000000000..07379d206f --- /dev/null +++ b/browser/components/search/extensions/amazon/manifest.json @@ -0,0 +1,28 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionDescription__", + "manifest_version": 2, + "version": "1.12", + "browser_specific_settings": { + "gecko": { + "id": "amazon@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "au", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": "@amazon", + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "search_form": "__MSG_searchForm__", + "search_url_get_params": "__MSG_searchUrlGetParams__", + "suggest_url": "__MSG_suggestUrl__", + "suggest_url_get_params": "__MSG_suggestUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/amazondotcn/_locales/default/messages.json b/browser/components/search/extensions/amazondotcn/_locales/default/messages.json new file mode 100644 index 0000000000..9402028a43 --- /dev/null +++ b/browser/components/search/extensions/amazondotcn/_locales/default/messages.json @@ -0,0 +1,8 @@ +{ + "searchUrl": { + "message": "https://www.amazon.cn/mn/searchApp" + }, + "searchUrlGetParams": { + "message": "ix=sunray&pageletid=headsearch&searchType=&Go.x=0&Go.y=0&bestSaleNum=0&keywords={searchTerms}" + } +} diff --git a/browser/components/search/extensions/amazondotcn/_locales/mozillaonline/messages.json b/browser/components/search/extensions/amazondotcn/_locales/mozillaonline/messages.json new file mode 100644 index 0000000000..888cc1d5a7 --- /dev/null +++ b/browser/components/search/extensions/amazondotcn/_locales/mozillaonline/messages.json @@ -0,0 +1,8 @@ +{ + "searchUrl": { + "message": "https://www.amazon.cn/gp/search" + }, + "searchUrlGetParams": { + "message": "ie=UTF8&camp=536&creative=3200&index=aps&linkCode=ur2&tag=mozilla&keywords={searchTerms}" + } +} diff --git a/browser/components/search/extensions/amazondotcn/favicon.ico b/browser/components/search/extensions/amazondotcn/favicon.ico Binary files differnew file mode 100644 index 0000000000..1c39eaf8fe --- /dev/null +++ b/browser/components/search/extensions/amazondotcn/favicon.ico diff --git a/browser/components/search/extensions/amazondotcn/manifest.json b/browser/components/search/extensions/amazondotcn/manifest.json new file mode 100644 index 0000000000..4cff45292e --- /dev/null +++ b/browser/components/search/extensions/amazondotcn/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "亚马逊", + "description": "亚马逊搜索", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "amazondotcn@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "default", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": "@amazon", + "name": "亚马逊", + "search_url": "__MSG_searchUrl__", + "search_form": "https://www.amazon.cn/", + "search_url_get_params": "__MSG_searchUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/amazondotcom/_locales/en/messages.json b/browser/components/search/extensions/amazondotcom/_locales/en/messages.json new file mode 100644 index 0000000000..ab88c4f41a --- /dev/null +++ b/browser/components/search/extensions/amazondotcom/_locales/en/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Amazon.com" + }, + "extensionDescription": { + "message": "Amazon.com Search" + }, + "searchUrl": { + "message": "https://www.amazon.com/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.com/exec/obidos/external-search/" + }, + "suggestUrl": { + "message": "https://completion.amazon.com/search/complete?q={searchTerms}&search-alias=aps&mkt=1" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=mozilla-20&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/amazondotcom/_locales/us/messages.json b/browser/components/search/extensions/amazondotcom/_locales/us/messages.json new file mode 100644 index 0000000000..3822bd3de0 --- /dev/null +++ b/browser/components/search/extensions/amazondotcom/_locales/us/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Amazon.com" + }, + "extensionDescription": { + "message": "Amazon.com Search" + }, + "searchUrl": { + "message": "https://www.amazon.com/exec/obidos/external-search/" + }, + "searchForm": { + "message": "https://www.amazon.com/exec/obidos/external-search/" + }, + "suggestUrl": { + "message": "https://completion.amazon.com/search/complete?q={searchTerms}&search-alias=aps&mkt=1" + }, + "searchUrlGetParams": { + "message": "field-keywords={searchTerms}&ie={inputEncoding}&mode=blended&tag=moz-us-20&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/amazondotcom/favicon.ico b/browser/components/search/extensions/amazondotcom/favicon.ico Binary files differnew file mode 100644 index 0000000000..1c39eaf8fe --- /dev/null +++ b/browser/components/search/extensions/amazondotcom/favicon.ico diff --git a/browser/components/search/extensions/amazondotcom/manifest.json b/browser/components/search/extensions/amazondotcom/manifest.json new file mode 100644 index 0000000000..7cce995b0e --- /dev/null +++ b/browser/components/search/extensions/amazondotcom/manifest.json @@ -0,0 +1,27 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionDescription__", + "manifest_version": 2, + "version": "1.6", + "browser_specific_settings": { + "gecko": { + "id": "amazondotcom@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "en", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": "@amazon", + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "search_form": "__MSG_searchForm__", + "suggest_url": "__MSG_suggestUrl__", + "search_url_get_params": "__MSG_searchUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/azerdict/favicon.ico b/browser/components/search/extensions/azerdict/favicon.ico Binary files differnew file mode 100644 index 0000000000..ba687ca8e7 --- /dev/null +++ b/browser/components/search/extensions/azerdict/favicon.ico diff --git a/browser/components/search/extensions/azerdict/manifest.json b/browser/components/search/extensions/azerdict/manifest.json new file mode 100644 index 0000000000..50220463a3 --- /dev/null +++ b/browser/components/search/extensions/azerdict/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "Azerdict", + "description": "Azərbaycanın Online Lüğəti", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "azerdict@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Azerdict", + "search_url": "https://azerdict.com/english/", + "search_form": "https://azerdict.com/", + "search_url_get_params": "word={searchTerms}", + "suggest_url": "https://api.azerdict.com/english/autocomplete", + "suggest_url_get_params": "action=opensearch&query={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/baidu/favicon.ico b/browser/components/search/extensions/baidu/favicon.ico Binary files differnew file mode 100644 index 0000000000..e1c770cc4b --- /dev/null +++ b/browser/components/search/extensions/baidu/favicon.ico diff --git a/browser/components/search/extensions/baidu/manifest.json b/browser/components/search/extensions/baidu/manifest.json new file mode 100644 index 0000000000..214c5ad0cf --- /dev/null +++ b/browser/components/search/extensions/baidu/manifest.json @@ -0,0 +1,27 @@ +{ + "name": "百度", + "description": "百度网页搜索", + "manifest_version": 2, + "version": "1.3", + "browser_specific_settings": { + "gecko": { + "id": "baidu@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": ["@\u767E\u5EA6", "@baidu"], + "name": "百度", + "search_url": "https://www.baidu.com/baidu", + "search_form": "https://www.baidu.com/", + "search_url_get_params": "tn=monline_7_dg&ie=utf-8&wd={searchTerms}", + "suggest_url": "https://www.baidu.com/su", + "suggest_url_get_params": "tn=monline_7_dg&ie=utf-8&action=opensearch&wd={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/bing/favicon.ico b/browser/components/search/extensions/bing/favicon.ico Binary files differnew file mode 100644 index 0000000000..fdc021cfeb --- /dev/null +++ b/browser/components/search/extensions/bing/favicon.ico diff --git a/browser/components/search/extensions/bing/manifest.json b/browser/components/search/extensions/bing/manifest.json new file mode 100644 index 0000000000..655379139a --- /dev/null +++ b/browser/components/search/extensions/bing/manifest.json @@ -0,0 +1,59 @@ +{ + "name": "Bing", + "description": "Microsoft Bing", + "manifest_version": 2, + "version": "1.5", + "browser_specific_settings": { + "gecko": { + "id": "bing@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": "@bing", + "name": "Bing", + "search_url": "https://www.bing.com/search", + "search_form": "https://www.bing.com/search", + "search_url_get_params": "pc=MOZI&q={searchTerms}", + "params": [ + { + "name": "form", + "condition": "purpose", + "purpose": "contextmenu", + "value": "MOZCON" + }, + { + "name": "form", + "condition": "purpose", + "purpose": "searchbar", + "value": "MOZSBR" + }, + { + "name": "form", + "condition": "purpose", + "purpose": "homepage", + "value": "MOZSPG" + }, + { + "name": "form", + "condition": "purpose", + "purpose": "keyword", + "value": "MOZLBR" + }, + { + "name": "form", + "condition": "purpose", + "purpose": "newtab", + "value": "MOZTSB" + } + ], + "suggest_url": "https://www.bing.com/osjson.aspx", + "suggest_url_get_params": "query={searchTerms}&form=OSDJAS&language={moz:locale}" + } + } +} diff --git a/browser/components/search/extensions/bok-NO/favicon.png b/browser/components/search/extensions/bok-NO/favicon.png Binary files differnew file mode 100644 index 0000000000..c2d46117ef --- /dev/null +++ b/browser/components/search/extensions/bok-NO/favicon.png diff --git a/browser/components/search/extensions/bok-NO/manifest.json b/browser/components/search/extensions/bok-NO/manifest.json new file mode 100644 index 0000000000..55b5f058a0 --- /dev/null +++ b/browser/components/search/extensions/bok-NO/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Ordbok", + "description": "Norske ordbøker", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "bok-NO@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.png" + }, + "web_accessible_resources": ["favicon.png"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Ordbok", + "search_url": "https://ordbok.uib.no/perl/ordbok.cgi", + "search_form": "https://ordbok.uib.no/", + "search_url_get_params": "OPP={searchTerms}&sourceid=Mozilla-search" + } + } +} diff --git a/browser/components/search/extensions/ceneji/favicon.png b/browser/components/search/extensions/ceneji/favicon.png Binary files differnew file mode 100644 index 0000000000..3c77b64d3c --- /dev/null +++ b/browser/components/search/extensions/ceneji/favicon.png diff --git a/browser/components/search/extensions/ceneji/manifest.json b/browser/components/search/extensions/ceneji/manifest.json new file mode 100644 index 0000000000..df15149ef3 --- /dev/null +++ b/browser/components/search/extensions/ceneji/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Ceneje.si", + "description": "Iskalnik Ceneje.si", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "ceneji@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.png" + }, + "web_accessible_resources": ["favicon.png"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Ceneje.si", + "search_url": "https://www.ceneje.si/search_new.aspx", + "search_form": "https://www.ceneje.si", + "search_url_get_params": "q={searchTerms}&FF-SearchBox=1" + } + } +} diff --git a/browser/components/search/extensions/coccoc/favicon.ico b/browser/components/search/extensions/coccoc/favicon.ico Binary files differnew file mode 100644 index 0000000000..f128244fed --- /dev/null +++ b/browser/components/search/extensions/coccoc/favicon.ico diff --git a/browser/components/search/extensions/coccoc/manifest.json b/browser/components/search/extensions/coccoc/manifest.json new file mode 100644 index 0000000000..ba44adb2ce --- /dev/null +++ b/browser/components/search/extensions/coccoc/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "Cốc Cốc", + "description": "Use Cốc Cốc to search on coccoc.com", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "coccoc@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Cốc Cốc", + "search_url": "https://coccoc.com/search", + "search_url_get_params": "query={searchTerms}&s=ff&utm_source=firefox", + "suggest_url": "https://coccoc.com/composer/autocomplete", + "suggest_url_get_params": "of=b&q={searchTerms}&s=ff" + } + } +} diff --git a/browser/components/search/extensions/daum-kr/favicon.ico b/browser/components/search/extensions/daum-kr/favicon.ico Binary files differnew file mode 100644 index 0000000000..ed803f50e2 --- /dev/null +++ b/browser/components/search/extensions/daum-kr/favicon.ico diff --git a/browser/components/search/extensions/daum-kr/manifest.json b/browser/components/search/extensions/daum-kr/manifest.json new file mode 100644 index 0000000000..1e6015ea4f --- /dev/null +++ b/browser/components/search/extensions/daum-kr/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "다음", + "description": "다음 검색", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "daum-kr@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "다음", + "search_url": "https://search.daum.net/search", + "search_form": "https://search.daum.net", + "search_url_get_params": "q={searchTerms}&w=tot&nil_ch=ffsr", + "suggest_url": "https://suggest.search.daum.net/sushi/opensearch/pc", + "suggest_url_get_params": "q={searchTerms}&DA=JU2" + } + } +} diff --git a/browser/components/search/extensions/ddg/favicon.ico b/browser/components/search/extensions/ddg/favicon.ico Binary files differnew file mode 100644 index 0000000000..3ad20825c1 --- /dev/null +++ b/browser/components/search/extensions/ddg/favicon.ico diff --git a/browser/components/search/extensions/ddg/manifest.json b/browser/components/search/extensions/ddg/manifest.json new file mode 100644 index 0000000000..1e1bffed47 --- /dev/null +++ b/browser/components/search/extensions/ddg/manifest.json @@ -0,0 +1,27 @@ +{ + "name": "DuckDuckGo", + "description": "Search DuckDuckGo", + "manifest_version": 2, + "version": "1.4", + "browser_specific_settings": { + "gecko": { + "id": "ddg@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": ["@duckduckgo", "@ddg"], + "name": "DuckDuckGo", + "search_url": "https://duckduckgo.com/", + "search_form": "https://duckduckgo.com/", + "search_url_get_params": "t=ffab&q={searchTerms}", + "suggest_url": "https://ac.duckduckgo.com/ac/", + "suggest_url_get_params": "q={searchTerms}&type=list" + } + } +} diff --git a/browser/components/search/extensions/ebay/_locales/at/messages.json b/browser/components/search/extensions/ebay/_locales/at/messages.json new file mode 100644 index 0000000000..ee7ab962cc --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/at/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.at/sch/" + }, + "searchForm": { + "message": "https://www.ebay.at/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=5221-53469-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=16&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/au/messages.json b/browser/components/search/extensions/ebay/_locales/au/messages.json new file mode 100644 index 0000000000..4e0a1d374e --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/au/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.com.au/sch/" + }, + "searchForm": { + "message": "https://www.ebay.com.au/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=705-53470-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=15&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/be/messages.json b/browser/components/search/extensions/ebay/_locales/be/messages.json new file mode 100644 index 0000000000..918c0443a9 --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/be/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.befr.ebay.be/sch/" + }, + "searchForm": { + "message": "https://www.befr.ebay.be/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=1553-53471-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=23&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/ca/messages.json b/browser/components/search/extensions/ebay/_locales/ca/messages.json new file mode 100644 index 0000000000..23b07f14b6 --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/ca/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.ca/sch/" + }, + "searchForm": { + "message": "https://www.ebay.ca/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=706-53473-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=2&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/ch/messages.json b/browser/components/search/extensions/ebay/_locales/ch/messages.json new file mode 100644 index 0000000000..2c181eaa9f --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/ch/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.ch/sch/" + }, + "searchForm": { + "message": "https://www.ebay.ch/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=5222-53480-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=193&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/de/messages.json b/browser/components/search/extensions/ebay/_locales/de/messages.json new file mode 100644 index 0000000000..02ffb6f43a --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/de/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.de/sch/" + }, + "searchForm": { + "message": "https://www.ebay.de/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=707-53477-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=77&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/en/messages.json b/browser/components/search/extensions/ebay/_locales/en/messages.json new file mode 100644 index 0000000000..d17d77f2b3 --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/en/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.com/sch/" + }, + "searchForm": { + "message": "https://www.ebay.com/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=711-53200-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=0&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/es/messages.json b/browser/components/search/extensions/ebay/_locales/es/messages.json new file mode 100644 index 0000000000..8ef67142dd --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/es/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.es/sch/" + }, + "searchForm": { + "message": "https://www.ebay.es/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=1185-53479-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=186&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/fr/messages.json b/browser/components/search/extensions/ebay/_locales/fr/messages.json new file mode 100644 index 0000000000..545afafe09 --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/fr/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.fr/sch/" + }, + "searchForm": { + "message": "https://www.ebay.fr/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=709-53476-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=71&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/ie/messages.json b/browser/components/search/extensions/ebay/_locales/ie/messages.json new file mode 100644 index 0000000000..194f54adcb --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/ie/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.ie/sch/" + }, + "searchForm": { + "message": "https://www.ebay.ie/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=5282-53468-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=205&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/it/messages.json b/browser/components/search/extensions/ebay/_locales/it/messages.json new file mode 100644 index 0000000000..ff78adaa74 --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/it/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.it/sch/" + }, + "searchForm": { + "message": "https://www.ebay.it/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=724-53478-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=101&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/nl/messages.json b/browser/components/search/extensions/ebay/_locales/nl/messages.json new file mode 100644 index 0000000000..075abe659a --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/nl/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.nl/sch/" + }, + "searchForm": { + "message": "https://www.ebay.nl/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=1346-53482-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=146&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/_locales/uk/messages.json b/browser/components/search/extensions/ebay/_locales/uk/messages.json new file mode 100644 index 0000000000..d0918a1e35 --- /dev/null +++ b/browser/components/search/extensions/ebay/_locales/uk/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "eBay" + }, + "extensionDescription": { + "message": "eBay - Online auctions" + }, + "searchUrl": { + "message": "https://www.ebay.co.uk/sch/" + }, + "searchForm": { + "message": "https://www.ebay.co.uk/" + }, + "searchUrlGetParams": { + "message": "toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=710-53481-19255-0&kw={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "sId=3&fmt=osr&kwd={searchTerms}" + } +} diff --git a/browser/components/search/extensions/ebay/favicon.ico b/browser/components/search/extensions/ebay/favicon.ico Binary files differnew file mode 100644 index 0000000000..3af7a36484 --- /dev/null +++ b/browser/components/search/extensions/ebay/favicon.ico diff --git a/browser/components/search/extensions/ebay/manifest.json b/browser/components/search/extensions/ebay/manifest.json new file mode 100644 index 0000000000..d4721688fe --- /dev/null +++ b/browser/components/search/extensions/ebay/manifest.json @@ -0,0 +1,28 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionDescription__", + "manifest_version": 2, + "version": "1.4", + "browser_specific_settings": { + "gecko": { + "id": "ebay@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "en", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": "@ebay", + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "search_form": "__MSG_searchForm__", + "search_url_get_params": "__MSG_searchUrlGetParams__", + "suggest_url": "https://autosug.ebay.com/autosug", + "suggest_url_get_params": "__MSG_suggestUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/ecosia/favicon.ico b/browser/components/search/extensions/ecosia/favicon.ico Binary files differnew file mode 100644 index 0000000000..cc72d09d6d --- /dev/null +++ b/browser/components/search/extensions/ecosia/favicon.ico diff --git a/browser/components/search/extensions/ecosia/manifest.json b/browser/components/search/extensions/ecosia/manifest.json new file mode 100644 index 0000000000..74fc9aff59 --- /dev/null +++ b/browser/components/search/extensions/ecosia/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "Ecosia", + "description": "Search Ecosia", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "ecosia@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Ecosia", + "search_url": "https://www.ecosia.org/search", + "search_form": "https://www.ecosia.org/", + "search_url_get_params": "tt=mzl&q={searchTerms}", + "suggest_url": "https://ac.ecosia.org/autocomplete", + "suggest_url_get_params": "type=list&q={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/eudict/favicon.ico b/browser/components/search/extensions/eudict/favicon.ico Binary files differnew file mode 100644 index 0000000000..20750d0c19 --- /dev/null +++ b/browser/components/search/extensions/eudict/favicon.ico diff --git a/browser/components/search/extensions/eudict/manifest.json b/browser/components/search/extensions/eudict/manifest.json new file mode 100644 index 0000000000..d3ebc2d77b --- /dev/null +++ b/browser/components/search/extensions/eudict/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "EUdict Eng->Cro", + "description": "EUdict - englesko-hrvatski rječnik", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "eudict@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "EUdict Eng->Cro", + "search_url": "https://eudict.com", + "search_form": "https://eudict.com?lang=engcro", + "search_url_get_params": "lang=engcro&word={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/faclair-beag/favicon.ico b/browser/components/search/extensions/faclair-beag/favicon.ico Binary files differnew file mode 100644 index 0000000000..990cf93298 --- /dev/null +++ b/browser/components/search/extensions/faclair-beag/favicon.ico diff --git a/browser/components/search/extensions/faclair-beag/manifest.json b/browser/components/search/extensions/faclair-beag/manifest.json new file mode 100644 index 0000000000..cc76816056 --- /dev/null +++ b/browser/components/search/extensions/faclair-beag/manifest.json @@ -0,0 +1,23 @@ +{ + "name": "Am Faclair Beag", + "description": "Lorg Am Faclair Beag", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "faclair-beag@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Am Faclair Beag", + "search_url": "https://www.faclair.com/", + "search_url_get_params": "txtSearch={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/gmx/_locales/de/messages.json b/browser/components/search/extensions/gmx/_locales/de/messages.json new file mode 100644 index 0000000000..d03ed6fd64 --- /dev/null +++ b/browser/components/search/extensions/gmx/_locales/de/messages.json @@ -0,0 +1,17 @@ +{ + "extensionName": { + "message": "GMX Suche" + }, + "searchUrl": { + "message": "https://go.gmx.net/br/moz_search_web/" + }, + "suggestUrl": { + "message": "https://suggestplugin.ui-portal.de/s" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&enc=UTF-8" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&brand=gmx&origin=br_splugin_ff_sg" + } +} diff --git a/browser/components/search/extensions/gmx/_locales/en-GB/messages.json b/browser/components/search/extensions/gmx/_locales/en-GB/messages.json new file mode 100644 index 0000000000..9822021f24 --- /dev/null +++ b/browser/components/search/extensions/gmx/_locales/en-GB/messages.json @@ -0,0 +1,17 @@ +{ + "extensionName": { + "message": "GMX Search" + }, + "searchUrl": { + "message": "https://go.gmx.co.uk/br/moz_search_web/" + }, + "suggestUrl": { + "message": "https://suggestplugin.gmx.co.uk/s" + }, + "searchUrlGetParams": { + "message": "enc=UTF-8&q={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&brand=gmxcouk&origin=moz_splugin_ff&enc=UTF-8" + } +} diff --git a/browser/components/search/extensions/gmx/_locales/es/messages.json b/browser/components/search/extensions/gmx/_locales/es/messages.json new file mode 100644 index 0000000000..664f36c0a1 --- /dev/null +++ b/browser/components/search/extensions/gmx/_locales/es/messages.json @@ -0,0 +1,17 @@ +{ + "extensionName": { + "message": "GMX - Búsqueda web" + }, + "searchUrl": { + "message": "https://go.gmx.es/br/moz_search_web/" + }, + "suggestUrl": { + "message": "https://suggestplugin.gmx.es/s" + }, + "searchUrlGetParams": { + "message": "enc=UTF-8&q={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&brand=gmxes&origin=moz_splugin_ff&enc=UTF-8" + } +} diff --git a/browser/components/search/extensions/gmx/_locales/fr/messages.json b/browser/components/search/extensions/gmx/_locales/fr/messages.json new file mode 100644 index 0000000000..2623548b99 --- /dev/null +++ b/browser/components/search/extensions/gmx/_locales/fr/messages.json @@ -0,0 +1,17 @@ +{ + "extensionName": { + "message": "GMX - Recherche web" + }, + "searchUrl": { + "message": "https://go.gmx.fr/br/moz_search_web/" + }, + "suggestUrl": { + "message": "https://suggestplugin.gmx.fr/s" + }, + "searchUrlGetParams": { + "message": "enc=UTF-8&q={searchTerms}" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&brand=gmxfr&origin=moz_splugin_ff&enc=UTF-8" + } +} diff --git a/browser/components/search/extensions/gmx/_locales/shopping/messages.json b/browser/components/search/extensions/gmx/_locales/shopping/messages.json new file mode 100644 index 0000000000..fa15088706 --- /dev/null +++ b/browser/components/search/extensions/gmx/_locales/shopping/messages.json @@ -0,0 +1,17 @@ +{ + "extensionName": { + "message": "GMX Shopping" + }, + "searchUrl": { + "message": "https://shopping.gmx.net/" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&origin=br_osd" + }, + "suggestUrl": { + "message": "https://shopping.gmx.net/suggest/ca/" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}" + } +} diff --git a/browser/components/search/extensions/gmx/favicon.png b/browser/components/search/extensions/gmx/favicon.png Binary files differnew file mode 100644 index 0000000000..020006b5e4 --- /dev/null +++ b/browser/components/search/extensions/gmx/favicon.png diff --git a/browser/components/search/extensions/gmx/manifest.json b/browser/components/search/extensions/gmx/manifest.json new file mode 100644 index 0000000000..4605b5daad --- /dev/null +++ b/browser/components/search/extensions/gmx/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionName__", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "gmx@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "de", + "icons": { + "16": "favicon.png" + }, + "web_accessible_resources": ["favicon.png"], + "chrome_settings_overrides": { + "search_provider": { + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "suggest_url": "__MSG_suggestUrl__", + "search_url_get_params": "__MSG_searchUrlGetParams__", + "suggest_url_get_params": "__MSG_suggestUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/google/_locales/en/messages.json b/browser/components/search/extensions/google/_locales/en/messages.json new file mode 100644 index 0000000000..e45a67a13f --- /dev/null +++ b/browser/components/search/extensions/google/_locales/en/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Google" + }, + "extensionDescription": { + "message": "Google Search" + }, + "searchUrl": { + "message": "https://www.google.com/search" + }, + "searchForm": { + "message": "https://www.google.com/search" + }, + "suggestUrl": { + "message": "https://www.google.com/complete/search?client=firefox&q={searchTerms}" + }, + "searchUrlGetParams": { + "message": "client=firefox-b-d&q={searchTerms}" + }, + "channelPref": { + "message": "google_channel_row" + } +} diff --git a/browser/components/search/extensions/google/_locales/region-by/messages.json b/browser/components/search/extensions/google/_locales/region-by/messages.json new file mode 100644 index 0000000000..4ad45a4aba --- /dev/null +++ b/browser/components/search/extensions/google/_locales/region-by/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Google" + }, + "extensionDescription": { + "message": "Google Search" + }, + "searchUrl": { + "message": "https://www.google.by/search" + }, + "searchForm": { + "message": "https://www.google.by/search" + }, + "suggestUrl": { + "message": "https://www.google.by/complete/search?client=firefox&q={searchTerms}" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}" + } +} diff --git a/browser/components/search/extensions/google/_locales/region-kz/messages.json b/browser/components/search/extensions/google/_locales/region-kz/messages.json new file mode 100644 index 0000000000..6497b5a84a --- /dev/null +++ b/browser/components/search/extensions/google/_locales/region-kz/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Google" + }, + "extensionDescription": { + "message": "Google Search" + }, + "searchUrl": { + "message": "https://www.google.kz/search" + }, + "searchForm": { + "message": "https://www.google.kz/search" + }, + "suggestUrl": { + "message": "https://www.google.kz/complete/search?client=firefox&q={searchTerms}" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}" + } +} diff --git a/browser/components/search/extensions/google/_locales/region-ru/messages.json b/browser/components/search/extensions/google/_locales/region-ru/messages.json new file mode 100644 index 0000000000..85a6c29902 --- /dev/null +++ b/browser/components/search/extensions/google/_locales/region-ru/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Google" + }, + "extensionDescription": { + "message": "Google Search" + }, + "searchUrl": { + "message": "https://www.google.ru/search" + }, + "searchForm": { + "message": "https://www.google.ru/search" + }, + "suggestUrl": { + "message": "https://www.google.ru/complete/search?client=firefox&q={searchTerms}" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}" + } +} diff --git a/browser/components/search/extensions/google/_locales/region-tr/messages.json b/browser/components/search/extensions/google/_locales/region-tr/messages.json new file mode 100644 index 0000000000..4d8cd5a199 --- /dev/null +++ b/browser/components/search/extensions/google/_locales/region-tr/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Google" + }, + "extensionDescription": { + "message": "Google Search" + }, + "searchUrl": { + "message": "https://www.google.com.tr/search" + }, + "searchForm": { + "message": "https://www.google.com.tr/search" + }, + "suggestUrl": { + "message": "https://www.google.com.tr/complete/search?client=firefox&q={searchTerms}" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}" + } +} diff --git a/browser/components/search/extensions/google/favicon.ico b/browser/components/search/extensions/google/favicon.ico Binary files differnew file mode 100644 index 0000000000..82339b3b1d --- /dev/null +++ b/browser/components/search/extensions/google/favicon.ico diff --git a/browser/components/search/extensions/google/manifest.json b/browser/components/search/extensions/google/manifest.json new file mode 100644 index 0000000000..5c48bf553f --- /dev/null +++ b/browser/components/search/extensions/google/manifest.json @@ -0,0 +1,34 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionDescription__", + "manifest_version": 2, + "version": "1.4", + "browser_specific_settings": { + "gecko": { + "id": "google@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "en", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": "@google", + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "search_form": "__MSG_searchForm__", + "suggest_url": "__MSG_suggestUrl__", + "params": [ + { + "name": "channel", + "condition": "pref", + "pref": "__MSG_channelPref__" + } + ], + "search_url_get_params": "__MSG_searchUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/gulesider-NO/favicon.ico b/browser/components/search/extensions/gulesider-NO/favicon.ico Binary files differnew file mode 100644 index 0000000000..e35572a557 --- /dev/null +++ b/browser/components/search/extensions/gulesider-NO/favicon.ico diff --git a/browser/components/search/extensions/gulesider-NO/manifest.json b/browser/components/search/extensions/gulesider-NO/manifest.json new file mode 100644 index 0000000000..c01fef7989 --- /dev/null +++ b/browser/components/search/extensions/gulesider-NO/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Gule sider", + "description": "Gule sider person og firmasøk", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "gulesider-NO@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Gule sider", + "search_url": "https://www.gulesider.no/search", + "search_form": "https://www.gulesider.no/", + "search_url_get_params": "what=all&cmpid=fre_partner_fire_gssbtop&q={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/leo_ende_de/favicon.png b/browser/components/search/extensions/leo_ende_de/favicon.png Binary files differnew file mode 100644 index 0000000000..04e5e344ef --- /dev/null +++ b/browser/components/search/extensions/leo_ende_de/favicon.png diff --git a/browser/components/search/extensions/leo_ende_de/manifest.json b/browser/components/search/extensions/leo_ende_de/manifest.json new file mode 100644 index 0000000000..f6733b7dd1 --- /dev/null +++ b/browser/components/search/extensions/leo_ende_de/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "LEO Eng-Deu", + "description": "Deutsch-Englisch Wörterbuch von LEO", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "leo_ende_de@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.png" + }, + "web_accessible_resources": ["favicon.png"], + "chrome_settings_overrides": { + "search_provider": { + "name": "LEO Eng-Deu", + "search_url": "https://dict.leo.org/englisch-deutsch/{searchTerms}", + "search_form": "https://dict.leo.org", + "suggest_url": "https://dict.leo.org/dictQuery/m-query/conf/ende/query.conf/strlist.json", + "suggest_url_get_params": "q={searchTerms}&sort=PLa&shortQuery=undefined&noDescription=undefined&noQueryURLs=undefined" + } + } +} diff --git a/browser/components/search/extensions/longdo/favicon.ico b/browser/components/search/extensions/longdo/favicon.ico Binary files differnew file mode 100644 index 0000000000..aa42cda97f --- /dev/null +++ b/browser/components/search/extensions/longdo/favicon.ico diff --git a/browser/components/search/extensions/longdo/manifest.json b/browser/components/search/extensions/longdo/manifest.json new file mode 100644 index 0000000000..51f56f7eba --- /dev/null +++ b/browser/components/search/extensions/longdo/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "พจนานุกรม ลองดู", + "description": "พจนานุกรม ลองดู", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "longdo@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "พจนานุกรม ลองดู", + "search_url": "https://dict.longdo.org/", + "search_form": "https://dict.longdo.org/", + "search_url_get_params": "search={searchTerms}&src=moz", + "suggest_url": "https://search.longdo.com/Suggest/HeadSearch", + "suggest_url_get_params": "ds=head&fxjson=1&key={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/mailcom/favicon.ico b/browser/components/search/extensions/mailcom/favicon.ico Binary files differnew file mode 100644 index 0000000000..9f1bed60f8 --- /dev/null +++ b/browser/components/search/extensions/mailcom/favicon.ico diff --git a/browser/components/search/extensions/mailcom/manifest.json b/browser/components/search/extensions/mailcom/manifest.json new file mode 100644 index 0000000000..e01016b7df --- /dev/null +++ b/browser/components/search/extensions/mailcom/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "mail.com", + "description": "mail.com", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "mailcom@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "mail.com search", + "search_url": "https://go.mail.com/br/moz_search_web/", + "search_url_get_params": "q={searchTerms}&enc=UTF-8", + "suggest_url": "https://search.mail.com/SuggestSearch/s", + "suggest_url_get_params": "q={searchTerms}&brand=mailcom&origin=br_splugin_ff_sg" + } + } +} diff --git a/browser/components/search/extensions/mailru/_locales/default/messages.json b/browser/components/search/extensions/mailru/_locales/default/messages.json new file mode 100644 index 0000000000..c902c14424 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/default/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900200" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900200&frc=900200" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900200" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/mailru001/messages.json b/browser/components/search/extensions/mailru/_locales/mailru001/messages.json new file mode 100644 index 0000000000..2b40a70dd0 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/mailru001/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900201" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900201&frc=900201" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900201" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-az/messages.json b/browser/components/search/extensions/mailru/_locales/okru-az/messages.json new file mode 100644 index 0000000000..a8b85dc600 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-az/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900209" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900209&frc=900209" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900209" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-en-US/messages.json b/browser/components/search/extensions/mailru/_locales/okru-en-US/messages.json new file mode 100644 index 0000000000..cf737cae11 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-en-US/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900205" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900205&frc=900205" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900205" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-hy-AM/messages.json b/browser/components/search/extensions/mailru/_locales/okru-hy-AM/messages.json new file mode 100644 index 0000000000..65e5ef1077 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-hy-AM/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900211" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900211&frc=900211" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900211" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-kk/messages.json b/browser/components/search/extensions/mailru/_locales/okru-kk/messages.json new file mode 100644 index 0000000000..8da96ed9b2 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-kk/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900206" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900206&frc=900206" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900206" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-ro/messages.json b/browser/components/search/extensions/mailru/_locales/okru-ro/messages.json new file mode 100644 index 0000000000..66724aba79 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-ro/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900207" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900207&frc=900207" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900207" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-ru/messages.json b/browser/components/search/extensions/mailru/_locales/okru-ru/messages.json new file mode 100644 index 0000000000..c38275f3cc --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-ru/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900203" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900203&frc=900203" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900203" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-tr/messages.json b/browser/components/search/extensions/mailru/_locales/okru-tr/messages.json new file mode 100644 index 0000000000..f3126ab63a --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-tr/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900210" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900210&frc=900210" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900210" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-uk/messages.json b/browser/components/search/extensions/mailru/_locales/okru-uk/messages.json new file mode 100644 index 0000000000..14153aa013 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-uk/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900204" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900204&frc=900204" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900204" + } +} diff --git a/browser/components/search/extensions/mailru/_locales/okru-uz/messages.json b/browser/components/search/extensions/mailru/_locales/okru-uz/messages.json new file mode 100644 index 0000000000..206a696842 --- /dev/null +++ b/browser/components/search/extensions/mailru/_locales/okru-uz/messages.json @@ -0,0 +1,11 @@ +{ + "searchForm": { + "message": "https://go.mail.ru/?gp=900208" + }, + "searchUrlGetParams": { + "message": "q={searchTerms}&fr=osmi&gp=900208&frc=900208" + }, + "suggestUrlGetParams": { + "message": "q={searchTerms}&gp=900208" + } +} diff --git a/browser/components/search/extensions/mailru/favicon.ico b/browser/components/search/extensions/mailru/favicon.ico Binary files differnew file mode 100644 index 0000000000..a2d3a48883 --- /dev/null +++ b/browser/components/search/extensions/mailru/favicon.ico diff --git a/browser/components/search/extensions/mailru/manifest.json b/browser/components/search/extensions/mailru/manifest.json new file mode 100644 index 0000000000..28bebde8d0 --- /dev/null +++ b/browser/components/search/extensions/mailru/manifest.json @@ -0,0 +1,27 @@ +{ + "name": "Поиск Mail.Ru", + "description": "Search with Поиск Mail.Ru", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "mailru@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "default", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Поиск Mail.Ru", + "search_url": "https://go.mail.ru/search", + "search_form": "__MSG_searchForm__", + "search_url_get_params": "__MSG_searchUrlGetParams__", + "suggest_url": "https://suggests.go.mail.ru/ff3", + "suggest_url_get_params": "__MSG_suggestUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/mapy-cz/favicon.ico b/browser/components/search/extensions/mapy-cz/favicon.ico Binary files differnew file mode 100644 index 0000000000..051204c35c --- /dev/null +++ b/browser/components/search/extensions/mapy-cz/favicon.ico diff --git a/browser/components/search/extensions/mapy-cz/manifest.json b/browser/components/search/extensions/mapy-cz/manifest.json new file mode 100644 index 0000000000..b6aa3c6b67 --- /dev/null +++ b/browser/components/search/extensions/mapy-cz/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Mapy.cz", + "description": "Vyhledávání na Mapy.cz", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "mapy-cz@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Mapy.cz", + "search_url": "https://www.mapy.cz/", + "search_form": "https://www.mapy.cz/", + "search_url_get_params": "q={searchTerms}&sourceid=Searchmodule_3" + } + } +} diff --git a/browser/components/search/extensions/mercadolibre/_locales/ar/messages.json b/browser/components/search/extensions/mercadolibre/_locales/ar/messages.json new file mode 100644 index 0000000000..b83f37c6fc --- /dev/null +++ b/browser/components/search/extensions/mercadolibre/_locales/ar/messages.json @@ -0,0 +1,17 @@ +{ + "extensionName": { + "message": "MercadoLibre Argentina" + }, + "extensionDescription": { + "message": "MercadoLibre Argentina" + }, + "searchUrl": { + "message": "https://www.mercadolibre.com.ar/jm/search" + }, + "searchForm": { + "message": "https://www.mercadolibre.com.ar/" + }, + "searchUrlGetParams": { + "message": "as_word={searchTerms}" + } +} diff --git a/browser/components/search/extensions/mercadolibre/_locales/cl/messages.json b/browser/components/search/extensions/mercadolibre/_locales/cl/messages.json new file mode 100644 index 0000000000..3c37756464 --- /dev/null +++ b/browser/components/search/extensions/mercadolibre/_locales/cl/messages.json @@ -0,0 +1,17 @@ +{ + "extensionName": { + "message": "MercadoLibre Chile" + }, + "extensionDescription": { + "message": "MercadoLibre Chile" + }, + "searchUrl": { + "message": "https://www.mercadolibre.cl/jm/search" + }, + "searchForm": { + "message": "https://www.mercadolibre.cl/" + }, + "searchUrlGetParams": { + "message": "as_word={searchTerms}" + } +} diff --git a/browser/components/search/extensions/mercadolibre/_locales/mx/messages.json b/browser/components/search/extensions/mercadolibre/_locales/mx/messages.json new file mode 100644 index 0000000000..cb4d2b4b79 --- /dev/null +++ b/browser/components/search/extensions/mercadolibre/_locales/mx/messages.json @@ -0,0 +1,17 @@ +{ + "extensionName": { + "message": "MercadoLibre Mexico" + }, + "extensionDescription": { + "message": "MercadoLibre Mexico" + }, + "searchUrl": { + "message": "https://www.mercadolibre.com.mx/jm/search" + }, + "searchForm": { + "message": "https://www.mercadolibre.com.mx/" + }, + "searchUrlGetParams": { + "message": "as_word={searchTerms}" + } +} diff --git a/browser/components/search/extensions/mercadolibre/favicon.ico b/browser/components/search/extensions/mercadolibre/favicon.ico Binary files differnew file mode 100644 index 0000000000..dc9ad5b2a9 --- /dev/null +++ b/browser/components/search/extensions/mercadolibre/favicon.ico diff --git a/browser/components/search/extensions/mercadolibre/manifest.json b/browser/components/search/extensions/mercadolibre/manifest.json new file mode 100644 index 0000000000..32f5d4f9e2 --- /dev/null +++ b/browser/components/search/extensions/mercadolibre/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionDescription__", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "mercadolibre@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "ar", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "search_form": "__MSG_searchForm__", + "search_url_get_params": "__MSG_searchUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/mercadolivre/favicon.ico b/browser/components/search/extensions/mercadolivre/favicon.ico Binary files differnew file mode 100644 index 0000000000..dc9ad5b2a9 --- /dev/null +++ b/browser/components/search/extensions/mercadolivre/favicon.ico diff --git a/browser/components/search/extensions/mercadolivre/manifest.json b/browser/components/search/extensions/mercadolivre/manifest.json new file mode 100644 index 0000000000..bccfa2f0e4 --- /dev/null +++ b/browser/components/search/extensions/mercadolivre/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "MercadoLivre", + "description": "Onde comprar e vender de Tudo.", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "mercadolivre@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "MercadoLivre", + "search_url": "https://www.mercadolivre.com.br/jm/search", + "search_form": "https://www.mercadolivre.com.br/", + "search_url_get_params": "as_word={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/naver-kr/favicon.ico b/browser/components/search/extensions/naver-kr/favicon.ico Binary files differnew file mode 100644 index 0000000000..eed93a92cb --- /dev/null +++ b/browser/components/search/extensions/naver-kr/favicon.ico diff --git a/browser/components/search/extensions/naver-kr/manifest.json b/browser/components/search/extensions/naver-kr/manifest.json new file mode 100644 index 0000000000..3c866e9066 --- /dev/null +++ b/browser/components/search/extensions/naver-kr/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "네이버", + "description": "네이버 검색", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "naver-kr@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "네이버", + "search_url": "https://search.naver.com/search.naver", + "search_form": "https://search.naver.com", + "search_url_get_params": "where=nexearch&frm=ff&sm=oss&ie=utf8&query={searchTerms}", + "suggest_url": "https://ac.search.naver.com/nx/ac", + "suggest_url_get_params": "of=os&ie=utf-8&q={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/odpiralni/favicon.png b/browser/components/search/extensions/odpiralni/favicon.png Binary files differnew file mode 100644 index 0000000000..044d4f13d4 --- /dev/null +++ b/browser/components/search/extensions/odpiralni/favicon.png diff --git a/browser/components/search/extensions/odpiralni/manifest.json b/browser/components/search/extensions/odpiralni/manifest.json new file mode 100644 index 0000000000..fdcb90e5ba --- /dev/null +++ b/browser/components/search/extensions/odpiralni/manifest.json @@ -0,0 +1,23 @@ +{ + "name": "Odpiralni Časi", + "description": "Odpiralni Časi v Sloveniji", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "odpiralni@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.png" + }, + "web_accessible_resources": ["favicon.png"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Odpiralni Časi", + "search_url": "https://www.odpiralnicasi.com/spots", + "search_url_get_params": "q={searchTerms}&source=1" + } + } +} diff --git a/browser/components/search/extensions/pazaruvaj/favicon.ico b/browser/components/search/extensions/pazaruvaj/favicon.ico Binary files differnew file mode 100644 index 0000000000..36f0cff233 --- /dev/null +++ b/browser/components/search/extensions/pazaruvaj/favicon.ico diff --git a/browser/components/search/extensions/pazaruvaj/manifest.json b/browser/components/search/extensions/pazaruvaj/manifest.json new file mode 100644 index 0000000000..dec393e303 --- /dev/null +++ b/browser/components/search/extensions/pazaruvaj/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Pazaruvaj", + "description": "Надежден помощник за покупки, сравнение на цени, онлайн магазини, описания, мнения, видеоклипове", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "pazaruvaj@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Pazaruvaj", + "search_url": "https://www.pazaruvaj.com/CategorySearch.php", + "search_form": "https://www.pazaruvaj.com/", + "search_url_get_params": "st={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/priberam/favicon.png b/browser/components/search/extensions/priberam/favicon.png Binary files differnew file mode 100644 index 0000000000..98924439d5 --- /dev/null +++ b/browser/components/search/extensions/priberam/favicon.png diff --git a/browser/components/search/extensions/priberam/manifest.json b/browser/components/search/extensions/priberam/manifest.json new file mode 100644 index 0000000000..ef4aba79ac --- /dev/null +++ b/browser/components/search/extensions/priberam/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "Priberam", + "description": "Dicionário Priberam", + "manifest_version": 2, + "version": "1.3", + "browser_specific_settings": { + "gecko": { + "id": "priberam@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.png" + }, + "web_accessible_resources": ["favicon.png"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Priberam", + "encoding": "ISO-8859-15", + "search_url": "https://www.priberam.pt/dlpo/firefox.aspx", + "search_form": "https://www.priberam.pt/dlpo/", + "search_url_get_params": "pal={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/prisjakt-sv-SE/favicon.ico b/browser/components/search/extensions/prisjakt-sv-SE/favicon.ico Binary files differnew file mode 100644 index 0000000000..feac665f71 --- /dev/null +++ b/browser/components/search/extensions/prisjakt-sv-SE/favicon.ico diff --git a/browser/components/search/extensions/prisjakt-sv-SE/manifest.json b/browser/components/search/extensions/prisjakt-sv-SE/manifest.json new file mode 100644 index 0000000000..ee65ba4f56 --- /dev/null +++ b/browser/components/search/extensions/prisjakt-sv-SE/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "Prisjakt", + "description": "Prisjakt - jämför priser och produkter", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "prisjakt-sv-SE@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Prisjakt", + "search_url": "https://www.prisjakt.nu/search", + "search_url_get_params": "search={searchTerms}", + "search_form": "https://www.prisjakt.nu/search", + "suggest_url": "https://www.prisjakt.nu/plugins/opensearch/suggestions.php", + "suggest_url_get_params": "search={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/qwant/favicon.ico b/browser/components/search/extensions/qwant/favicon.ico Binary files differnew file mode 100644 index 0000000000..d43d1d5aa6 --- /dev/null +++ b/browser/components/search/extensions/qwant/favicon.ico diff --git a/browser/components/search/extensions/qwant/manifest.json b/browser/components/search/extensions/qwant/manifest.json new file mode 100644 index 0000000000..cceb5994cb --- /dev/null +++ b/browser/components/search/extensions/qwant/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "Qwant", + "manifest_version": 2, + "version": "1.4", + "browser_specific_settings": { + "gecko": { + "id": "qwant@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": "@qwant", + "name": "Qwant", + "search_url": "https://www.qwant.com/", + "search_url_get_params": "client=brz-moz&q={searchTerms}", + "suggest_url": "https://api.qwant.com/api/suggest/", + "suggest_url_get_params": "client=opensearch&q={searchTerms}", + "search_form": "https://www.qwant.com/" + } + } +} diff --git a/browser/components/search/extensions/qwantjr/favicon.ico b/browser/components/search/extensions/qwantjr/favicon.ico Binary files differnew file mode 100644 index 0000000000..d43d1d5aa6 --- /dev/null +++ b/browser/components/search/extensions/qwantjr/favicon.ico diff --git a/browser/components/search/extensions/qwantjr/manifest.json b/browser/components/search/extensions/qwantjr/manifest.json new file mode 100644 index 0000000000..fbeab3570b --- /dev/null +++ b/browser/components/search/extensions/qwantjr/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "Qwant Junior", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "qwantjr@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Qwant Junior", + "search_url": "https://www.qwantjunior.com/", + "search_url_get_params": "q={searchTerms}&client=firefoxqwant", + "suggest_url": "https://api.qwant.com/egp/suggest/", + "suggest_url_get_params": "q={searchTerms}&client=opensearch", + "search_form": "https://www.qwantjunior.com/" + } + } +} diff --git a/browser/components/search/extensions/rakuten/favicon.ico b/browser/components/search/extensions/rakuten/favicon.ico Binary files differnew file mode 100644 index 0000000000..66afe98469 --- /dev/null +++ b/browser/components/search/extensions/rakuten/favicon.ico diff --git a/browser/components/search/extensions/rakuten/manifest.json b/browser/components/search/extensions/rakuten/manifest.json new file mode 100644 index 0000000000..4ce1ffcd7a --- /dev/null +++ b/browser/components/search/extensions/rakuten/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "楽天市場", + "description": "楽天市場 商品検索", + "manifest_version": 2, + "version": "1.3", + "browser_specific_settings": { + "gecko": { + "id": "rakuten@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "楽天市場", + "encoding": "EUC-JP", + "search_url": "https://pt.afl.rakuten.co.jp/c/013ca98b.cd7c5f0c/", + "search_form": "https://www.rakuten.co.jp/", + "search_url_get_params": "sitem={searchTerms}&sv=2&p=0" + } + } +} diff --git a/browser/components/search/extensions/readmoo/favicon.ico b/browser/components/search/extensions/readmoo/favicon.ico Binary files differnew file mode 100644 index 0000000000..75396dc9ca --- /dev/null +++ b/browser/components/search/extensions/readmoo/favicon.ico diff --git a/browser/components/search/extensions/readmoo/manifest.json b/browser/components/search/extensions/readmoo/manifest.json new file mode 100644 index 0000000000..4c3622fed4 --- /dev/null +++ b/browser/components/search/extensions/readmoo/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Readmoo 讀墨電子書", + "description": "Readmoo 讀墨電子書", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "readmoo@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Readmoo 讀墨電子書", + "search_url": "https://readmoo.com/search/keyword", + "search_form": "https://readmoo.com/search/keyword?pi=0&st=true", + "search_url_get_params": "pi=0&q={searchTerms}&st=true" + } + } +} diff --git a/browser/components/search/extensions/salidzinilv/favicon.ico b/browser/components/search/extensions/salidzinilv/favicon.ico Binary files differnew file mode 100644 index 0000000000..0a7d01cae8 --- /dev/null +++ b/browser/components/search/extensions/salidzinilv/favicon.ico diff --git a/browser/components/search/extensions/salidzinilv/manifest.json b/browser/components/search/extensions/salidzinilv/manifest.json new file mode 100644 index 0000000000..bc444d5dcf --- /dev/null +++ b/browser/components/search/extensions/salidzinilv/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "Salidzini.lv", + "description": "Salidzini.lv - Latvijas interneta veikalu mekletajs", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "salidzinilv@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Salidzini.lv", + "search_url": "https://www.salidzini.lv/search.php", + "search_form": "https://salidzini.lv", + "search_url_get_params": "q={searchTerms}&utm_source=firefox-plugin", + "suggest_url": "https://www.salidzini.lv/search_suggest_opensearch.php", + "suggest_url_get_params": "q={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/seznam-cz/favicon.ico b/browser/components/search/extensions/seznam-cz/favicon.ico Binary files differnew file mode 100644 index 0000000000..f3e078a107 --- /dev/null +++ b/browser/components/search/extensions/seznam-cz/favicon.ico diff --git a/browser/components/search/extensions/seznam-cz/manifest.json b/browser/components/search/extensions/seznam-cz/manifest.json new file mode 100644 index 0000000000..eaa0e1b11f --- /dev/null +++ b/browser/components/search/extensions/seznam-cz/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "Seznam", + "description": "Vyhledávání na Seznam.cz", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "seznam-cz@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Seznam", + "search_url": "https://search.seznam.cz/", + "search_form": "https://search.seznam.cz/", + "search_url_get_params": "q={searchTerms}&sourceid=firefox", + "suggest_url": "https://suggest.seznam.cz/fulltext_ff", + "suggest_url_get_params": "phrase={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/tyda-sv-SE/favicon.ico b/browser/components/search/extensions/tyda-sv-SE/favicon.ico Binary files differnew file mode 100644 index 0000000000..7415cbb160 --- /dev/null +++ b/browser/components/search/extensions/tyda-sv-SE/favicon.ico diff --git a/browser/components/search/extensions/tyda-sv-SE/manifest.json b/browser/components/search/extensions/tyda-sv-SE/manifest.json new file mode 100644 index 0000000000..cb8d1b3951 --- /dev/null +++ b/browser/components/search/extensions/tyda-sv-SE/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Tyda.se", + "description": "Tyda.se, lexikon, ordlista och översättning.", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "tyda-sv-SE@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Tyda.se", + "search_url": "https://tyda.se", + "search_form": "https://tyda.se", + "search_url_get_params": "w={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/vatera/favicon.ico b/browser/components/search/extensions/vatera/favicon.ico Binary files differnew file mode 100644 index 0000000000..5b02f16cb9 --- /dev/null +++ b/browser/components/search/extensions/vatera/favicon.ico diff --git a/browser/components/search/extensions/vatera/manifest.json b/browser/components/search/extensions/vatera/manifest.json new file mode 100644 index 0000000000..565f7e1af8 --- /dev/null +++ b/browser/components/search/extensions/vatera/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "Vatera.hu", + "description": "Keresés a Vatera.hu piacterén", + "manifest_version": 2, + "version": "1.3", + "browser_specific_settings": { + "gecko": { + "id": "vatera@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Vatera.hu", + "encoding": "ISO-8859-2", + "search_url": "https://www.vatera.hu/listings/index.php", + "search_form": "https://www.vatera.hu/", + "search_url_get_params": "q={searchTerms}&c=0&td=on" + } + } +} diff --git a/browser/components/search/extensions/webde/favicon.ico b/browser/components/search/extensions/webde/favicon.ico Binary files differnew file mode 100644 index 0000000000..f0ef93d209 --- /dev/null +++ b/browser/components/search/extensions/webde/favicon.ico diff --git a/browser/components/search/extensions/webde/manifest.json b/browser/components/search/extensions/webde/manifest.json new file mode 100644 index 0000000000..25adbb03ab --- /dev/null +++ b/browser/components/search/extensions/webde/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "WEB.DE Suche", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "webde@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "WEB.DE Suche", + "search_url": "https://go.web.de/br/moz_search_web/", + "search_url_get_params": "q={searchTerms}&enc=UTF-8", + "suggest_url": "https://suggestplugin.ui-portal.de/s", + "suggest_url_get_params": "q={searchTerms}&brand=webde&origin=br_splugin_ff_sg" + } + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/NN/messages.json b/browser/components/search/extensions/wikipedia/_locales/NN/messages.json new file mode 100644 index 0000000000..f634d94ca8 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/NN/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (nn)" + }, + "extensionDescription": { + "message": "Wikipedia, det frie oppslagsverket" + }, + "searchUrl": { + "message": "https://nn.wikipedia.org/wiki/Spesial:Søk" + }, + "searchForm": { + "message": "https://nn.wikipedia.org/wiki/Spesial:Søk" + }, + "suggestUrl": { + "message": "https://nn.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/NO/messages.json b/browser/components/search/extensions/wikipedia/_locales/NO/messages.json new file mode 100644 index 0000000000..0e83173b7a --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/NO/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (no)" + }, + "extensionDescription": { + "message": "Wikipedia, den frie encyklopedi" + }, + "searchUrl": { + "message": "https://no.wikipedia.org/wiki/Spesial:Søk" + }, + "searchForm": { + "message": "https://no.wikipedia.org/wiki/Spesial:Søk" + }, + "suggestUrl": { + "message": "https://no.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/af/messages.json b/browser/components/search/extensions/wikipedia/_locales/af/messages.json new file mode 100644 index 0000000000..382e3e1412 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/af/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (af)" + }, + "extensionDescription": { + "message": "Wikipedia, die vrye ensiklopedie" + }, + "searchUrl": { + "message": "https://af.wikipedia.org/wiki/Spesiaal:Soek" + }, + "searchForm": { + "message": "https://af.wikipedia.org/wiki/Spesiaal:Soek" + }, + "suggestUrl": { + "message": "https://af.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/an/messages.json b/browser/components/search/extensions/wikipedia/_locales/an/messages.json new file mode 100644 index 0000000000..d205a6b0a7 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/an/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Biquipedia (an)" + }, + "extensionDescription": { + "message": "A enciclopedia Libre" + }, + "searchUrl": { + "message": "https://an.wikipedia.org/wiki/Especial:Mirar" + }, + "searchForm": { + "message": "https://an.wikipedia.org/wiki/Especial:Mirar" + }, + "suggestUrl": { + "message": "https://an.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ar/messages.json b/browser/components/search/extensions/wikipedia/_locales/ar/messages.json new file mode 100644 index 0000000000..0d0fe38ceb --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ar/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "ويكيبيديا (ar)" + }, + "extensionDescription": { + "message": "ويكيبيديا (ar)" + }, + "searchUrl": { + "message": "https://ar.wikipedia.org/wiki/خاص:بحث" + }, + "searchForm": { + "message": "https://ar.wikipedia.org/wiki/خاص:بحث" + }, + "suggestUrl": { + "message": "https://ar.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ast/messages.json b/browser/components/search/extensions/wikipedia/_locales/ast/messages.json new file mode 100644 index 0000000000..b0b17cdb2a --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ast/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (ast)" + }, + "extensionDescription": { + "message": "La enciclopedia llibre" + }, + "searchUrl": { + "message": "https://ast.wikipedia.org/wiki/Especial:Gueta" + }, + "searchForm": { + "message": "https://ast.wikipedia.org/wiki/Especial:Gueta" + }, + "suggestUrl": { + "message": "https://ast.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/az/messages.json b/browser/components/search/extensions/wikipedia/_locales/az/messages.json new file mode 100644 index 0000000000..b67a299a48 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/az/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Vikipediya (az)" + }, + "extensionDescription": { + "message": "Vikipediya, açıq ensiklopediya" + }, + "searchUrl": { + "message": "https://az.wikipedia.org/wiki/Xüsusi:Axtar" + }, + "searchForm": { + "message": "https://az.wikipedia.org/wiki/Xüsusi:Axtar" + }, + "suggestUrl": { + "message": "https://az.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/be-tarask/messages.json b/browser/components/search/extensions/wikipedia/_locales/be-tarask/messages.json new file mode 100644 index 0000000000..eea6296bf1 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/be-tarask/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Вікіпэдыя (be-tarask)" + }, + "extensionDescription": { + "message": "Вікіпэдыя, вольная энцыкляпэдыя" + }, + "searchUrl": { + "message": "https://be-tarask.wikipedia.org/wiki/Спэцыяльныя:Пошук" + }, + "searchForm": { + "message": "https://be-tarask.wikipedia.org/wiki/Спэцыяльныя:Пошук" + }, + "suggestUrl": { + "message": "https://be-tarask.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/be/messages.json b/browser/components/search/extensions/wikipedia/_locales/be/messages.json new file mode 100644 index 0000000000..c826d36246 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/be/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Вікіпедыя (be)" + }, + "extensionDescription": { + "message": "Вікіпедыя, свабодная энцыклапедыя" + }, + "searchUrl": { + "message": "https://be.wikipedia.org/wiki/Адмысловае:Search" + }, + "searchForm": { + "message": "https://be.wikipedia.org/wiki/Адмысловае:Search" + }, + "suggestUrl": { + "message": "https://be.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/bg/messages.json b/browser/components/search/extensions/wikipedia/_locales/bg/messages.json new file mode 100644 index 0000000000..26d103285c --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/bg/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Уикипедия (bg)" + }, + "extensionDescription": { + "message": "Уикипедия, свободната енциклоподия" + }, + "searchUrl": { + "message": "https://bg.wikipedia.org/wiki/Специални:Търсене" + }, + "searchForm": { + "message": "https://bg.wikipedia.org/wiki/Специални:Търсене" + }, + "suggestUrl": { + "message": "https://bg.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/bn/messages.json b/browser/components/search/extensions/wikipedia/_locales/bn/messages.json new file mode 100644 index 0000000000..afe7d94a8d --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/bn/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "উইকিপিডিয়া (bn)" + }, + "extensionDescription": { + "message": "উইকিপিডিয়া, মুক্ত বিশ্বকোষ" + }, + "searchUrl": { + "message": "https://bn.wikipedia.org/wiki/বিশেষ:Search" + }, + "searchForm": { + "message": "https://bn.wikipedia.org/wiki/বিশেষ:Search" + }, + "suggestUrl": { + "message": "https://bn.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/br/messages.json b/browser/components/search/extensions/wikipedia/_locales/br/messages.json new file mode 100644 index 0000000000..ed0e453280 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/br/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (br)" + }, + "extensionDescription": { + "message": "Wikipedia, an holloueziadur digor" + }, + "searchUrl": { + "message": "https://br.wikipedia.org/wiki/Dibar:Klask" + }, + "searchForm": { + "message": "https://br.wikipedia.org/wiki/Dibar:Klask" + }, + "suggestUrl": { + "message": "https://br.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/bs/messages.json b/browser/components/search/extensions/wikipedia/_locales/bs/messages.json new file mode 100644 index 0000000000..00932991c6 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/bs/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (bs)" + }, + "extensionDescription": { + "message": "Slobodna enciklopedija" + }, + "searchUrl": { + "message": "https://bs.wikipedia.org/wiki/Posebno:Pretraga" + }, + "searchForm": { + "message": "https://bs.wikipedia.org/wiki/Posebno:Pretraga" + }, + "suggestUrl": { + "message": "https://bs.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ca/messages.json b/browser/components/search/extensions/wikipedia/_locales/ca/messages.json new file mode 100644 index 0000000000..852be81415 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ca/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Viquipèdia (ca)" + }, + "extensionDescription": { + "message": "L'enciclopèdia lliure" + }, + "searchUrl": { + "message": "https://ca.wikipedia.org/wiki/Especial:Cerca" + }, + "searchForm": { + "message": "https://ca.wikipedia.org/wiki/Especial:Cerca" + }, + "suggestUrl": { + "message": "https://ca.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/cy/messages.json b/browser/components/search/extensions/wikipedia/_locales/cy/messages.json new file mode 100644 index 0000000000..d8522ffafc --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/cy/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wicipedia (cy)" + }, + "extensionDescription": { + "message": "Wicipedia, Y Gwyddioniadur Rhydd" + }, + "searchUrl": { + "message": "https://cy.wikipedia.org/wiki/Arbennig:Search" + }, + "searchForm": { + "message": "https://cy.wikipedia.org/wiki/Arbennig:Search" + }, + "suggestUrl": { + "message": "https://cy.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/cz/messages.json b/browser/components/search/extensions/wikipedia/_locales/cz/messages.json new file mode 100644 index 0000000000..0da42bcd87 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/cz/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedie (cs)" + }, + "extensionDescription": { + "message": "Wikipedia, svobodná encyclopedie" + }, + "searchUrl": { + "message": "https://cs.wikipedia.org/wiki/Speciální:Hledání" + }, + "searchForm": { + "message": "https://cs.wikipedia.org/wiki/Speciální:Hledání" + }, + "suggestUrl": { + "message": "https://cs.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/da/messages.json b/browser/components/search/extensions/wikipedia/_locales/da/messages.json new file mode 100644 index 0000000000..bdca8de0d0 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/da/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (da)" + }, + "extensionDescription": { + "message": "Wikipedia, den frie encyklopædi" + }, + "searchUrl": { + "message": "https://da.wikipedia.org/wiki/Speciel:Søgning" + }, + "searchForm": { + "message": "https://da.wikipedia.org/wiki/Speciel:Søgning" + }, + "suggestUrl": { + "message": "https://da.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/de/messages.json b/browser/components/search/extensions/wikipedia/_locales/de/messages.json new file mode 100644 index 0000000000..102032708b --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/de/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (de)" + }, + "extensionDescription": { + "message": "Wikipedia, die freie Enzyklopädie" + }, + "searchUrl": { + "message": "https://de.wikipedia.org/wiki/Spezial:Suche" + }, + "searchForm": { + "message": "https://de.wikipedia.org/wiki/Spezial:Suche" + }, + "suggestUrl": { + "message": "https://de.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/dsb/messages.json b/browser/components/search/extensions/wikipedia/_locales/dsb/messages.json new file mode 100644 index 0000000000..cc0ce903d0 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/dsb/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedija (dsb)" + }, + "extensionDescription": { + "message": "Wikipedija, lichotna encyklopedija" + }, + "searchUrl": { + "message": "https://dsb.wikipedia.org/wiki/Specialne:Pytaś" + }, + "searchForm": { + "message": "https://dsb.wikipedia.org/wiki/Specialne:Pytaś" + }, + "suggestUrl": { + "message": "https://dsb.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/el/messages.json b/browser/components/search/extensions/wikipedia/_locales/el/messages.json new file mode 100644 index 0000000000..5225a298d6 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/el/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (el)" + }, + "extensionDescription": { + "message": "Βικιπαίδεια, η ελεύθερη εγκυκλοπαίδεια" + }, + "searchUrl": { + "message": "https://el.wikipedia.org/wiki/Ειδικό:Αναζήτηση" + }, + "searchForm": { + "message": "https://el.wikipedia.org/wiki/Ειδικό:Αναζήτηση" + }, + "suggestUrl": { + "message": "https://el.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/en/messages.json b/browser/components/search/extensions/wikipedia/_locales/en/messages.json new file mode 100644 index 0000000000..f94458bb55 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/en/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (en)" + }, + "extensionDescription": { + "message": "Wikipedia, the Free Encyclopedia" + }, + "searchUrl": { + "message": "https://en.wikipedia.org/wiki/Special:Search" + }, + "searchForm": { + "message": "https://en.wikipedia.org/wiki/Special:Search" + }, + "suggestUrl": { + "message": "https://en.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/eo/messages.json b/browser/components/search/extensions/wikipedia/_locales/eo/messages.json new file mode 100644 index 0000000000..9ed9398408 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/eo/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Vikipedio (eo)" + }, + "extensionDescription": { + "message": "Vikipedio, la libera enciklopedio" + }, + "searchUrl": { + "message": "https://eo.wikipedia.org/wiki/Specialaĵo:Serĉi" + }, + "searchForm": { + "message": "https://eo.wikipedia.org/wiki/Specialaĵo:Serĉi" + }, + "suggestUrl": { + "message": "https://eo.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/es/messages.json b/browser/components/search/extensions/wikipedia/_locales/es/messages.json new file mode 100644 index 0000000000..ced826eb40 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/es/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (es)" + }, + "extensionDescription": { + "message": "Wikipedia, la enciclopedia libre" + }, + "searchUrl": { + "message": "https://es.wikipedia.org/wiki/Especial:Buscar" + }, + "searchForm": { + "message": "https://es.wikipedia.org/wiki/Especial:Buscar" + }, + "suggestUrl": { + "message": "https://es.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/et/messages.json b/browser/components/search/extensions/wikipedia/_locales/et/messages.json new file mode 100644 index 0000000000..16812519da --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/et/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Vikipeedia (et)" + }, + "extensionDescription": { + "message": "Vikipeedia, vaba entsüklopeedia" + }, + "searchUrl": { + "message": "https://et.wikipedia.org/wiki/Eri:Otsimine" + }, + "searchForm": { + "message": "https://et.wikipedia.org/wiki/Eri:Otsimine" + }, + "suggestUrl": { + "message": "https://et.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/eu/messages.json b/browser/components/search/extensions/wikipedia/_locales/eu/messages.json new file mode 100644 index 0000000000..f1adb3b383 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/eu/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (eu)" + }, + "extensionDescription": { + "message": "Wikipedia, entziklopedia askea" + }, + "searchUrl": { + "message": "https://eu.wikipedia.org/wiki/Berezi:Bilatu" + }, + "searchForm": { + "message": "https://eu.wikipedia.org/wiki/Berezi:Bilatu" + }, + "suggestUrl": { + "message": "https://eu.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/fa/messages.json b/browser/components/search/extensions/wikipedia/_locales/fa/messages.json new file mode 100644 index 0000000000..08f13c1f22 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/fa/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "ویکیپدیا (fa)" + }, + "extensionDescription": { + "message": "ویکیپدیا، دانشنامهٔ آزاد" + }, + "searchUrl": { + "message": "https://fa.wikipedia.org/wiki/ویژه:جستجو" + }, + "searchForm": { + "message": "https://fa.wikipedia.org/wiki/ویژه:جستجو" + }, + "suggestUrl": { + "message": "https://fa.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/fi/messages.json b/browser/components/search/extensions/wikipedia/_locales/fi/messages.json new file mode 100644 index 0000000000..2abb8282d3 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/fi/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (fi)" + }, + "extensionDescription": { + "message": "Wikipedia (fi), vapaa tietosanakirja" + }, + "searchUrl": { + "message": "https://fi.wikipedia.org/wiki/Toiminnot:Haku" + }, + "searchForm": { + "message": "https://fi.wikipedia.org/wiki/Toiminnot:Haku" + }, + "suggestUrl": { + "message": "https://fi.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/fr/messages.json b/browser/components/search/extensions/wikipedia/_locales/fr/messages.json new file mode 100644 index 0000000000..e1b4aeffb7 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/fr/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipédia (fr)" + }, + "extensionDescription": { + "message": "Wikipédia, l'encyclopédie libre" + }, + "searchUrl": { + "message": "https://fr.wikipedia.org/wiki/Spécial:Recherche" + }, + "searchForm": { + "message": "https://fr.wikipedia.org/wiki/Spécial:Recherche" + }, + "suggestUrl": { + "message": "https://fr.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/fy-NL/messages.json b/browser/components/search/extensions/wikipedia/_locales/fy-NL/messages.json new file mode 100644 index 0000000000..bfad9c2a6c --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/fy-NL/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedy (fy)" + }, + "extensionDescription": { + "message": "De fergese ensyklopedy" + }, + "searchUrl": { + "message": "https://fy.wikipedia.org/wiki/Wiki:Sykje" + }, + "searchForm": { + "message": "https://fy.wikipedia.org/wiki/Wiki:Sykje" + }, + "suggestUrl": { + "message": "https://fy.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ga-IE/messages.json b/browser/components/search/extensions/wikipedia/_locales/ga-IE/messages.json new file mode 100644 index 0000000000..ae350f7df6 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ga-IE/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Vicipéid (ga)" + }, + "extensionDescription": { + "message": "Vicipéid, an Chiclipéid Shaor" + }, + "searchUrl": { + "message": "https://ga.wikipedia.org/wiki/Speisialta:Search" + }, + "searchForm": { + "message": "https://ga.wikipedia.org/wiki/Speisialta:Search" + }, + "suggestUrl": { + "message": "https://ga.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/gd/messages.json b/browser/components/search/extensions/wikipedia/_locales/gd/messages.json new file mode 100644 index 0000000000..178b67c7b6 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/gd/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Uicipeid (gd)" + }, + "extensionDescription": { + "message": "Wikipedia, An leabhar mòr-eòlais" + }, + "searchUrl": { + "message": "https://gd.wikipedia.org/wiki/Sònraichte:Search" + }, + "searchForm": { + "message": "https://gd.wikipedia.org/wiki/Sònraichte:Search" + }, + "suggestUrl": { + "message": "https://gd.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/gl/messages.json b/browser/components/search/extensions/wikipedia/_locales/gl/messages.json new file mode 100644 index 0000000000..97309277a3 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/gl/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (gl)" + }, + "extensionDescription": { + "message": "Wikipedia, a enciclopedia libre" + }, + "searchUrl": { + "message": "https://gl.wikipedia.org/wiki/Especial:Procurar" + }, + "searchForm": { + "message": "https://gl.wikipedia.org/wiki/Especial:Procurar" + }, + "suggestUrl": { + "message": "https://gl.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/gn/messages.json b/browser/components/search/extensions/wikipedia/_locales/gn/messages.json new file mode 100644 index 0000000000..0628e96ac9 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/gn/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Vikipetã (gn)" + }, + "extensionDescription": { + "message": "Vikipetã, opaite tembikuaa hekosãsóva renda" + }, + "searchUrl": { + "message": "https://gn.wikipedia.org/wiki/Mba'echĩchĩ:Buscar" + }, + "searchForm": { + "message": "https://gn.wikipedia.org/wiki/Mba'echĩchĩ:Buscar" + }, + "suggestUrl": { + "message": "https://gn.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/gu/messages.json b/browser/components/search/extensions/wikipedia/_locales/gu/messages.json new file mode 100644 index 0000000000..b9dacaf138 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/gu/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "વિકિપીડિયા (gu)" + }, + "extensionDescription": { + "message": "વીકીપીડિયા, મુક્ત એનસાયક્લોપીડિયા" + }, + "searchUrl": { + "message": "https://gu.wikipedia.org/wiki/વિશેષ:શોધ" + }, + "searchForm": { + "message": "https://gu.wikipedia.org/wiki/વિશેષ:શોધ" + }, + "suggestUrl": { + "message": "https://gu.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/he/messages.json b/browser/components/search/extensions/wikipedia/_locales/he/messages.json new file mode 100644 index 0000000000..8189c73983 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/he/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "ויקיפדיה" + }, + "extensionDescription": { + "message": "ויקיפדיה" + }, + "searchUrl": { + "message": "https://he.wikipedia.org/wiki/מיוחד:חיפוש" + }, + "searchForm": { + "message": "https://he.wikipedia.org/wiki/מיוחד:חיפוש" + }, + "suggestUrl": { + "message": "https://he.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/hi/messages.json b/browser/components/search/extensions/wikipedia/_locales/hi/messages.json new file mode 100644 index 0000000000..5765c26de8 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/hi/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "विकिपीडिया (hi)" + }, + "extensionDescription": { + "message": "विकिपीडिया (हिन्दी)" + }, + "searchUrl": { + "message": "https://hi.wikipedia.org/wiki/विशेष:खोज" + }, + "searchForm": { + "message": "https://hi.wikipedia.org/wiki/विशेष:खोज" + }, + "suggestUrl": { + "message": "https://hi.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/hr/messages.json b/browser/components/search/extensions/wikipedia/_locales/hr/messages.json new file mode 100644 index 0000000000..e01349bdec --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/hr/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedija (hr)" + }, + "extensionDescription": { + "message": "Wikipedija, slobodna enciklopedija" + }, + "searchUrl": { + "message": "https://hr.wikipedia.org/wiki/Posebno:Traži" + }, + "searchForm": { + "message": "https://hr.wikipedia.org/wiki/Posebno:Traži" + }, + "suggestUrl": { + "message": "https://hr.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/hsb/messages.json b/browser/components/search/extensions/wikipedia/_locales/hsb/messages.json new file mode 100644 index 0000000000..ace410f1ca --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/hsb/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedija (hsb)" + }, + "extensionDescription": { + "message": "Wikipedija, swobodna encyklopedija" + }, + "searchUrl": { + "message": "https://hsb.wikipedia.org/wiki/Specialnje:Pytać" + }, + "searchForm": { + "message": "https://hsb.wikipedia.org/wiki/Specialnje:Pytać" + }, + "suggestUrl": { + "message": "https://hsb.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/hu/messages.json b/browser/components/search/extensions/wikipedia/_locales/hu/messages.json new file mode 100644 index 0000000000..c853c4b51b --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/hu/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipédia (hu)" + }, + "extensionDescription": { + "message": "Wikipedia, a szabad enciklopédia" + }, + "searchUrl": { + "message": "https://hu.wikipedia.org/wiki/Speciális:Keresés" + }, + "searchForm": { + "message": "https://hu.wikipedia.org/wiki/Speciális:Keresés" + }, + "suggestUrl": { + "message": "https://hu.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/hy/messages.json b/browser/components/search/extensions/wikipedia/_locales/hy/messages.json new file mode 100644 index 0000000000..093171ed00 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/hy/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (hy)" + }, + "extensionDescription": { + "message": "Վիքիփեդիա՝ ազատ հանրագիտարան" + }, + "searchUrl": { + "message": "https://hy.wikipedia.org/wiki/Սպասարկող:Որոնել" + }, + "searchForm": { + "message": "https://hy.wikipedia.org/wiki/Սպասարկող:Որոնել" + }, + "suggestUrl": { + "message": "https://hy.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ia/messages.json b/browser/components/search/extensions/wikipedia/_locales/ia/messages.json new file mode 100644 index 0000000000..b19d0f7fbb --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ia/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (ia)" + }, + "extensionDescription": { + "message": "Wikipedia, le encyclopedia libere" + }, + "searchUrl": { + "message": "https://ia.wikipedia.org/wiki/Special:Recerca" + }, + "searchForm": { + "message": "https://ia.wikipedia.org/wiki/Special:Recerca" + }, + "suggestUrl": { + "message": "https://ia.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/id/messages.json b/browser/components/search/extensions/wikipedia/_locales/id/messages.json new file mode 100644 index 0000000000..a88a925a9b --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/id/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (id)" + }, + "extensionDescription": { + "message": "Wikipedia, ensiklopedia bebas" + }, + "searchUrl": { + "message": "https://id.wikipedia.org/wiki/Istimewa:Pencarian" + }, + "searchForm": { + "message": "https://id.wikipedia.org/wiki/Istimewa:Pencarian" + }, + "suggestUrl": { + "message": "https://id.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/is/messages.json b/browser/components/search/extensions/wikipedia/_locales/is/messages.json new file mode 100644 index 0000000000..417539d457 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/is/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (is)" + }, + "extensionDescription": { + "message": "Wikipedia, the free encyclopedia" + }, + "searchUrl": { + "message": "https://is.wikipedia.org/wiki/Kerfissíða:Leit" + }, + "searchForm": { + "message": "https://is.wikipedia.org/wiki/Kerfissíða:Leit" + }, + "suggestUrl": { + "message": "https://is.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/it/messages.json b/browser/components/search/extensions/wikipedia/_locales/it/messages.json new file mode 100644 index 0000000000..cda10354cc --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/it/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (it)" + }, + "extensionDescription": { + "message": "Wikipedia, l'enciclopedia libera" + }, + "searchUrl": { + "message": "https://it.wikipedia.org/wiki/Speciale:Ricerca" + }, + "searchForm": { + "message": "https://it.wikipedia.org/wiki/Speciale:Ricerca" + }, + "suggestUrl": { + "message": "https://it.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ja/messages.json b/browser/components/search/extensions/wikipedia/_locales/ja/messages.json new file mode 100644 index 0000000000..ef16685a68 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ja/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (ja)" + }, + "extensionDescription": { + "message": "Wikipedia - フリー百科事典" + }, + "searchUrl": { + "message": "https://ja.wikipedia.org/wiki/特別:検索" + }, + "searchForm": { + "message": "https://ja.wikipedia.org/wiki/特別:検索" + }, + "suggestUrl": { + "message": "https://ja.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ka/messages.json b/browser/components/search/extensions/wikipedia/_locales/ka/messages.json new file mode 100644 index 0000000000..c23cdbf0a5 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ka/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "ვიკიპედია (ka)" + }, + "extensionDescription": { + "message": "ვიკიპედია, თავისუფალი ენციკლოპედია" + }, + "searchUrl": { + "message": "https://ka.wikipedia.org/wiki/სპეციალური:ძიება" + }, + "searchForm": { + "message": "https://ka.wikipedia.org/wiki/სპეციალური:ძიება" + }, + "suggestUrl": { + "message": "https://ka.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/kab/messages.json b/browser/components/search/extensions/wikipedia/_locales/kab/messages.json new file mode 100644 index 0000000000..e2a156ccd6 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/kab/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (kab)" + }, + "extensionDescription": { + "message": "Wikipedia, tasanayt tilellit" + }, + "searchUrl": { + "message": "https://kab.wikipedia.org/wiki/Uslig:Search" + }, + "searchForm": { + "message": "https://kab.wikipedia.org/wiki/Uslig:Search" + }, + "suggestUrl": { + "message": "https://kab.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/kk/messages.json b/browser/components/search/extensions/wikipedia/_locales/kk/messages.json new file mode 100644 index 0000000000..d2da12ff70 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/kk/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Уикипедия (kk)" + }, + "extensionDescription": { + "message": "Уикипедия (kk)" + }, + "searchUrl": { + "message": "https://kk.wikipedia.org/wiki/Арнайы:Іздеу" + }, + "searchForm": { + "message": "https://kk.wikipedia.org/wiki/Арнайы:Іздеу" + }, + "suggestUrl": { + "message": "https://kk.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/km/messages.json b/browser/components/search/extensions/wikipedia/_locales/km/messages.json new file mode 100644 index 0000000000..c8da6a1d2f --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/km/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "វីគីភីឌា (km)" + }, + "extensionDescription": { + "message": "វីគីភីឌា សព្វវចនាធិប្បាយសេរី" + }, + "searchUrl": { + "message": "https://km.wikipedia.org/wiki/ពិសេស:ស្វែងរក" + }, + "searchForm": { + "message": "https://km.wikipedia.org/wiki/ពិសេស:ស្វែងរក" + }, + "suggestUrl": { + "message": "https://km.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/kn/messages.json b/browser/components/search/extensions/wikipedia/_locales/kn/messages.json new file mode 100644 index 0000000000..8e5fc996b8 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/kn/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (kn)" + }, + "extensionDescription": { + "message": "Wikipedia, the free encyclopedia" + }, + "searchUrl": { + "message": "https://kn.wikipedia.org/wiki/ವಿಶೇಷ:Search" + }, + "searchForm": { + "message": "https://kn.wikipedia.org/wiki/ವಿಶೇಷ:Search" + }, + "suggestUrl": { + "message": "https://kn.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/kr/messages.json b/browser/components/search/extensions/wikipedia/_locales/kr/messages.json new file mode 100644 index 0000000000..6e2d4e99f3 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/kr/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "위키백과 (ko)" + }, + "extensionDescription": { + "message": "Wikipedia, the free encyclopedia" + }, + "searchUrl": { + "message": "https://ko.wikipedia.org/wiki/특수기능:찾기" + }, + "searchForm": { + "message": "https://ko.wikipedia.org/wiki/특수기능:찾기" + }, + "suggestUrl": { + "message": "https://ko.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/lij/messages.json b/browser/components/search/extensions/wikipedia/_locales/lij/messages.json new file mode 100644 index 0000000000..b856f7f2d5 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/lij/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (lij)" + }, + "extensionDescription": { + "message": "Wikipedia, l'enciclopedia libera" + }, + "searchUrl": { + "message": "https://lij.wikipedia.org/wiki/Speçiale:Riçerca" + }, + "searchForm": { + "message": "https://lij.wikipedia.org/wiki/Speçiale:Riçerca" + }, + "suggestUrl": { + "message": "https://lij.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/lo/messages.json b/browser/components/search/extensions/wikipedia/_locales/lo/messages.json new file mode 100644 index 0000000000..99341253cb --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/lo/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "ວິກິພີເດຍ (lo)" + }, + "extensionDescription": { + "message": "ວິກິພີເດຍ, ສາລານຸກົມເສລີ" + }, + "searchUrl": { + "message": "https://lo.wikipedia.org/wiki/ພິເສດ:ຊອກຫາ" + }, + "searchForm": { + "message": "https://lo.wikipedia.org/wiki/ພິເສດ:ຊອກຫາ" + }, + "suggestUrl": { + "message": "https://lo.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/lt/messages.json b/browser/components/search/extensions/wikipedia/_locales/lt/messages.json new file mode 100644 index 0000000000..27299e618d --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/lt/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (lt)" + }, + "extensionDescription": { + "message": "Vikipedija, laisvoji enciklopedija" + }, + "searchUrl": { + "message": "https://lt.wikipedia.org/wiki/Specialus:Paieška" + }, + "searchForm": { + "message": "https://lt.wikipedia.org/wiki/Specialus:Paieška" + }, + "suggestUrl": { + "message": "https://lt.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ltg/messages.json b/browser/components/search/extensions/wikipedia/_locales/ltg/messages.json new file mode 100644 index 0000000000..e4db21d0bb --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ltg/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Vikipedeja (ltg)" + }, + "extensionDescription": { + "message": "Vikipēdija, breivuo eņciklopedeja" + }, + "searchUrl": { + "message": "https://ltg.wikipedia.org/wiki/Seviškuo:Search" + }, + "searchForm": { + "message": "https://ltg.wikipedia.org/wiki/Seviškuo:Search" + }, + "suggestUrl": { + "message": "https://ltg.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/lv/messages.json b/browser/components/search/extensions/wikipedia/_locales/lv/messages.json new file mode 100644 index 0000000000..4ddd84ce0f --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/lv/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Vikipēdija" + }, + "extensionDescription": { + "message": "Vikipēdija, brīvā enciklopēdija" + }, + "searchUrl": { + "message": "https://lv.wikipedia.org/wiki/Special:Search" + }, + "searchForm": { + "message": "https://lv.wikipedia.org/wiki/Special:Search" + }, + "suggestUrl": { + "message": "https://lv.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/mk/messages.json b/browser/components/search/extensions/wikipedia/_locales/mk/messages.json new file mode 100644 index 0000000000..f894354767 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/mk/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Википедија (mk)" + }, + "extensionDescription": { + "message": "Википедија, слободната енциклопедија" + }, + "searchUrl": { + "message": "https://mk.wikipedia.org/wiki/Специјална:Барај" + }, + "searchForm": { + "message": "https://mk.wikipedia.org/wiki/Специјална:Барај" + }, + "suggestUrl": { + "message": "https://mk.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/mr/messages.json b/browser/components/search/extensions/wikipedia/_locales/mr/messages.json new file mode 100644 index 0000000000..b41e92218d --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/mr/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "विकिपीडिया (mr)" + }, + "extensionDescription": { + "message": "विकिपीडिया, मोफत माहितीकोष" + }, + "searchUrl": { + "message": "https://mr.wikipedia.org/wiki/विशेष:शोधा" + }, + "searchForm": { + "message": "https://mr.wikipedia.org/wiki/विशेष:शोधा" + }, + "suggestUrl": { + "message": "https://mr.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ms/messages.json b/browser/components/search/extensions/wikipedia/_locales/ms/messages.json new file mode 100644 index 0000000000..e1a0b3bab8 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ms/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (ms)" + }, + "extensionDescription": { + "message": "Wikipedia, ensiklopedia bebas" + }, + "searchUrl": { + "message": "https://ms.wikipedia.org/wiki/Khas:Gelintar" + }, + "searchForm": { + "message": "https://ms.wikipedia.org/wiki/Khas:Gelintar" + }, + "suggestUrl": { + "message": "https://ms.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/my/messages.json b/browser/components/search/extensions/wikipedia/_locales/my/messages.json new file mode 100644 index 0000000000..e856786d33 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/my/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (my)" + }, + "extensionDescription": { + "message": "အခမဲ့လွတ်လပ်စွယ်စုံကျမ်း" + }, + "searchUrl": { + "message": "https://my.wikipedia.org/wiki/Special:Search" + }, + "searchForm": { + "message": "https://my.wikipedia.org/wiki/Special:Search" + }, + "suggestUrl": { + "message": "https://my.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ne/messages.json b/browser/components/search/extensions/wikipedia/_locales/ne/messages.json new file mode 100644 index 0000000000..96458e5507 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ne/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "विकिपीडिया (ne)" + }, + "extensionDescription": { + "message": "विकिपिडिया एक स्वतन्त्र विश्वकोष" + }, + "searchUrl": { + "message": "https://ne.wikipedia.org/wiki/विशेष:Search" + }, + "searchForm": { + "message": "https://ne.wikipedia.org/wiki/विशेष:Search" + }, + "suggestUrl": { + "message": "https://ne.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/nl/messages.json b/browser/components/search/extensions/wikipedia/_locales/nl/messages.json new file mode 100644 index 0000000000..9e61b67aab --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/nl/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (nl)" + }, + "extensionDescription": { + "message": "De vrije encyclopedie" + }, + "searchUrl": { + "message": "https://nl.wikipedia.org/wiki/Speciaal:Zoeken" + }, + "searchForm": { + "message": "https://nl.wikipedia.org/wiki/Speciaal:Zoeken" + }, + "suggestUrl": { + "message": "https://nl.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/oc/messages.json b/browser/components/search/extensions/wikipedia/_locales/oc/messages.json new file mode 100644 index 0000000000..186438f33d --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/oc/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipèdia (oc)" + }, + "extensionDescription": { + "message": "Wikipèdia, l'enciclopèdia liura" + }, + "searchUrl": { + "message": "https://oc.wikipedia.org/wiki/Especial:Recèrca" + }, + "searchForm": { + "message": "https://oc.wikipedia.org/wiki/Especial:Recèrca" + }, + "suggestUrl": { + "message": "https://oc.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/pa/messages.json b/browser/components/search/extensions/wikipedia/_locales/pa/messages.json new file mode 100644 index 0000000000..4951bc3360 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/pa/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (pa)" + }, + "extensionDescription": { + "message": "ਵਿਕਿਪੀਡਿਆ, ਮੁਫ਼ਤ/ਮੁਕਤ ਸ਼ਬਦਕੋਸ਼" + }, + "searchUrl": { + "message": "https://pa.wikipedia.org/wiki/ਖ਼ਾਸ:ਖੋਜੋ" + }, + "searchForm": { + "message": "https://pa.wikipedia.org/wiki/ਖ਼ਾਸ:ਖੋਜੋ" + }, + "suggestUrl": { + "message": "https://pa.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/pl/messages.json b/browser/components/search/extensions/wikipedia/_locales/pl/messages.json new file mode 100644 index 0000000000..df3ace08e5 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/pl/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (pl)" + }, + "extensionDescription": { + "message": "Wikipedia, wolna encyklopedia" + }, + "searchUrl": { + "message": "https://pl.wikipedia.org/wiki/Specjalna:Szukaj" + }, + "searchForm": { + "message": "https://pl.wikipedia.org/wiki/Specjalna:Szukaj" + }, + "suggestUrl": { + "message": "https://pl.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/pt/messages.json b/browser/components/search/extensions/wikipedia/_locales/pt/messages.json new file mode 100644 index 0000000000..55eb5d6620 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/pt/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (pt)" + }, + "extensionDescription": { + "message": "Wikipédia, a enciclopédia livre" + }, + "searchUrl": { + "message": "https://pt.wikipedia.org/wiki/Especial:Pesquisar" + }, + "searchForm": { + "message": "https://pt.wikipedia.org/wiki/Especial:Pesquisar" + }, + "suggestUrl": { + "message": "https://pt.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/rm/messages.json b/browser/components/search/extensions/wikipedia/_locales/rm/messages.json new file mode 100644 index 0000000000..6a49d16dec --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/rm/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (rm)" + }, + "extensionDescription": { + "message": "Vichipedia, l'enciclopedia libra" + }, + "searchUrl": { + "message": "https://rm.wikipedia.org/wiki/Spezial:Search" + }, + "searchForm": { + "message": "https://rm.wikipedia.org/wiki/Spezial:Search" + }, + "suggestUrl": { + "message": "https://rm.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ro/messages.json b/browser/components/search/extensions/wikipedia/_locales/ro/messages.json new file mode 100644 index 0000000000..f34a57f46a --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ro/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (ro)" + }, + "extensionDescription": { + "message": "Wikipedia, enciclopedia liberă" + }, + "searchUrl": { + "message": "https://ro.wikipedia.org/wiki/Special:Căutare" + }, + "searchForm": { + "message": "https://ro.wikipedia.org/wiki/Special:Căutare" + }, + "suggestUrl": { + "message": "https://ro.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ru/messages.json b/browser/components/search/extensions/wikipedia/_locales/ru/messages.json new file mode 100644 index 0000000000..295df0d802 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ru/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Википедия (ru)" + }, + "extensionDescription": { + "message": "Википедия, свободная энциклопедия" + }, + "searchUrl": { + "message": "https://ru.wikipedia.org/wiki/Служебная:Поиск" + }, + "searchForm": { + "message": "https://ru.wikipedia.org/wiki/Служебная:Поиск" + }, + "suggestUrl": { + "message": "https://ru.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/si/messages.json b/browser/components/search/extensions/wikipedia/_locales/si/messages.json new file mode 100644 index 0000000000..73bd4b55a7 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/si/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (si)" + }, + "extensionDescription": { + "message": "Wikipedia, the free encyclopedia" + }, + "searchUrl": { + "message": "https://si.wikipedia.org/wiki/විශේෂ:ගවේෂණය" + }, + "searchForm": { + "message": "https://si.wikipedia.org/wiki/විශේෂ:ගවේෂණය" + }, + "suggestUrl": { + "message": "https://si.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/sk/messages.json b/browser/components/search/extensions/wikipedia/_locales/sk/messages.json new file mode 100644 index 0000000000..287d586a2b --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/sk/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipédia (sk)" + }, + "extensionDescription": { + "message": "Wikipédia, slobodná a otvorená encyklopédia" + }, + "searchUrl": { + "message": "https://sk.wikipedia.org/wiki/Špeciálne:Hľadanie" + }, + "searchForm": { + "message": "https://sk.wikipedia.org/wiki/Špeciálne:Hľadanie" + }, + "suggestUrl": { + "message": "https://sk.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/sl/messages.json b/browser/components/search/extensions/wikipedia/_locales/sl/messages.json new file mode 100644 index 0000000000..ac3d13264e --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/sl/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedija (sl)" + }, + "extensionDescription": { + "message": "Wikipedija, prosta enciklopedija" + }, + "searchUrl": { + "message": "https://sl.wikipedia.org/wiki/Posebno:Iskanje" + }, + "searchForm": { + "message": "https://sl.wikipedia.org/wiki/Posebno:Iskanje" + }, + "suggestUrl": { + "message": "https://sl.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/sq/messages.json b/browser/components/search/extensions/wikipedia/_locales/sq/messages.json new file mode 100644 index 0000000000..c7b1a581e7 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/sq/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (sq)" + }, + "extensionDescription": { + "message": "Wikipedia, enciklopedia e lirë" + }, + "searchUrl": { + "message": "https://sq.wikipedia.org/wiki/Speciale:Kërkim" + }, + "searchForm": { + "message": "https://sq.wikipedia.org/wiki/Speciale:Kërkim" + }, + "suggestUrl": { + "message": "https://sq.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/sr/messages.json b/browser/components/search/extensions/wikipedia/_locales/sr/messages.json new file mode 100644 index 0000000000..c457dcb9b0 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/sr/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Википедија (sr)" + }, + "extensionDescription": { + "message": "Претрага Википедије на српском језику" + }, + "searchUrl": { + "message": "https://sr.wikipedia.org/wiki/Посебно:Претражи" + }, + "searchForm": { + "message": "https://sr.wikipedia.org/wiki/Посебно:Претражи" + }, + "suggestUrl": { + "message": "https://sr.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/sv-SE/messages.json b/browser/components/search/extensions/wikipedia/_locales/sv-SE/messages.json new file mode 100644 index 0000000000..bcb18cf169 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/sv-SE/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (sv)" + }, + "extensionDescription": { + "message": "Wikipedia, den fria encyklopedin" + }, + "searchUrl": { + "message": "https://sv.wikipedia.org/wiki/Special:Sök" + }, + "searchForm": { + "message": "https://sv.wikipedia.org/wiki/Special:Sök" + }, + "suggestUrl": { + "message": "https://sv.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ta/messages.json b/browser/components/search/extensions/wikipedia/_locales/ta/messages.json new file mode 100644 index 0000000000..19bd1ccc9a --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ta/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "விக்கிப்பீடியா (ta)" + }, + "extensionDescription": { + "message": "விக்கிப்பீடியா (ta)" + }, + "searchUrl": { + "message": "https://ta.wikipedia.org/wiki/சிறப்பு:Search" + }, + "searchForm": { + "message": "https://ta.wikipedia.org/wiki/சிறப்பு:Search" + }, + "suggestUrl": { + "message": "https://ta.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/te/messages.json b/browser/components/search/extensions/wikipedia/_locales/te/messages.json new file mode 100644 index 0000000000..3fa0618eb8 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/te/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "వికీపీడియా (te)" + }, + "extensionDescription": { + "message": "వికీపీడియా (te)" + }, + "searchUrl": { + "message": "https://te.wikipedia.org/wiki/ప్రత్యేక:అన్వేషణ" + }, + "searchForm": { + "message": "https://te.wikipedia.org/wiki/ప్రత్యేక:అన్వేషణ" + }, + "suggestUrl": { + "message": "https://te.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/th/messages.json b/browser/components/search/extensions/wikipedia/_locales/th/messages.json new file mode 100644 index 0000000000..10f47248ba --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/th/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "วิกิพีเดีย" + }, + "extensionDescription": { + "message": "วิกิพีเดีย สารานุกรมเสรี" + }, + "searchUrl": { + "message": "https://th.wikipedia.org/wiki/พิเศษ:ค้นหา" + }, + "searchForm": { + "message": "https://th.wikipedia.org/wiki/พิเศษ:ค้นหา" + }, + "suggestUrl": { + "message": "https://th.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/tl/messages.json b/browser/components/search/extensions/wikipedia/_locales/tl/messages.json new file mode 100644 index 0000000000..05246341e9 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/tl/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (tl)" + }, + "extensionDescription": { + "message": "Wikipedia, ang malayang ensiklopedya" + }, + "searchUrl": { + "message": "https://tl.wikipedia.org/wiki/Natatangi:Maghanap" + }, + "searchForm": { + "message": "https://tl.wikipedia.org/wiki/Natatangi:Maghanap" + }, + "suggestUrl": { + "message": "https://tl.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/tr/messages.json b/browser/components/search/extensions/wikipedia/_locales/tr/messages.json new file mode 100644 index 0000000000..87d696f076 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/tr/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (tr)" + }, + "extensionDescription": { + "message": "Vikipedi, özgür ansiklopedi" + }, + "searchUrl": { + "message": "https://tr.wikipedia.org/wiki/Özel:Ara" + }, + "searchForm": { + "message": "https://tr.wikipedia.org/wiki/Özel:Ara" + }, + "suggestUrl": { + "message": "https://tr.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/uk/messages.json b/browser/components/search/extensions/wikipedia/_locales/uk/messages.json new file mode 100644 index 0000000000..842883e899 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/uk/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Вікіпедія (uk)" + }, + "extensionDescription": { + "message": "Вікіпедія, вільна енциклопедія" + }, + "searchUrl": { + "message": "https://uk.wikipedia.org/wiki/Спеціальна:Пошук" + }, + "searchForm": { + "message": "https://uk.wikipedia.org/wiki/Спеціальна:Пошук" + }, + "suggestUrl": { + "message": "https://uk.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/ur/messages.json b/browser/components/search/extensions/wikipedia/_locales/ur/messages.json new file mode 100644 index 0000000000..fe616805bf --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/ur/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "ویکیپیڈیا (ur)" + }, + "extensionDescription": { + "message": "ویکیپیڈیا آزاد دائرۃ المعارف" + }, + "searchUrl": { + "message": "https://ur.wikipedia.org/wiki/خاص:تلاش" + }, + "searchForm": { + "message": "https://ur.wikipedia.org/wiki/خاص:تلاش" + }, + "suggestUrl": { + "message": "https://ur.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/uz/messages.json b/browser/components/search/extensions/wikipedia/_locales/uz/messages.json new file mode 100644 index 0000000000..2be111e5f8 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/uz/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Vikipediya (uz)" + }, + "extensionDescription": { + "message": "Vikipediya, ochiq ensiklopediya" + }, + "searchUrl": { + "message": "https://uz.wikipedia.org/wiki/Maxsus:Search" + }, + "searchForm": { + "message": "https://uz.wikipedia.org/wiki/Maxsus:Search" + }, + "suggestUrl": { + "message": "https://uz.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/vi/messages.json b/browser/components/search/extensions/wikipedia/_locales/vi/messages.json new file mode 100644 index 0000000000..bc037299e6 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/vi/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (vi)" + }, + "extensionDescription": { + "message": "Wikipedia, bách khoa toàn thư mở" + }, + "searchUrl": { + "message": "https://vi.wikipedia.org/wiki/Đặc_biệt:Tìm_kiếm" + }, + "searchForm": { + "message": "https://vi.wikipedia.org/wiki/Đặc_biệt:Tìm_kiếm" + }, + "suggestUrl": { + "message": "https://vi.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/wo/messages.json b/browser/components/search/extensions/wikipedia/_locales/wo/messages.json new file mode 100644 index 0000000000..285764da13 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/wo/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (wo)" + }, + "extensionDescription": { + "message": "Wikipedia, Jimbulang bu Ubbeeku bi" + }, + "searchUrl": { + "message": "https://wo.wikipedia.org/wiki/Jagleel:Ceet" + }, + "searchForm": { + "message": "https://wo.wikipedia.org/wiki/Jagleel:Ceet" + }, + "suggestUrl": { + "message": "https://wo.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/zh-CN/messages.json b/browser/components/search/extensions/wikipedia/_locales/zh-CN/messages.json new file mode 100644 index 0000000000..5d5cd1be73 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/zh-CN/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "维基百科" + }, + "extensionDescription": { + "message": "维基百科，自由的百科全书" + }, + "searchUrl": { + "message": "https://zh.wikipedia.org/wiki/Special:搜索" + }, + "searchForm": { + "message": "https://zh.wikipedia.org/wiki/Special:搜索" + }, + "suggestUrl": { + "message": "https://zh.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search" + } +} diff --git a/browser/components/search/extensions/wikipedia/_locales/zh-TW/messages.json b/browser/components/search/extensions/wikipedia/_locales/zh-TW/messages.json new file mode 100644 index 0000000000..401d14b619 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/_locales/zh-TW/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikipedia (zh)" + }, + "extensionDescription": { + "message": "維基百科，自由的百科全書" + }, + "searchUrl": { + "message": "https://zh.wikipedia.org/wiki/Special:搜索" + }, + "searchForm": { + "message": "https://zh.wikipedia.org/wiki/Special:搜索?variant=zh-tw" + }, + "suggestUrl": { + "message": "https://zh.wikipedia.org/w/api.php?action=opensearch&search={searchTerms}" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}&sourceid=Mozilla-search&variant=zh-tw" + } +} diff --git a/browser/components/search/extensions/wikipedia/favicon.ico b/browser/components/search/extensions/wikipedia/favicon.ico Binary files differnew file mode 100644 index 0000000000..4314071e24 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/favicon.ico diff --git a/browser/components/search/extensions/wikipedia/manifest.json b/browser/components/search/extensions/wikipedia/manifest.json new file mode 100644 index 0000000000..696d98fa60 --- /dev/null +++ b/browser/components/search/extensions/wikipedia/manifest.json @@ -0,0 +1,27 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionDescription__", + "manifest_version": 2, + "version": "1.3", + "browser_specific_settings": { + "gecko": { + "id": "wikipedia@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "en", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": "@wikipedia", + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "search_form": "__MSG_searchForm__", + "suggest_url": "__MSG_suggestUrl__", + "search_url_get_params": "__MSG_searchUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/wiktionary/_locales/oc/messages.json b/browser/components/search/extensions/wiktionary/_locales/oc/messages.json new file mode 100644 index 0000000000..58367bf130 --- /dev/null +++ b/browser/components/search/extensions/wiktionary/_locales/oc/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "Wikiccionari (oc)" + }, + "extensionDescription": { + "message": "Wikiccionari, lo diccionari liure" + }, + "searchUrl": { + "message": "https://oc.wiktionary.org/wiki/Especial:Recèrca" + }, + "searchForm": { + "message": "https://oc.wiktionary.org/wiki/Especial:Recèrca" + }, + "suggestUrl": { + "message": "https://oc.wiktionary.org/w/api.php?action=opensearch&search={searchTerms}&namespace=0" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}" + } +} diff --git a/browser/components/search/extensions/wiktionary/_locales/te/messages.json b/browser/components/search/extensions/wiktionary/_locales/te/messages.json new file mode 100644 index 0000000000..19201032ff --- /dev/null +++ b/browser/components/search/extensions/wiktionary/_locales/te/messages.json @@ -0,0 +1,20 @@ +{ + "extensionName": { + "message": "విక్షనరీ (te)" + }, + "extensionDescription": { + "message": "విక్షనరీ (te)" + }, + "searchUrl": { + "message": "https://te.wiktionary.org/wiki/ప్రత్యేక:అన్వేషణ" + }, + "searchForm": { + "message": "https://te.wiktionary.org/wiki/ప్రత్యేక:అన్వేషణ" + }, + "suggestUrl": { + "message": "https://te.wiktionary.org/w/api.php?action=opensearch&search={searchTerms}&namespace=0" + }, + "searchUrlGetParams": { + "message": "search={searchTerms}" + } +} diff --git a/browser/components/search/extensions/wiktionary/favicon.ico b/browser/components/search/extensions/wiktionary/favicon.ico Binary files differnew file mode 100644 index 0000000000..31b0e38092 --- /dev/null +++ b/browser/components/search/extensions/wiktionary/favicon.ico diff --git a/browser/components/search/extensions/wiktionary/manifest.json b/browser/components/search/extensions/wiktionary/manifest.json new file mode 100644 index 0000000000..5301fdd1cc --- /dev/null +++ b/browser/components/search/extensions/wiktionary/manifest.json @@ -0,0 +1,26 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionDescription__", + "manifest_version": 2, + "version": "1.2", + "browser_specific_settings": { + "gecko": { + "id": "wiktionary@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "oc", + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "search_form": "__MSG_searchForm__", + "suggest_url": "__MSG_suggestUrl__", + "search_url_get_params": "__MSG_searchUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/wolnelektury-pl/favicon.png b/browser/components/search/extensions/wolnelektury-pl/favicon.png Binary files differnew file mode 100644 index 0000000000..77f6db5322 --- /dev/null +++ b/browser/components/search/extensions/wolnelektury-pl/favicon.png diff --git a/browser/components/search/extensions/wolnelektury-pl/manifest.json b/browser/components/search/extensions/wolnelektury-pl/manifest.json new file mode 100644 index 0000000000..3599d9e82d --- /dev/null +++ b/browser/components/search/extensions/wolnelektury-pl/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Wolne Lektury", + "description": "Biblioteka internetowa WolneLektury.pl", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "wolnelektury-pl@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.png" + }, + "web_accessible_resources": ["favicon.png"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Wolne Lektury", + "search_url": "https://wolnelektury.pl/szukaj/?q={searchTerms}", + "search_form": "https://wolnelektury.pl", + "suggest_url": "https://wolnelektury.pl/katalog/jtags/?mozhint=1&q={searchTerms}" + } + } +} diff --git a/browser/components/search/extensions/yahoo-jp-auctions/favicon.ico b/browser/components/search/extensions/yahoo-jp-auctions/favicon.ico Binary files differnew file mode 100644 index 0000000000..4401c7a40e --- /dev/null +++ b/browser/components/search/extensions/yahoo-jp-auctions/favicon.ico diff --git a/browser/components/search/extensions/yahoo-jp-auctions/manifest.json b/browser/components/search/extensions/yahoo-jp-auctions/manifest.json new file mode 100644 index 0000000000..ea1a02f4ef --- /dev/null +++ b/browser/components/search/extensions/yahoo-jp-auctions/manifest.json @@ -0,0 +1,25 @@ +{ + "name": "Yahoo!オークション", + "description": "ヤフオク! 検索", + "manifest_version": 2, + "version": "1.5", + "browser_specific_settings": { + "gecko": { + "id": "yahoo-jp-auctions@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Yahoo!オークション", + "encoding": "EUC-JP", + "search_url": "https://auctions.yahoo.co.jp/search/search", + "search_form": "https://auctions.yahoo.co.jp/", + "search_url_get_params": "p={searchTerms}&ei=EUC-JP&fr=mozff" + } + } +} diff --git a/browser/components/search/extensions/yahoo-jp/favicon.ico b/browser/components/search/extensions/yahoo-jp/favicon.ico Binary files differnew file mode 100644 index 0000000000..34a916ccde --- /dev/null +++ b/browser/components/search/extensions/yahoo-jp/favicon.ico diff --git a/browser/components/search/extensions/yahoo-jp/manifest.json b/browser/components/search/extensions/yahoo-jp/manifest.json new file mode 100644 index 0000000000..149c082af5 --- /dev/null +++ b/browser/components/search/extensions/yahoo-jp/manifest.json @@ -0,0 +1,24 @@ +{ + "name": "Yahoo! JAPAN", + "description": "Yahoo Search", + "manifest_version": 2, + "version": "1.1", + "browser_specific_settings": { + "gecko": { + "id": "yahoo-jp@search.mozilla.org" + } + }, + "hidden": true, + "icons": { + "16": "favicon.ico" + }, + "web_accessible_resources": ["favicon.ico"], + "chrome_settings_overrides": { + "search_provider": { + "name": "Yahoo! JAPAN", + "search_url": "https://search.yahoo.co.jp/search", + "search_form": "https://search.yahoo.co.jp/", + "search_url_get_params": "p={searchTerms}&ei=UTF-8&fr=mozff" + } + } +} diff --git a/browser/components/search/extensions/yandex/_locales/az/messages.json b/browser/components/search/extensions/yandex/_locales/az/messages.json new file mode 100644 index 0000000000..d57aca3bb5 --- /dev/null +++ b/browser/components/search/extensions/yandex/_locales/az/messages.json @@ -0,0 +1,38 @@ +{ + "extensionName": { + "message": "Yandex" + }, + "extensionDescription": { + "message": "İnternetdə axtarış üçün Yandexdən istifadə edin." + }, + "searchUrl": { + "message": "https://yandex.az/search" + }, + "searchForm": { + "message": "https://www.yandex.az/" + }, + "suggestUrl": { + "message": "https://yandex.az/suggest/suggest-ff.cgi?part={searchTerms}" + }, + "searchUrlGetParams": { + "message": "text={searchTerms}" + }, + "param_searchbar": { + "message": "2186618" + }, + "param_keyword": { + "message": "2186621" + }, + "param_contextmenu": { + "message": "2186623" + }, + "param_homepage": { + "message": "2186617" + }, + "param_newtab": { + "message": "2186620" + }, + "extensionIcon": { + "message": "yandex-ru.ico" + } +} diff --git a/browser/components/search/extensions/yandex/_locales/by/messages.json b/browser/components/search/extensions/yandex/_locales/by/messages.json new file mode 100644 index 0000000000..0bcb41945e --- /dev/null +++ b/browser/components/search/extensions/yandex/_locales/by/messages.json @@ -0,0 +1,38 @@ +{ + "extensionName": { + "message": "Яндекс" + }, + "extensionDescription": { + "message": "Пошук з дапамогаю Яндекс" + }, + "searchUrl": { + "message": "https://yandex.by/search" + }, + "searchForm": { + "message": "https://www.yandex.by/" + }, + "suggestUrl": { + "message": "https://suggest.yandex.by/suggest-ff.cgi?part={searchTerms}" + }, + "searchUrlGetParams": { + "message": "text={searchTerms}" + }, + "param_searchbar": { + "message": "2186618" + }, + "param_keyword": { + "message": "2186621" + }, + "param_contextmenu": { + "message": "2186623" + }, + "param_homepage": { + "message": "2186617" + }, + "param_newtab": { + "message": "2186620" + }, + "extensionIcon": { + "message": "yandex-ru.ico" + } +} diff --git a/browser/components/search/extensions/yandex/_locales/en/messages.json b/browser/components/search/extensions/yandex/_locales/en/messages.json new file mode 100644 index 0000000000..ee7f914640 --- /dev/null +++ b/browser/components/search/extensions/yandex/_locales/en/messages.json @@ -0,0 +1,38 @@ +{ + "extensionName": { + "message": "Yandex" + }, + "extensionDescription": { + "message": "Use Yandex to search the Internet." + }, + "searchUrl": { + "message": "https://www.yandex.com/search" + }, + "searchForm": { + "message": "https://www.yandex.com/" + }, + "suggestUrl": { + "message": "https://suggest.yandex.com/suggest-ff.cgi?part={searchTerms}" + }, + "searchUrlGetParams": { + "message": "text={searchTerms}" + }, + "param_searchbar": { + "message": "2186618" + }, + "param_keyword": { + "message": "2186621" + }, + "param_contextmenu": { + "message": "2186623" + }, + "param_homepage": { + "message": "2186617" + }, + "param_newtab": { + "message": "2186620" + }, + "extensionIcon": { + "message": "yandex-en.ico" + } +} diff --git a/browser/components/search/extensions/yandex/_locales/kk/messages.json b/browser/components/search/extensions/yandex/_locales/kk/messages.json new file mode 100644 index 0000000000..c1e924d987 --- /dev/null +++ b/browser/components/search/extensions/yandex/_locales/kk/messages.json @@ -0,0 +1,38 @@ +{ + "extensionName": { + "message": "Яндекс" + }, + "extensionDescription": { + "message": "Воспользуйтесь Яндексом для поиска в Интернете." + }, + "searchUrl": { + "message": "https://yandex.kz/search" + }, + "searchForm": { + "message": "https://www.yandex.kz/" + }, + "suggestUrl": { + "message": "https://suggest.yandex.kz/suggest-ff.cgi?part={searchTerms}" + }, + "searchUrlGetParams": { + "message": "text={searchTerms}" + }, + "param_searchbar": { + "message": "2186618" + }, + "param_keyword": { + "message": "2186621" + }, + "param_contextmenu": { + "message": "2186623" + }, + "param_homepage": { + "message": "2186617" + }, + "param_newtab": { + "message": "2186620" + }, + "extensionIcon": { + "message": "yandex-ru.ico" + } +} diff --git a/browser/components/search/extensions/yandex/_locales/ru/messages.json b/browser/components/search/extensions/yandex/_locales/ru/messages.json new file mode 100644 index 0000000000..072370fd00 --- /dev/null +++ b/browser/components/search/extensions/yandex/_locales/ru/messages.json @@ -0,0 +1,38 @@ +{ + "extensionName": { + "message": "Яндекс" + }, + "extensionDescription": { + "message": "Воспользуйтесь Яндексом для поиска в Интернете." + }, + "searchUrl": { + "message": "https://yandex.ru/search" + }, + "searchForm": { + "message": "https://www.yandex.ru/" + }, + "suggestUrl": { + "message": "https://suggest.yandex.ru/suggest-ff.cgi?part={searchTerms}" + }, + "searchUrlGetParams": { + "message": "text={searchTerms}" + }, + "param_searchbar": { + "message": "2186618" + }, + "param_keyword": { + "message": "2186621" + }, + "param_contextmenu": { + "message": "2186623" + }, + "param_homepage": { + "message": "2186617" + }, + "param_newtab": { + "message": "2186620" + }, + "extensionIcon": { + "message": "yandex-ru.ico" + } +} diff --git a/browser/components/search/extensions/yandex/_locales/tr/messages.json b/browser/components/search/extensions/yandex/_locales/tr/messages.json new file mode 100644 index 0000000000..35b4a44bae --- /dev/null +++ b/browser/components/search/extensions/yandex/_locales/tr/messages.json @@ -0,0 +1,38 @@ +{ + "extensionName": { + "message": "Yandex" + }, + "extensionDescription": { + "message": "Yandex Türkiye arama motoru" + }, + "searchUrl": { + "message": "https://yandex.com.tr/search" + }, + "searchForm": { + "message": "https://www.yandex.com.tr/" + }, + "suggestUrl": { + "message": "https://suggest.yandex.com.tr/suggest-ff.cgi?part={searchTerms}" + }, + "searchUrlGetParams": { + "message": "text={searchTerms}" + }, + "param_searchbar": { + "message": "2186618" + }, + "param_keyword": { + "message": "2186621" + }, + "param_contextmenu": { + "message": "2186623" + }, + "param_homepage": { + "message": "2186617" + }, + "param_newtab": { + "message": "2186620" + }, + "extensionIcon": { + "message": "yandex-en.ico" + } +} diff --git a/browser/components/search/extensions/yandex/_locales/ua/messages.json b/browser/components/search/extensions/yandex/_locales/ua/messages.json new file mode 100644 index 0000000000..6d7efc2848 --- /dev/null +++ b/browser/components/search/extensions/yandex/_locales/ua/messages.json @@ -0,0 +1,23 @@ +{ + "extensionName": { + "message": "Яндекс" + }, + "extensionDescription": { + "message": "Воспользуйтесь Яндексом для поиска в Интернете." + }, + "searchUrl": { + "message": "https://yandex.ua/yandsearch" + }, + "searchForm": { + "message": "https://www.yandex.ua/" + }, + "suggestUrl": { + "message": "https://suggest.yandex.ua/suggest-ff.cgi?part={searchTerms}" + }, + "searchUrlGetParams": { + "message": "text={searchTerms}" + }, + "extensionIcon": { + "message": "yandex-ru.ico" + } +} diff --git a/browser/components/search/extensions/yandex/manifest.json b/browser/components/search/extensions/yandex/manifest.json new file mode 100644 index 0000000000..0d609a9019 --- /dev/null +++ b/browser/components/search/extensions/yandex/manifest.json @@ -0,0 +1,59 @@ +{ + "name": "__MSG_extensionName__", + "description": "__MSG_extensionDescription__", + "manifest_version": 2, + "version": "1.3", + "browser_specific_settings": { + "gecko": { + "id": "yandex@search.mozilla.org" + } + }, + "hidden": true, + "default_locale": "en", + "icons": { + "16": "__MSG_extensionIcon__" + }, + "web_accessible_resources": ["yandex-en.ico", "yandex-ru.ico"], + "chrome_settings_overrides": { + "search_provider": { + "keyword": ["@\u044F\u043D\u0434\u0435\u043A\u0441", "@yandex"], + "name": "__MSG_extensionName__", + "search_url": "__MSG_searchUrl__", + "search_form": "__MSG_searchForm__", + "suggest_url": "__MSG_suggestUrl__", + "params": [ + { + "name": "clid", + "condition": "purpose", + "purpose": "searchbar", + "value": "__MSG_param_searchbar__" + }, + { + "name": "clid", + "condition": "purpose", + "purpose": "keyword", + "value": "__MSG_param_keyword__" + }, + { + "name": "clid", + "condition": "purpose", + "purpose": "contextmenu", + "value": "__MSG_param_contextmenu__" + }, + { + "name": "clid", + "condition": "purpose", + "purpose": "homepage", + "value": "__MSG_param_homepage__" + }, + { + "name": "clid", + "condition": "purpose", + "purpose": "newtab", + "value": "__MSG_param_newtab__" + } + ], + "search_url_get_params": "__MSG_searchUrlGetParams__" + } + } +} diff --git a/browser/components/search/extensions/yandex/yandex-en.ico b/browser/components/search/extensions/yandex/yandex-en.ico Binary files differnew file mode 100644 index 0000000000..d1c3f3f8b1 --- /dev/null +++ b/browser/components/search/extensions/yandex/yandex-en.ico diff --git a/browser/components/search/extensions/yandex/yandex-ru.ico b/browser/components/search/extensions/yandex/yandex-ru.ico Binary files differnew file mode 100644 index 0000000000..eb187398c7 --- /dev/null +++ b/browser/components/search/extensions/yandex/yandex-ru.ico diff --git a/browser/components/search/jar.mn b/browser/components/search/jar.mn new file mode 100644 index 0000000000..a9617478d2 --- /dev/null +++ b/browser/components/search/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/. + +browser.jar: + content/browser/search/autocomplete-popup.js (content/autocomplete-popup.js) + content/browser/search/searchbar.js (content/searchbar.js) + content/browser/contentSearchUI.js (content/contentSearchUI.js) + content/browser/contentSearchHandoffUI.js (content/contentSearchHandoffUI.js) + content/browser/contentSearchUI.css (content/contentSearchUI.css) + search-extensions/ (extensions/**) + +% resource search-extensions %search-extensions/ contentaccessible=yes diff --git a/browser/components/search/metrics.yaml b/browser/components/search/metrics.yaml new file mode 100644 index 0000000000..9f7b6af652 --- /dev/null +++ b/browser/components/search/metrics.yaml @@ -0,0 +1,313 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +# Adding a new metric? We have docs for that! +# https://firefox-source-docs.mozilla.org/toolkit/components/glean/user/new_definitions_file.html + +--- +$schema: moz://mozilla.org/schemas/glean/metrics/2-0-0 +$tags: + - 'Firefox :: Search' + +newtab.search: + issued: + type: event + description: > + When Firefox was asked to issue a search from a Search Access Point (SAP) + on a newtab page. + Doesn't record searches in Private Browsing Mode unless + `browser.engagement.search_counts.pbm` is set to `true`. + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1766887 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1786670 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1817105 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1766887 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1786670#c3 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1817105#c11 + data_sensitivity: + - interaction + notification_emails: + - anicholson@mozilla.com + - chutten@mozilla.com + - mmccorquodale@mozilla.com + - najiang@mozilla.com + - lina@mozilla.com + expires: never + extra_keys: + newtab_visit_id: &newtab_visit_id + description: > + The id of the newtab visit that originated the search. + Should always be present for handoff searches. + TODO(bug 1774597): for searches done without handoff (e.g. with + `browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar` + set to `false`), the active newtab visit id is unknown. + type: string + search_access_point: &search_access_point + description: > + One of the search access points available on the new tab like + * `urlbar_handoff` + * `about_home` + * `about_newtab` + type: string + telemetry_id: &telemetry_id + description: > + The search engine's `telemetryId`, like `google-b-d`. + This is set to be a telemetry-specific id for app-provided engines, + and is `other-<name>` for others (where `<name>` is the engine's + WebExtension name). + type: string + send_in_pings: + - newtab + +newtab.search.ad: + impression: + type: event + description: > + Recorded when a newtab visit resulted in a search that + loaded a Search Engine Result Page (SERP) that contains an ad link. + And the SERP is visible. + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1766887 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1786670 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1817105 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1766887 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1786670#c3 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1817105#c11 + data_sensitivity: + - interaction + notification_emails: + - anicholson@mozilla.com + - chutten@mozilla.com + - mmccorquodale@mozilla.com + - najiang@mozilla.com + - lina@mozilla.com + expires: never + extra_keys: + newtab_visit_id: *newtab_visit_id + search_access_point: *search_access_point + is_follow_on: &is_follow_on + description: > + Whether the preceding search happened on a search results page. + type: boolean + is_tagged: &is_tagged + description: > + Whether the preceding search was tagged with a partner code. + type: boolean + telemetry_id: *telemetry_id + send_in_pings: + - newtab + + click: + type: event + description: > + Recorded when an ad link is clicked on a Search Engine Result Page (SERP) + which was loaded by a seach that began on a newtab page. + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1766887 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1786670 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1817105 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1766887 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1786670#c3 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1817105#c11 + data_sensitivity: + - interaction + notification_emails: + - anicholson@mozilla.com + - chutten@mozilla.com + - mmccorquodale@mozilla.com + - najiang@mozilla.com + - lina@mozilla.com + expires: never + extra_keys: + newtab_visit_id: *newtab_visit_id + search_access_point: *search_access_point + is_follow_on: *is_follow_on + is_tagged: *is_tagged + telemetry_id: *telemetry_id + send_in_pings: + - newtab + +serp: + impression: + type: event + description: > + Recorded when a search engine results page (SERP) is shown to a user. + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1813162 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1824543 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1816736 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1816738 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1829953 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1813162 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1824543 + data_sensitivity: + - interaction + notification_emails: + - fx-search-telemetry@mozilla.com + - rev-data@mozilla.com + expires: never + extra_keys: + impression_id: &impression_id + description: > + A uuid to link SERP events to user's engagement events. + type: string + provider: + description: > + The name of the provider. + type: string + tagged: + description: > + Whether the search is tagged (true) or organic (false). + type: boolean + partner_code: + description: > + Any partner_code parsing in the URL or an empty string if not + available. + type: string + source: + description: > + How the user arrived at the SERP. + Possible values are: + `urlbar`, `urlbar_handoff`, `urlbar_searchmode`, `urlbar_persisted`, + `searchbar`, `contextmenu`, `webextension`, `system`, `reload`, + `tabhistory`, `follow_on_from_refine_on_incontent_search`, + `follow_on_from_refine_on_SERP`, `opened_in_new_tab`, `unknown`. + This will be `unknown` if we cannot determine the source. + type: string + shopping_tab_displayed: + description: + Indicates if the shopping tab is displayed. + type: boolean + is_shopping_page: + description: + Indicates if the page is a shopping page. + type: boolean + + engagement: + type: event + description: > + Recorded user actions on a SERP. + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1814773 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1816730 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1816735 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1814773 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1816730 + data_sensitivity: + - interaction + notification_emails: + - fx-search-telemetry@mozilla.com + - rev-data@mozilla.com + expires: never + extra_keys: + impression_id: *impression_id + action: + description: > + The action taken on the page. + Possible values are `clicked`, `expanded`, and `submitted`. + type: string + target: + description: > + The target component used to trigger the action. + Possible values are: + `ad_carousel`, + `ad_image_row`, + `ad_link`, + `ad_sidebar`, + `ad_sitelink`, + `incontent_searchbox`, + `refined_search_buttons`, + `shopping_tab`. + type: string + + ad_impression: + type: event + description: > + Recorded when a user loads a SERP and ads are detected. + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1816728 + - https://bugzilla.mozilla.org/show_bug.cgi?id=1816729 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1816728 + data_sensitivity: + - interaction + notification_emails: + - fx-search-telemetry@mozilla.com + - rev-data@mozilla.com + expires: never + extra_keys: + impression_id: *impression_id + component: + description: > + Type of components on a SERP. Possible values are: + `ad_carousel`, + `ad_image_row`, + `ad_link`, + `ad_sidebar`, + `ad_sitelink`, + `refined_search_buttons`, + `shopping_tab`. + Defaults to `ad_link`. + type: string + ads_loaded: + description: > + Number of ads loaded for this component. They may or + may not be visible on the page. + type: quantity + ads_visible: + description: > + Number of ads visible for this component. An ad can be + considered visible if was within the browser window + by the time the impression was recorded. + type: quantity + ads_hidden: + description: > + Number of ads hidden for this component. These are ads that + are loaded in the DOM but hidden via CSS and/or Javascript. + type: quantity + + abandonment: + type: event + description: > + Recorded when there is no engagement with the SERP before the tab is + closed, the window is closed, the app is closed, or the tab is navigated + away from. + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1814776 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1814776 + data_sensitivity: + - interaction + notification_emails: + - fx-search-telemetry@mozilla.com + - rev-data@mozilla.com + expires: never + extra_keys: + impression_id: *impression_id + reason: + description: > + Why the SERP is deemed abandoned. + Possible values are: + `tab_close`, `window_close`, `navigation` + type: string + + categorization_duration: + type: timing_distribution + time_unit: millisecond + description: > + The time it takes to categorize elements on a SERP. + bugs: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1834100 + data_reviews: + - https://bugzilla.mozilla.org/show_bug.cgi?id=1834100 + data_sensitivity: + - technical + notification_emails: + - fx-search-telemetry@mozilla.com + expires: never diff --git a/browser/components/search/moz.build b/browser/components/search/moz.build new file mode 100644 index 0000000000..a3b1ad2763 --- /dev/null +++ b/browser/components/search/moz.build @@ -0,0 +1,28 @@ +# -*- 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 += [ + "BrowserSearchTelemetry.sys.mjs", + "SearchOneOffs.sys.mjs", + "SearchSERPTelemetry.sys.mjs", + "SearchUIUtils.sys.mjs", +] + +BROWSER_CHROME_MANIFESTS += [ + "test/browser/browser.ini", + "test/browser/google_codes/browser.ini", +] + +MARIONETTE_LAYOUT_MANIFESTS += ["test/marionette/manifest.ini"] + +XPCSHELL_TESTS_MANIFESTS += ["test/unit/xpcshell.ini"] + +JAR_MANIFESTS += ["jar.mn"] + +SPHINX_TREES["/browser/search"] = "docs" + +with Files("**"): + BUG_COMPONENT = ("Firefox", "Search") diff --git a/browser/components/search/schema/Readme.txt b/browser/components/search/schema/Readme.txt new file mode 100644 index 0000000000..14fffb5c10 --- /dev/null +++ b/browser/components/search/schema/Readme.txt @@ -0,0 +1,7 @@ +The schemas in this directory are the primary source for the schemas they represent. + +They are uploaded to the RemoteSettings server to validate new configurations. + +Any changes should be validated by the Search team. + +See the documentation for more information: https://firefox-source-docs.mozilla.org/ diff --git a/browser/components/search/schema/search-telemetry-schema.json b/browser/components/search/schema/search-telemetry-schema.json new file mode 100644 index 0000000000..8bca1f30fb --- /dev/null +++ b/browser/components/search/schema/search-telemetry-schema.json @@ -0,0 +1,341 @@ +{ + "type": "object", + "required": ["telemetryId", "searchPageRegexp", "queryParamName"], + "properties": { + "telemetryId": { + "type": "string", + "title": "Telemetry Id", + "description": "The telemetry identifier for the provider.", + "pattern": "^[a-z0-9-._]*$" + }, + "searchPageRegexp": { + "type": "string", + "title": "Search Page Regular Expression", + "description": "A regular expression which matches the search page of the provider." + }, + "queryParamName": { + "type": "string", + "title": "Search Query Parameter Name", + "description": "The name of the query parameter for the user's search string. This is deprecated, in preference to queryParamNames, but still defined for older clients (pre Firefox 121)." + }, + "queryParamNames": { + "type": "array", + "title": "Search Query Parameter Names", + "description": "An array of query parameters that may be used for the user's search string.", + "items": { + "type": "string" + } + }, + "codeParamName": { + "type": "string", + "title": "Partner Code Parameter Name", + "description": "The name of the query parameter for the partner code." + }, + "taggedCodes": { + "type": "array", + "title": "Partner Codes", + "description": "An array of partner codes to match against the parameters in the url. Matching these codes will report the SERP as tagged.", + "items": { + "type": "string", + "pattern": "^[a-zA-Z0-9-._]*$" + } + }, + "expectedOrganicCodes": { + "type": "array", + "title": "Expected Organic Codes", + "description": "An array of partner codes to match against the parameters in the url. Matching these codes will report the SERP as organic:none which means the user has done a search through the search engine's website rather than through SAP.", + "items": { + "type": "string", + "pattern": "^[a-zA-Z0-9-._]*$" + } + }, + "organicCodes": { + "type": "array", + "title": "Organic Codes", + "description": "An array of partner codes to match against the parameters in the url. Matching these codes will report the SERP as organic:<partner code>, which means the search was performed organically rather than through a SAP.", + "items": { + "type": "string", + "pattern": "^[a-zA-Z0-9-._]*$" + } + }, + "followOnParamNames": { + "type": "array", + "title": "Follow-on Search Parameter Names", + "description": "An array of query parameter names that are used when a follow-on search occurs.", + "items": { + "type": "string", + "pattern": "^[a-z0-9-._]*$" + } + }, + "followOnCookies": { + "type": "array", + "title": "Follow-on Cookies", + "description": "An array of cookie details that are used to identify follow-on searches.", + "items": { + "type": "object", + "properties": { + "extraCodeParamName": { + "type": "string", + "description": "The query parameter name in the URL that indicates this might be a follow-on search.", + "pattern": "^[a-z0-9-._]*$" + }, + "extraCodePrefixes": { + "type": "array", + "description": "Possible values for the query parameter in the URL that indicates this might be a follow-on search.", + "items": { + "type": "string", + "pattern": "^[a-zA-Z0-9-._]*$" + } + }, + "host": { + "type": "string", + "description": "The hostname on which the cookie is stored.", + "pattern": "^[a-z0-9-._]*$" + }, + "name": { + "type": "string", + "description": "The name of the cookie to check.", + "pattern": "^[a-zA-Z0-9-._]*$" + }, + "codeParamName": { + "type": "string", + "description": "The name of parameter within the cookie.", + "pattern": "^[a-zA-Z0-9-._]*$" + } + } + } + }, + "extraAdServersRegexps": { + "type": "array", + "title": "Extra Ad Server Regular Expressions", + "description": "An array of regular expressions that match URLs of potential ad servers.", + "items": { + "type": "string" + } + }, + "adServerAttributes": { + "type": "array", + "title": "Ad Server Attributes", + "description": "An array of strings that potentially match data-attribute keys of anchors.", + "items": { + "type": "string" + } + }, + "components": { + "type": "array", + "title": "Components", + "description": "An array of components that could be on the SERP.", + "items": { + "required": ["type"], + "type": "object", + "properties": { + "type": { + "enum": [ + "ad_carousel", + "ad_image_row", + "ad_link", + "ad_sitelink", + "ad_sidebar", + "incontent_searchbox", + "refined_search_buttons", + "shopping_tab" + ], + "description": "The type of component the anchor or DOM element should belong to." + }, + "included": { + "type": "object", + "description": "Conditions that should be fulfilled.", + "properties": { + "parent": { + "title": "Parent", + "description": "The DOM element that should only contain elements applicable to a single component type.", + "type": "object", + "properties": { + "selector": { + "description": "If topDown is true for this component, then this will be the value used in querySelectorAll(). Otherwise, it will be the value to in closest() from the context of an anchor.", + "type": "string" + } + }, + "required": ["selector"] + }, + "children": { + "type": "array", + "title": "Children", + "description": "Child DOM elements of the parent. Optional.", + "items": { + "type": "object", + "properties": { + "selector": { + "type": "string", + "description": "The selector to use querySelectorAll from the context of the parent." + }, + "type": { + "enum": [ + "ad_carousel", + "ad_image_row", + "ad_link", + "ad_sitelink", + "ad_sidebar", + "incontent_searchbox", + "refined_search_buttons", + "shopping_tab" + ], + "description": "The component type to use if this child is present." + }, + "countChildren": { + "type": "boolean", + "description": "Whether we should count all instances of the child element instead of anchor links found inside of the parent. Defaults to false." + } + }, + "required": ["selector"] + } + }, + "related": { + "type": "object", + "properties": { + "selector": { + "type": "string", + "description": "The selector to use querySelectorAll from the context of the parent. Any elements specified will have their click events registered and categorized as expanded unless explicitly overwritten in SearchSERPTelemetryChild." + } + }, + "required": ["selector"] + } + }, + "required": ["parent"] + }, + "excluded": { + "type": "object", + "description": "Conditions that should not be included.", + "properties": { + "parent": { + "type": "object", + "properties": { + "selector": { + "type": "string", + "description": "The root DOM element that shouldn't be a parent from the context of the anchor being inspected." + } + }, + "required": ["selector"] + } + } + }, + "default": { + "type": "boolean", + "description": "Whether this component should be the fallback option if a link was included in both ad-related regular expressions as well as regular expressions matching non-ad elements but couldn't be categorized. Defaults to false." + }, + "topDown": { + "type": "boolean", + "description": "Whether the component should be found first by using document.querySelectorAll on the parent selector definition. Defaults to false." + }, + "dependentRequired": { + "topDown": ["included"] + } + } + } + }, + "nonAdsLinkRegexps": { + "type": "array", + "title": "Non-ads link matching regular expressions", + "description": "An array containing known patterns that match non-ad links from a search provider.", + "items": { + "type": "string", + "description": "The matching regular expression." + } + }, + "shoppingTab": { + "type": "object", + "title": "Shopping Tab", + "properties": { + "selector": { + "type": "string", + "description": "The elements on the page to inspect for the shopping tab. Should be anchor elements." + }, + "regexp": { + "type": "string", + "description": "The regular expression to match against a possible shopping tab. Must be provided if using this feature." + }, + "inspectRegexpInSERP": { + "type": "boolean", + "description": "Whether the regexp should be used against hrefs the selector matches against." + } + }, + "required": ["selector", "regexp"] + }, + "domainExtraction": { + "type": "object", + "title": "Domain Extraction", + "description": "An array of methods for extracting domains from a SERP result.", + "properties": { + "ads": { + "type": "array", + "description": "An array of methods for extracting domains from ads.", + "items": { + "$ref": "/schemas/extraction" + } + }, + "nonAds": { + "type": "array", + "description": "An array of methods for extracting domains from non-ads.", + "items": { + "$ref": "/schemas/extraction" + } + } + } + } + }, + "$defs": { + "extraction": { + "$id": "/schemas/extraction", + "anyOf": [ + { + "type": "object", + "properties": { + "selectors": { + "type": "string", + "description": "The query to inspect all elements on the SERP." + }, + "method": { + "enum": ["data-attribute"], + "description": "The extraction method used for the query." + }, + "options": { + "type": "object", + "properties": { + "dataAttributeKey": { + "type": "string", + "description": "The data attribute key that will be looked up in order to retrieve its data attribute value." + } + }, + "required": ["dataAttributeKey"] + } + }, + "required": ["selectors", "method", "options"] + }, + { + "type": "object", + "properties": { + "selectors": { + "type": "string", + "description": "The query to use to inspect all elements on the SERP." + }, + "method": { + "enum": ["href"], + "description": "The extraction method to use for the query." + }, + "options": { + "type": "object", + "properties": { + "queryParamKey": { + "type": "string", + "description": "The query parameter key to inspect in the href." + } + }, + "required": ["queryParamKey"] + } + }, + "required": ["selectors", "method"] + } + ] + } + } +} diff --git a/browser/components/search/schema/search-telemetry-ui-schema.json b/browser/components/search/schema/search-telemetry-ui-schema.json new file mode 100644 index 0000000000..01c6e89b7e --- /dev/null +++ b/browser/components/search/schema/search-telemetry-ui-schema.json @@ -0,0 +1,20 @@ +{ + "ui:order": [ + "telemetryId", + "searchPageRegexp", + "queryParamNames", + "queryParamName", + "codeParamName", + "taggedCodes", + "expectedOrganicCodes", + "organicCodes", + "followOnParamNames", + "followOnCookies", + "extraAdServersRegexps", + "adServerAttributes", + "components", + "nonAdsLinkRegexps", + "shoppingTab", + "domainExtraction" + ] +} diff --git a/browser/components/search/test/browser/426329.xml b/browser/components/search/test/browser/426329.xml new file mode 100644 index 0000000000..b565ed7288 --- /dev/null +++ b/browser/components/search/test/browser/426329.xml @@ -0,0 +1,11 @@ +<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" + xmlns:moz="http://www.mozilla.org/2006/browser/search/"> + <ShortName>Bug 426329</ShortName> + <Description>426329 Search</Description> + <InputEncoding>utf-8</InputEncoding> + <Image width="16" height="16">data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGklEQVQoz2NgGB6AnZ1dUlJSXl4eSDIyMhLW4Ovr%2B%2Fr168uXL69Zs4YoG%2BLi4i5dusTExMTGxsbNzd3f37937976%2BnpmZmagbHR09J49e5YvX66kpATVEBYW9ubNm2nTphkbG7e2tp44cQLIuHfvXm5urpaWFlDKysqqu7v73LlzECMYIiIiHj58mJCQoKKicvXq1bS0NKBgW1vbjh074uPjgeqAXE1NzSdPnvDz84M0AEUvXLgAsW379u1z5swBen3jxo2zZ892cHB4%2BvQp0KlAfwI1cHJyghQFBwfv2rULokFXV%2FfixYu7d%2B8GGqGgoMDKyrpu3br9%2B%2FcDuXl5eVA%2FAEWBfoWHAdAYoNuAYQ0XAeoUERFhGDYAAPoUaT2dfWJuAAAAAElFTkSuQmCC</Image> + <Url type="text/html" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/test.html"> + <Param name="test" value="{searchTerms}"/> + </Url> + <moz:SearchForm>http://mochi.test:8888/browser/browser/components/search/test/browser/test.html</moz:SearchForm> +</OpenSearchDescription> diff --git a/browser/components/search/test/browser/483086-1.xml b/browser/components/search/test/browser/483086-1.xml new file mode 100644 index 0000000000..765cd13d4f --- /dev/null +++ b/browser/components/search/test/browser/483086-1.xml @@ -0,0 +1,10 @@ +<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" + xmlns:moz="http://www.mozilla.org/2006/browser/search/"> + <ShortName>483086a</ShortName> + <Description>Bug 483086 Test 1</Description> + <Image width="16" height="16">data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGklEQVQoz2NgGB6AnZ1dUlJSXl4eSDIyMhLW4Ovr%2B%2Fr168uXL69Zs4YoG%2BLi4i5dusTExMTGxsbNzd3f37937976%2BnpmZmagbHR09J49e5YvX66kpATVEBYW9ubNm2nTphkbG7e2tp44cQLIuHfvXm5urpaWFlDKysqqu7v73LlzECMYIiIiHj58mJCQoKKicvXq1bS0NKBgW1vbjh074uPjgeqAXE1NzSdPnvDz84M0AEUvXLgAsW379u1z5swBen3jxo2zZ892cHB4%2BvQp0KlAfwI1cHJyghQFBwfv2rULokFXV%2FfixYu7d%2B8GGqGgoMDKyrpu3br9%2B%2FcDuXl5eVA%2FAEWBfoWHAdAYoNuAYQ0XAeoUERFhGDYAAPoUaT2dfWJuAAAAAElFTkSuQmCC</Image> + <Url type="text/html" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/?search"> + <Param name="test" value="{searchTerms}"/> + </Url> + <moz:SearchForm>foo://example.com</moz:SearchForm> +</OpenSearchDescription> diff --git a/browser/components/search/test/browser/483086-2.xml b/browser/components/search/test/browser/483086-2.xml new file mode 100644 index 0000000000..ce952ac2e7 --- /dev/null +++ b/browser/components/search/test/browser/483086-2.xml @@ -0,0 +1,10 @@ +<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" + xmlns:moz="http://www.mozilla.org/2006/browser/search/"> + <ShortName>483086b</ShortName> + <Description>Bug 483086 Test 2</Description> + <Image width="16" height="16">data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGklEQVQoz2NgGB6AnZ1dUlJSXl4eSDIyMhLW4Ovr%2B%2Fr168uXL69Zs4YoG%2BLi4i5dusTExMTGxsbNzd3f37937976%2BnpmZmagbHR09J49e5YvX66kpATVEBYW9ubNm2nTphkbG7e2tp44cQLIuHfvXm5urpaWFlDKysqqu7v73LlzECMYIiIiHj58mJCQoKKicvXq1bS0NKBgW1vbjh074uPjgeqAXE1NzSdPnvDz84M0AEUvXLgAsW379u1z5swBen3jxo2zZ892cHB4%2BvQp0KlAfwI1cHJyghQFBwfv2rULokFXV%2FfixYu7d%2B8GGqGgoMDKyrpu3br9%2B%2FcDuXl5eVA%2FAEWBfoWHAdAYoNuAYQ0XAeoUERFhGDYAAPoUaT2dfWJuAAAAAElFTkSuQmCC</Image> + <Url type="text/html" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/?search"> + <Param name="test" value="{searchTerms}"/> + </Url> + <moz:SearchForm>http://example.com</moz:SearchForm> +</OpenSearchDescription> diff --git a/browser/components/search/test/browser/browser.ini b/browser/components/search/test/browser/browser.ini new file mode 100644 index 0000000000..09fcd7e50f --- /dev/null +++ b/browser/components/search/test/browser/browser.ini @@ -0,0 +1,176 @@ +[DEFAULT] +support-files = + mozsearch.sjs + test_search.html + 426329.xml + 483086-1.xml + 483086-2.xml + discovery.html + head.js + opensearch.html + test.html + testEngine.xml + testEngine_diacritics.xml + testEngine_dupe.xml + testEngine_mozsearch.xml + tooManyEnginesOffered.html + +[browser_426329.js] +[browser_483086.js] +[browser_addKeywordSearch.js] +[browser_contentContextMenu.js] +support-files = browser_contentContextMenu.xhtml +[browser_contentSearchUI.js] +support-files = + contentSearchUI.html + contentSearchUI.js + searchSuggestionEngine.sjs +[browser_contentSearchUI_default.js] +[browser_contextSearchTabPosition.js] +[browser_contextmenu.js] +[browser_contextmenu_whereToOpenLink.js] +[browser_defaultPrivate_nimbus.js] +support-files = + search-engines/basic/manifest.json + search-engines/private/manifest.json +[browser_google_behavior.js] +[browser_hiddenOneOffs_cleanup.js] +[browser_hiddenOneOffs_diacritics.js] +[browser_ime_composition.js] +[browser_oneOffContextMenu.js] +[browser_oneOffContextMenu_setDefault.js] +[browser_private_search_perwindowpb.js] +[browser_rich_suggestions.js] +support-files = + trendingSuggestionEngine.sjs +[browser_searchEngine_behaviors.js] +[browser_search_annotation.js] +[browser_search_discovery.js] +[browser_search_glean_serp_telemetry_enabled_by_nimbus_variable.js] +tags = search-telemetry +support-files = + searchTelemetryAd.html +[browser_search_nimbus_reload.js] +[browser_search_telemetry_abandonment.js] +tags = search-telemetry +support-files = + searchTelemetry.html + searchTelemetryAd.html +[browser_search_telemetry_aboutHome.js] +tags = search-telemetry +[browser_search_telemetry_adImpression_component.js] +tags = search-telemetry +support-files = + searchTelemetryAd_components_carousel.html + searchTelemetryAd_components_carousel_below_the_fold.html + searchTelemetryAd_components_carousel_doubled.html + searchTelemetryAd_components_carousel_first_element_non_visible.html + searchTelemetryAd_components_carousel_hidden.html + searchTelemetryAd_components_carousel_outer_container.html + searchTelemetryAd_components_text.html + searchTelemetryAd_components_visibility.html + serp.css +[browser_search_telemetry_categorization_timing.js] +[browser_search_telemetry_content.js] +tags = search-telemetry +[browser_search_telemetry_engagement_cached.js] +tags = search-telemetry +support-files = + cacheable.html + cacheable.html^headers^ + searchTelemetryAd_components_text.html + serp.css +[browser_search_telemetry_engagement_cached_serp.js] +tags = search-telemetry +support-files = + searchTelemetryAd_searchbox.html + searchTelemetryAd_searchbox.html^headers^ +[browser_search_telemetry_engagement_content.js] +tags = search-telemetry +support-files = + searchTelemetryAd_searchbox_with_content.html + searchTelemetryAd_searchbox_with_content.html^headers^ + searchTelemetryAd_searchbox_with_content_redirect.html + searchTelemetryAd_searchbox_with_content_redirect.html^headers^ + serp.css +[browser_search_telemetry_engagement_multiple_tabs.js] +tags = search-telemetry +support-files = + searchTelemetryAd_searchbox_with_content.html + searchTelemetryAd_searchbox_with_content.html^headers^ +[browser_search_telemetry_engagement_non_ad.js] +tags = search-telemetry +support-files = + searchTelemetryAd_searchbox_with_content.html + searchTelemetryAd_searchbox_with_content.html^headers^ + serp.css +[browser_search_telemetry_engagement_redirect.js] +tags = search-telemetry +support-files = + redirect_ad.sjs + redirect_final.sjs + redirect_once.sjs + redirect_thrice.sjs + redirect_twice.sjs + searchTelemetryAd_components_text.html + searchTelemetryAd_nonAdsLink_redirect.html + searchTelemetryAd_nonAdsLink_redirect.html^headers^ + searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html + searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html^headers^ + serp.css +[browser_search_telemetry_engagement_target.js] +tags = search-telemetry +support-files = + searchTelemetryAd_components_text.html + searchTelemetryAd_searchbox.html + searchTelemetryAd_searchbox.html^headers^ + serp.css +[browser_search_telemetry_searchbar.js] +https_first_disabled = true +tags = search-telemetry +support-files = + slow_loading_page_with_ads_on_load_event.html + slow_loading_page_with_ads.html + slow_loading_page_with_ads.sjs + telemetrySearchSuggestions.sjs + telemetrySearchSuggestions.xml +[browser_search_telemetry_shopping.js] +tags = search-telemetry +support-files = + searchTelemetryAd_shopping.html +[browser_search_telemetry_sources.js] +tags = search-telemetry +support-files = + searchTelemetry.html + searchTelemetryAd.html +[browser_search_telemetry_sources_ads.js] +tags = search-telemetry +support-files = + searchTelemetry.html + searchTelemetryAd.html + searchTelemetryAd_dataAttributes.html + searchTelemetryAd_dataAttributes_href.html + searchTelemetryAd_dataAttributes_none.html +[browser_search_telemetry_sources_in_content.js] +tags = search-telemetry +support-files = + searchTelemetryAd_searchbox_with_content.html +[browser_search_telemetry_sources_navigation.js] +tags = search-telemetry +support-files = + searchTelemetry.html + searchTelemetryAd.html +[browser_searchbar_addEngine.js] +[browser_searchbar_context.js] +[browser_searchbar_default.js] +[browser_searchbar_enter.js] +[browser_searchbar_keyboard_navigation.js] +skip-if = (os == 'win' && debug) || (os == 'linux' && asan || debug || tsan) # Bug 1792718 +[browser_searchbar_openpopup.js] +[browser_searchbar_results.js] +[browser_searchbar_smallpanel_keyboard_navigation.js] +[browser_searchbar_widths.js] +[browser_tooManyEnginesOffered.js] +[browser_trending_suggestions.js] +support-files = + trendingSuggestionEngine.sjs diff --git a/browser/components/search/test/browser/browser_426329.js b/browser/components/search/test/browser/browser_426329.js new file mode 100644 index 0000000000..85b7fca2ee --- /dev/null +++ b/browser/components/search/test/browser/browser_426329.js @@ -0,0 +1,335 @@ +/* eslint-disable mozilla/no-arbitrary-setTimeout */ +ChromeUtils.defineESModuleGetters(this, { + FormHistoryTestUtils: + "resource://testing-common/FormHistoryTestUtils.sys.mjs", +}); + +function expectedURL(aSearchTerms) { + const ENGINE_HTML_BASE = + "http://mochi.test:8888/browser/browser/components/search/test/browser/test.html"; + let searchArg = Services.textToSubURI.ConvertAndEscape("utf-8", aSearchTerms); + return ENGINE_HTML_BASE + "?test=" + searchArg; +} + +function simulateClick(aEvent, aTarget) { + let event = document.createEvent("MouseEvent"); + let ctrlKeyArg = aEvent.ctrlKey || false; + let altKeyArg = aEvent.altKey || false; + let shiftKeyArg = aEvent.shiftKey || false; + let metaKeyArg = aEvent.metaKey || false; + let buttonArg = aEvent.button || 0; + event.initMouseEvent( + "click", + true, + true, + window, + 0, + 0, + 0, + 0, + 0, + ctrlKeyArg, + altKeyArg, + shiftKeyArg, + metaKeyArg, + buttonArg, + null + ); + aTarget.dispatchEvent(event); +} + +// modified from toolkit/components/satchel/test/test_form_autocomplete.html +function checkMenuEntries(expectedValues) { + let actualValues = getMenuEntries(); + is( + actualValues.length, + expectedValues.length, + "Checking length of expected menu" + ); + for (let i = 0; i < expectedValues.length; i++) { + is(actualValues[i], expectedValues[i], "Checking menu entry #" + i); + } +} + +function getMenuEntries() { + // Could perhaps pull values directly from the controller, but it seems + // more reliable to test the values that are actually in the richlistbox? + return Array.from(searchBar.textbox.popup.richlistbox.itemChildren, item => + item.getAttribute("ac-value") + ); +} + +var searchBar; +var searchButton; +var searchEntries = ["test"]; +function promiseSetEngine() { + return new Promise(resolve => { + let ss = Services.search; + + function observer(aSub, aTopic, aData) { + switch (aData) { + case "engine-added": + let engine = ss.getEngineByName("Bug 426329"); + ok(engine, "Engine was added."); + ss.defaultEngine = engine; + break; + case "engine-default": + ok(ss.defaultEngine.name == "Bug 426329", "defaultEngine set"); + searchBar = BrowserSearch.searchBar; + searchButton = searchBar.querySelector(".search-go-button"); + ok(searchButton, "got search-go-button"); + + Services.obs.removeObserver( + observer, + "browser-search-engine-modified" + ); + resolve(); + break; + } + } + + Services.obs.addObserver(observer, "browser-search-engine-modified"); + ss.addOpenSearchEngine( + "http://mochi.test:8888/browser/browser/components/search/test/browser/426329.xml", + "data:image/x-icon,%00" + ); + }); +} + +function promiseRemoveEngine() { + return new Promise(resolve => { + let ss = Services.search; + + function observer(aSub, aTopic, aData) { + if (aData == "engine-removed") { + Services.obs.removeObserver(observer, "browser-search-engine-modified"); + resolve(); + } + } + + Services.obs.addObserver(observer, "browser-search-engine-modified"); + let engine = ss.getEngineByName("Bug 426329"); + ss.removeEngine(engine); + }); +} + +var preSelectedBrowser; +var preTabNo; +async function prepareTest() { + await Services.search.init(); + + preSelectedBrowser = gBrowser.selectedBrowser; + preTabNo = gBrowser.tabs.length; + searchBar = BrowserSearch.searchBar; + + await SimpleTest.promiseFocus(); + + if (document.activeElement == searchBar) { + return; + } + + let focusPromise = BrowserTestUtils.waitForEvent(searchBar.textbox, "focus"); + gURLBar.focus(); + searchBar.focus(); + await focusPromise; +} + +add_task(async function testSetup() { + await gCUITestUtils.addSearchBar(); + registerCleanupFunction(() => { + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function testSetupEngine() { + await promiseSetEngine(); + searchBar.value = "test"; +}); + +add_task(async function testReturn() { + await prepareTest(); + EventUtils.synthesizeKey("KEY_Enter"); + await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + + is(gBrowser.tabs.length, preTabNo, "Return key did not open new tab"); + is( + gBrowser.currentURI.spec, + expectedURL(searchBar.value), + "testReturn opened correct search page" + ); +}); + +add_task(async function testAltReturn() { + await prepareTest(); + await BrowserTestUtils.openNewForegroundTab(gBrowser, () => { + EventUtils.synthesizeKey("KEY_Enter", { altKey: true }); + }); + + is(gBrowser.tabs.length, preTabNo + 1, "Alt+Return key added new tab"); + is( + gBrowser.currentURI.spec, + expectedURL(searchBar.value), + "testAltReturn opened correct search page" + ); +}); + +add_task(async function testAltGrReturn() { + await prepareTest(); + await BrowserTestUtils.openNewForegroundTab(gBrowser, () => { + EventUtils.synthesizeKey("KEY_Enter", { altGraphKey: true }); + }); + + is(gBrowser.tabs.length, preTabNo + 1, "AltGr+Return key added new tab"); + is( + gBrowser.currentURI.spec, + expectedURL(searchBar.value), + "testAltGrReturn opened correct search page" + ); +}); + +// Shift key has no effect for now, so skip it +add_task(async function testShiftAltReturn() { + /* + yield* prepareTest(); + + let url = expectedURL(searchBar.value); + + let newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, url); + EventUtils.synthesizeKey("VK_RETURN", { shiftKey: true, altKey: true }); + yield newTabPromise; + + is(gBrowser.tabs.length, preTabNo + 1, "Shift+Alt+Return key added new tab"); + is(gBrowser.currentURI.spec, url, "testShiftAltReturn opened correct search page"); + */ +}); + +add_task(async function testLeftClick() { + await prepareTest(); + simulateClick({ button: 0 }, searchButton); + await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + is(gBrowser.tabs.length, preTabNo, "LeftClick did not open new tab"); + is( + gBrowser.currentURI.spec, + expectedURL(searchBar.value), + "testLeftClick opened correct search page" + ); +}); + +add_task(async function testMiddleClick() { + await prepareTest(); + await BrowserTestUtils.openNewForegroundTab(gBrowser, () => { + simulateClick({ button: 1 }, searchButton); + }); + is(gBrowser.tabs.length, preTabNo + 1, "MiddleClick added new tab"); + is( + gBrowser.currentURI.spec, + expectedURL(searchBar.value), + "testMiddleClick opened correct search page" + ); +}); + +add_task(async function testShiftMiddleClick() { + await prepareTest(); + + let url = expectedURL(searchBar.value); + + let newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, url); + simulateClick({ button: 1, shiftKey: true }, searchButton); + let newTab = await newTabPromise; + + is(gBrowser.tabs.length, preTabNo + 1, "Shift+MiddleClick added new tab"); + is( + newTab.linkedBrowser.currentURI.spec, + url, + "testShiftMiddleClick opened correct search page" + ); +}); + +add_task(async function testRightClick() { + preTabNo = gBrowser.tabs.length; + BrowserTestUtils.loadURIString(gBrowser.selectedBrowser, "about:blank", { + triggeringPrincipal: Services.scriptSecurityManager.createNullPrincipal({}), + }); + await new Promise(resolve => { + setTimeout(function () { + is(gBrowser.tabs.length, preTabNo, "RightClick did not open new tab"); + is(gBrowser.currentURI.spec, "about:blank", "RightClick did nothing"); + resolve(); + }, 5000); + simulateClick({ button: 2 }, searchButton); + }); + // The click in the searchbox focuses it, which opens the suggestion + // panel. Clean up after ourselves. + searchBar.textbox.popup.hidePopup(); +}); + +add_task(async function testSearchHistory() { + let textbox = searchBar._textbox; + for (let i = 0; i < searchEntries.length; i++) { + let count = await FormHistoryTestUtils.count( + textbox.getAttribute("autocompletesearchparam"), + { value: searchEntries[i], source: "Bug 426329" } + ); + ok(count > 0, "form history entry '" + searchEntries[i] + "' should exist"); + } +}); + +add_task(async function testAutocomplete() { + let popup = searchBar.textbox.popup; + let popupShownPromise = BrowserTestUtils.waitForEvent(popup, "popupshown"); + searchBar.textbox.showHistoryPopup(); + await popupShownPromise; + checkMenuEntries(searchEntries); + searchBar.textbox.closePopup(); +}); + +add_task(async function testClearHistory() { + // Open the textbox context menu to trigger controller attachment. + let textbox = searchBar.textbox; + let popupShownPromise = BrowserTestUtils.waitForEvent( + window, + "popupshown", + false, + event => event.target.classList.contains("textbox-contextmenu") + ); + EventUtils.synthesizeMouseAtCenter(textbox, { + type: "contextmenu", + button: 2, + }); + await popupShownPromise; + // Close the context menu. + let contextMenu = document.querySelector(".textbox-contextmenu"); + contextMenu.hidePopup(); + + let menuitem = searchBar._menupopup.querySelector(".searchbar-clear-history"); + ok(!menuitem.disabled, "Clear history menuitem enabled"); + + let historyCleared = promiseObserver("satchel-storage-changed"); + searchBar._menupopup.activateItem(menuitem); + await historyCleared; + let count = await FormHistoryTestUtils.count( + textbox.getAttribute("autocompletesearchparam") + ); + ok(count == 0, "History cleared"); +}); + +add_task(async function asyncCleanup() { + searchBar.value = ""; + while (gBrowser.tabs.length != 1) { + gBrowser.removeTab(gBrowser.tabs[0], { animate: false }); + } + BrowserTestUtils.loadURIString(gBrowser.selectedBrowser, "about:blank", { + triggeringPrincipal: Services.scriptSecurityManager.createNullPrincipal({}), + }); + await promiseRemoveEngine(); +}); + +function promiseObserver(topic) { + return new Promise(resolve => { + let obs = (aSubject, aTopic, aData) => { + Services.obs.removeObserver(obs, aTopic); + resolve(aSubject); + }; + Services.obs.addObserver(obs, topic); + }); +} diff --git a/browser/components/search/test/browser/browser_483086.js b/browser/components/search/test/browser/browser_483086.js new file mode 100644 index 0000000000..9a487c403b --- /dev/null +++ b/browser/components/search/test/browser/browser_483086.js @@ -0,0 +1,56 @@ +/* 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 gSS = Services.search; + +function test() { + waitForExplicitFinish(); + + function observer(aSubject, aTopic, aData) { + switch (aData) { + case "engine-added": + let engine = gSS.getEngineByName("483086a"); + ok(engine, "Test engine 1 installed"); + isnot( + engine.searchForm, + "foo://example.com", + "Invalid SearchForm URL dropped" + ); + gSS.removeEngine(engine); + break; + case "engine-removed": + Services.obs.removeObserver(observer, "browser-search-engine-modified"); + test2(); + break; + } + } + + Services.obs.addObserver(observer, "browser-search-engine-modified"); + gSS.addOpenSearchEngine( + "http://mochi.test:8888/browser/browser/components/search/test/browser/483086-1.xml", + "data:image/x-icon;%00" + ); +} + +function test2() { + function observer(aSubject, aTopic, aData) { + switch (aData) { + case "engine-added": + let engine = gSS.getEngineByName("483086b"); + ok(engine, "Test engine 2 installed"); + is(engine.searchForm, "http://example.com", "SearchForm is correct"); + gSS.removeEngine(engine); + break; + case "engine-removed": + Services.obs.removeObserver(observer, "browser-search-engine-modified"); + finish(); + break; + } + } + + Services.obs.addObserver(observer, "browser-search-engine-modified"); + gSS.addOpenSearchEngine( + "http://mochi.test:8888/browser/browser/components/search/test/browser/483086-2.xml", + "data:image/x-icon;%00" + ); +} diff --git a/browser/components/search/test/browser/browser_addKeywordSearch.js b/browser/components/search/test/browser/browser_addKeywordSearch.js new file mode 100644 index 0000000000..6de653fd89 --- /dev/null +++ b/browser/components/search/test/browser/browser_addKeywordSearch.js @@ -0,0 +1,89 @@ +var testData = [ + { desc: "No path", action: "http://example.com/", param: "q" }, + { + desc: "With path", + action: "http://example.com/new-path-here/", + param: "q", + }, + { desc: "No action", action: "", param: "q" }, + { + desc: "With Query String", + action: "http://example.com/search?oe=utf-8", + param: "q", + }, +]; + +add_task(async function () { + const TEST_URL = + "http://example.org/browser/browser/components/search/test/browser/test.html"; + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_URL); + + let count = 0; + for (let method of ["GET", "POST"]) { + for (let { desc, action, param } of testData) { + info(`Running ${method} keyword test '${desc}'`); + let id = `keyword-form-${count++}`; + let contextMenu = document.getElementById("contentAreaContextMenu"); + let contextMenuPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + + await SpecialPowers.spawn( + tab.linkedBrowser, + [{ action, param, method, id }], + async function (args) { + let doc = content.document; + let form = doc.createElement("form"); + form.id = args.id; + form.method = args.method; + form.action = args.action; + let element = doc.createElement("input"); + element.setAttribute("type", "text"); + element.setAttribute("name", args.param); + form.appendChild(element); + doc.body.appendChild(form); + } + ); + + await BrowserTestUtils.synthesizeMouseAtCenter( + `#${id} > input`, + { type: "contextmenu", button: 2 }, + tab.linkedBrowser + ); + await contextMenuPromise; + let url = action || tab.linkedBrowser.currentURI.spec; + let actor = gContextMenu.actor; + + let data = await actor.getSearchFieldBookmarkData( + gContextMenu.targetIdentifier + ); + if (method == "GET") { + ok( + data.spec.endsWith(`${param}=%s`), + `Check expected url for field named ${param} and action ${action}` + ); + } else { + is( + data.spec, + url, + `Check expected url for field named ${param} and action ${action}` + ); + is( + data.postData, + `${param}%3D%25s`, + `Check expected POST data for field named ${param} and action ${action}` + ); + } + + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + contextMenu.hidePopup(); + await popupHiddenPromise; + } + } + + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_contentContextMenu.js b/browser/components/search/test/browser/browser_contentContextMenu.js new file mode 100644 index 0000000000..684428821e --- /dev/null +++ b/browser/components/search/test/browser/browser_contentContextMenu.js @@ -0,0 +1,230 @@ +/* Make sure context menu includes option to search hyperlink text on search + * engine. + */ + +add_task(async function () { + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.separatePrivateDefault", true], + ["browser.search.separatePrivateDefault.ui.enabled", true], + ], + }); + + const url = + "http://mochi.test:8888/browser/browser/components/search/test/browser/browser_contentContextMenu.xhtml"; + await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + const ellipsis = "\u2026"; + + let contentAreaContextMenu = document.getElementById( + "contentAreaContextMenu" + ); + + const originalPrivateDefault = await Services.search.getDefaultPrivate(); + let otherPrivateDefault; + for (let engine of await Services.search.getVisibleEngines()) { + if (engine.name != originalPrivateDefault.name) { + otherPrivateDefault = engine; + break; + } + } + + // Tests if the "Search <engine> for '<some terms>'" context menu item is + // shown for the given query string of an element. Tests to make sure label + // includes the proper search terms. + // + // Each test: + // + // id: The id of the element to test. + // isSelected: Flag to enable selecting (text highlight) the contents of the + // element. + // shouldBeShown: The display state of the menu item. + // expectedLabelContents: The menu item label should contain a portion of + // this string. Will only be tested if shouldBeShown + // is true. + // shouldPrivateBeShown: The display state of the Private Window menu item. + // expectedPrivateLabelContents: The menu item label for the Private Window + // should contain a portion of this string. + // Will only be tested if shouldPrivateBeShown + // is true. + let tests = [ + { + id: "link", + isSelected: true, + shouldBeShown: true, + expectedLabelContents: "I'm a link!", + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search in", + }, + { + id: "link", + isSelected: false, + shouldBeShown: true, + expectedLabelContents: "I'm a link!", + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search in", + }, + { + id: "longLink", + isSelected: true, + shouldBeShown: true, + expectedLabelContents: "I'm a really lo" + ellipsis, + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search in", + }, + { + id: "longLink", + isSelected: false, + shouldBeShown: true, + expectedLabelContents: "I'm a really lo" + ellipsis, + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search in", + }, + { + id: "plainText", + isSelected: true, + shouldBeShown: true, + expectedLabelContents: "Right clicking " + ellipsis, + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search in", + }, + { + id: "plainText", + isSelected: false, + shouldBeShown: false, + shouldPrivateBeShown: false, + }, + { + id: "mixedContent", + isSelected: true, + shouldBeShown: true, + expectedLabelContents: "I'm some text, " + ellipsis, + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search in", + }, + { + id: "mixedContent", + isSelected: false, + shouldBeShown: false, + shouldPrivateBeShown: false, + }, + { + id: "partialLink", + isSelected: true, + shouldBeShown: true, + expectedLabelContents: "link selection", + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search in", + }, + { + id: "partialLink", + isSelected: false, + shouldBeShown: true, + expectedLabelContents: "A partial link " + ellipsis, + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search with " + otherPrivateDefault.name, + changePrivateDefaultEngine: true, + }, + { + id: "surrogatePair", + isSelected: true, + shouldBeShown: true, + expectedLabelContents: "This character\uD83D\uDD25" + ellipsis, + shouldPrivateBeShown: true, + expectedPrivateLabelContents: "Search with " + otherPrivateDefault.name, + changePrivateDefaultEngine: true, + }, + ]; + + for (let test of tests) { + if (test.changePrivateDefaultEngine) { + await Services.search.setDefaultPrivate( + otherPrivateDefault, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + } + + await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [{ selectElement: test.isSelected ? test.id : null }], + async function (arg) { + let selection = content.getSelection(); + selection.removeAllRanges(); + + if (arg.selectElement) { + selection.selectAllChildren( + content.document.getElementById(arg.selectElement) + ); + } + } + ); + + let popupShownPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenu, + "popupshown" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#" + test.id, + { type: "contextmenu", button: 2 }, + gBrowser.selectedBrowser + ); + await popupShownPromise; + + let menuItem = document.getElementById("context-searchselect"); + is( + menuItem.hidden, + !test.shouldBeShown, + "search context menu item is shown for '#" + + test.id + + "' and selected is '" + + test.isSelected + + "'" + ); + + if (test.shouldBeShown) { + ok( + menuItem.label.includes(test.expectedLabelContents), + "Menu item text '" + + menuItem.label + + "' contains the correct search terms '" + + test.expectedLabelContents + + "'" + ); + } + + menuItem = document.getElementById("context-searchselect-private"); + is( + menuItem.hidden, + !test.shouldPrivateBeShown, + "private search context menu item is shown for '#" + test.id + "' " + ); + + if (test.shouldPrivateBeShown) { + ok( + menuItem.label.includes(test.expectedPrivateLabelContents), + "Menu item text '" + + menuItem.label + + "' contains the correct search terms '" + + test.expectedPrivateLabelContents + + "'" + ); + } + + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenu, + "popuphidden" + ); + contentAreaContextMenu.hidePopup(); + await popupHiddenPromise; + + if (test.changePrivateDefaultEngine) { + await Services.search.setDefaultPrivate( + originalPrivateDefault, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + } + } + + // Cleanup. + gBrowser.removeCurrentTab(); +}); diff --git a/browser/components/search/test/browser/browser_contentContextMenu.xhtml b/browser/components/search/test/browser/browser_contentContextMenu.xhtml new file mode 100644 index 0000000000..16e32eb8ac --- /dev/null +++ b/browser/components/search/test/browser/browser_contentContextMenu.xhtml @@ -0,0 +1,22 @@ +<?xml version="1.0" encoding="UTF-8"?> +<html xmlns="http://www.w3.org/1999/xhtml"> + <body> + <a href="http://mozilla.org" id="link">I'm a link!</a> + <br/> + <a href="http://mozilla.org" id="longLink">I'm a really long link and I should be truncated.</a> + <br/> + <span id="plainText"> + Right clicking me when I'm selected should show the menu item. + </span> + <br/> + <span id="mixedContent"> + I'm some text, and <a href="http://mozilla.org">I'm a link!</a> + </span> + <br/> + <a href="http://mozilla.org">A partial <span id="partialLink">link selection</span></a> + <br/> + <span id="surrogatePair"> + This character🔥 shouldn't be truncated. + </span> + </body> +</html> diff --git a/browser/components/search/test/browser/browser_contentSearchUI.js b/browser/components/search/test/browser/browser_contentSearchUI.js new file mode 100644 index 0000000000..9196b1355c --- /dev/null +++ b/browser/components/search/test/browser/browser_contentSearchUI.js @@ -0,0 +1,1158 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +const TEST_PAGE_BASENAME = "contentSearchUI.html"; + +const TEST_ENGINE1 = { + name: "searchSuggestionEngine1", + id: "other-searchSuggestionEngine1", + loadPath: "[addon]searchsuggestionengine1@tests.mozilla.org", +}; +const TEST_ENGINE2 = { + name: "searchSuggestionEngine2", + id: "other-searchSuggestionEngine2", + loadPath: "[addon]searchsuggestionengine2@tests.mozilla.org", +}; + +const TEST_MSG = "ContentSearchUIControllerTest"; + +ChromeUtils.defineESModuleGetters(this, { + ContentSearch: "resource:///actors/ContentSearchParent.sys.mjs", + FormHistoryTestUtils: + "resource://testing-common/FormHistoryTestUtils.sys.mjs", + SearchSuggestionController: + "resource://gre/modules/SearchSuggestionController.sys.mjs", +}); + +const pageURL = getRootDirectory(gTestPath) + TEST_PAGE_BASENAME; +BrowserTestUtils.registerAboutPage( + registerCleanupFunction, + "test-about-content-search-ui", + pageURL, + Ci.nsIAboutModule.URI_SAFE_FOR_UNTRUSTED_CONTENT | + Ci.nsIAboutModule.URI_MUST_LOAD_IN_CHILD | + Ci.nsIAboutModule.ALLOW_SCRIPT | + Ci.nsIAboutModule.URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS +); + +requestLongerTimeout(2); + +function waitForSuggestions() { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => + ContentTaskUtils.waitForCondition( + () => + Cu.waiveXrays(content).gController.input.getAttribute( + "aria-expanded" + ) == "true", + "Waiting for suggestions", + 200 // Increased interval to support long textruns. + ) + ); +} + +async function waitForSearch() { + await BrowserTestUtils.waitForContentEvent( + gBrowser.selectedBrowser, + "ContentSearchClient", + true, + event => { + if (event.detail.type == "Search") { + event.target._eventDetail = event.detail.data; + return true; + } + return false; + }, + true + ); + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + let eventDetail = content._eventDetail; + delete content._eventDetail; + return eventDetail; + }); +} + +async function waitForSearchSettings() { + await BrowserTestUtils.waitForContentEvent( + gBrowser.selectedBrowser, + "ContentSearchClient", + true, + event => { + if (event.detail.type == "ManageEngines") { + event.target._eventDetail = event.detail.data; + return true; + } + return false; + }, + true + ); + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + let eventDetail = content._eventDetail; + delete content._eventDetail; + return eventDetail; + }); +} + +function getCurrentState() { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + let controller = Cu.waiveXrays(content).gController; + let state = { + selectedIndex: controller.selectedIndex, + selectedButtonIndex: controller.selectedButtonIndex, + numSuggestions: controller._table.hidden ? 0 : controller.numSuggestions, + suggestionAtIndex: [], + isFormHistorySuggestionAtIndex: [], + + tableHidden: controller._table.hidden, + + inputValue: controller.input.value, + ariaExpanded: controller.input.getAttribute("aria-expanded"), + }; + + if (state.numSuggestions) { + for (let i = 0; i < controller.numSuggestions; i++) { + state.suggestionAtIndex.push(controller.suggestionAtIndex(i)); + state.isFormHistorySuggestionAtIndex.push( + controller.isFormHistorySuggestionAtIndex(i) + ); + } + } + + return state; + }); +} + +async function msg(type, data = null) { + switch (type) { + case "reset": + // Reset both the input and suggestions by select all + delete. If there was + // no text entered, this won't have any effect, so also escape to ensure the + // suggestions table is closed. + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + Cu.waiveXrays(content).gController.input.focus(); + EventUtils.synthesizeKey("a", { accelKey: true }, content); + EventUtils.synthesizeKey("KEY_Delete", {}, content); + EventUtils.synthesizeKey("KEY_Escape", {}, content); + }); + break; + + case "key": { + let keyName = typeof data == "string" ? data : data.key; + await BrowserTestUtils.synthesizeKey( + keyName, + data.modifiers || {}, + gBrowser.selectedBrowser + ); + if (data?.waitForSuggestions) { + await waitForSuggestions(); + } + break; + } + case "text": { + await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [data.value], + text => { + Cu.waiveXrays(content).gController.input.value = text.substring( + 0, + text.length - 1 + ); + EventUtils.synthesizeKey( + text.substring(text.length - 1), + {}, + content + ); + } + ); + if (data?.waitForSuggestions) { + await waitForSuggestions(); + } + break; + } + case "startComposition": + await BrowserTestUtils.synthesizeComposition( + "compositionstart", + gBrowser.selectedBrowser + ); + break; + case "changeComposition": { + await BrowserTestUtils.synthesizeCompositionChange( + { + composition: { + string: data.data, + clauses: [ + { + length: data.length, + attr: Ci.nsITextInputProcessor.ATTR_RAW_CLAUSE, + }, + ], + }, + caret: { start: data.length, length: 0 }, + }, + gBrowser.selectedBrowser + ); + if (data?.waitForSuggestions) { + await waitForSuggestions(); + } + break; + } + case "commitComposition": + await BrowserTestUtils.synthesizeComposition( + "compositioncommitasis", + gBrowser.selectedBrowser + ); + break; + case "mousemove": + case "click": { + let event; + let index; + if (type == "mousemove") { + event = { + type: "mousemove", + clickcount: 0, + }; + index = data; + } else { + event = data.modifiers || null; + index = data.eltIdx; + } + + await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [type, event, index], + (eventType, eventArgs, itemIndex) => { + let controller = Cu.waiveXrays(content).gController; + return new Promise(resolve => { + let row; + if (itemIndex == -1) { + row = controller._table.firstChild; + } else { + let allElts = [ + ...controller._suggestionsList.children, + ...controller._oneOffButtons, + content.document.getElementById("contentSearchSettingsButton"), + ]; + row = allElts[itemIndex]; + } + row.addEventListener(eventType, () => resolve(), { once: true }); + EventUtils.synthesizeMouseAtCenter(row, eventArgs, content); + }); + } + ); + break; + } + } + + return getCurrentState(); +} + +/** + * Focusses the in-content search bar. + * + * @returns {Promise} + * A promise that is resolved once the focus is complete. + */ +function focusContentSearchBar() { + return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + Cu.waiveXrays(content).input.focus(); + }); +} + +let extension1; +let extension2; + +add_setup(async function () { + let originalOnMessageSearch = ContentSearch._onMessageSearch; + let originalOnMessageManageEngines = ContentSearch._onMessageManageEngines; + + ContentSearch._onMessageSearch = () => {}; + ContentSearch._onMessageManageEngines = () => {}; + + let currentEngines = await Services.search.getVisibleEngines(); + + extension1 = await SearchTestUtils.installSearchExtension( + { + name: TEST_ENGINE1.name, + suggest_url: + "https://example.com/browser/browser/components/search/test/browser/searchSuggestionEngine.sjs", + suggest_url_get_params: "query={searchTerms}", + }, + { setAsDefault: true } + ); + extension2 = await SearchTestUtils.installSearchExtension({ + name: TEST_ENGINE2.name, + suggest_url: + "https://example.com/browser/browser/components/search/test/browser/searchSuggestionEngine.sjs", + suggest_url_get_params: "query={searchTerms}", + }); + + for (let engine of currentEngines) { + await Services.search.removeEngine(engine); + } + + registerCleanupFunction(async () => { + ContentSearch._onMessageSearch = originalOnMessageSearch; + ContentSearch._onMessageManageEngines = originalOnMessageManageEngines; + }); + + await promiseTab(); +}); + +add_task(async function emptyInput() { + await focusContentSearchBar(); + + let state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + state = await msg("key", "VK_BACK_SPACE"); + checkState(state, "", [], -1); + + await msg("reset"); +}); + +add_task(async function blur() { + await focusContentSearchBar(); + + let state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + Cu.waiveXrays(content).gController.input.blur(); + }); + state = await getCurrentState(); + checkState(state, "x", [], -1); + + await msg("reset"); +}); + +add_task(async function upDownKeys() { + await focusContentSearchBar(); + + let state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + // Cycle down the suggestions starting from no selection. + state = await msg("key", "VK_DOWN"); + checkState(state, "xfoo", ["xfoo", "xbar"], 0); + + state = await msg("key", "VK_DOWN"); + checkState(state, "xbar", ["xfoo", "xbar"], 1); + + state = await msg("key", "VK_DOWN"); + checkState(state, "x", ["xfoo", "xbar"], 2); + + state = await msg("key", "VK_DOWN"); + checkState(state, "x", ["xfoo", "xbar"], 3); + + state = await msg("key", "VK_DOWN"); + checkState(state, "x", ["xfoo", "xbar"], -1); + + // Cycle up starting from no selection. + state = await msg("key", "VK_UP"); + checkState(state, "x", ["xfoo", "xbar"], 3); + + state = await msg("key", "VK_UP"); + checkState(state, "x", ["xfoo", "xbar"], 2); + + state = await msg("key", "VK_UP"); + checkState(state, "xbar", ["xfoo", "xbar"], 1); + + state = await msg("key", "VK_UP"); + checkState(state, "xfoo", ["xfoo", "xbar"], 0); + + state = await msg("key", "VK_UP"); + checkState(state, "x", ["xfoo", "xbar"], -1); + + await msg("reset"); +}); + +add_task(async function rightLeftKeys() { + await focusContentSearchBar(); + + let state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + state = await msg("key", "VK_LEFT"); + checkState(state, "x", ["xfoo", "xbar"], -1); + + state = await msg("key", "VK_LEFT"); + checkState(state, "x", ["xfoo", "xbar"], -1); + + state = await msg("key", "VK_RIGHT"); + checkState(state, "x", ["xfoo", "xbar"], -1); + + state = await msg("key", "VK_RIGHT"); + checkState(state, "x", [], -1); + + state = await msg("key", { key: "VK_DOWN", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + state = await msg("key", "VK_DOWN"); + checkState(state, "xfoo", ["xfoo", "xbar"], 0); + + // This should make the xfoo suggestion sticky. To make sure it sticks, + // trigger suggestions again and cycle through them by pressing Down until + // nothing is selected again. + state = await msg("key", "VK_RIGHT"); + checkState(state, "xfoo", [], -1); + + state = await msg("key", { key: "VK_DOWN", waitForSuggestions: true }); + checkState(state, "xfoo", ["xfoofoo", "xfoobar"], -1); + + state = await msg("key", "VK_DOWN"); + checkState(state, "xfoofoo", ["xfoofoo", "xfoobar"], 0); + + state = await msg("key", "VK_DOWN"); + checkState(state, "xfoobar", ["xfoofoo", "xfoobar"], 1); + + state = await msg("key", "VK_DOWN"); + checkState(state, "xfoo", ["xfoofoo", "xfoobar"], 2); + + state = await msg("key", "VK_DOWN"); + checkState(state, "xfoo", ["xfoofoo", "xfoobar"], 3); + + state = await msg("key", "VK_DOWN"); + checkState(state, "xfoo", ["xfoofoo", "xfoobar"], -1); + + await msg("reset"); +}); + +add_task(async function tabKey() { + await focusContentSearchBar(); + await msg("key", { key: "x", waitForSuggestions: true }); + + let state = await msg("key", "VK_TAB"); + checkState(state, "x", ["xfoo", "xbar"], 2); + + state = await msg("key", "VK_TAB"); + checkState(state, "x", ["xfoo", "xbar"], 3); + + state = await msg("key", { key: "VK_TAB", modifiers: { shiftKey: true } }); + checkState(state, "x", ["xfoo", "xbar"], 2); + + state = await msg("key", { key: "VK_TAB", modifiers: { shiftKey: true } }); + checkState(state, "x", [], -1); + + await focusContentSearchBar(); + + await msg("key", { key: "VK_DOWN", waitForSuggestions: true }); + + for (let i = 0; i < 3; ++i) { + state = await msg("key", "VK_TAB"); + } + checkState(state, "x", [], -1); + + await focusContentSearchBar(); + + await msg("key", { key: "VK_DOWN", waitForSuggestions: true }); + state = await msg("key", "VK_DOWN"); + checkState(state, "xfoo", ["xfoo", "xbar"], 0); + + state = await msg("key", "VK_TAB"); + checkState(state, "xfoo", ["xfoo", "xbar"], 0, 0); + + state = await msg("key", "VK_TAB"); + checkState(state, "xfoo", ["xfoo", "xbar"], 0, 1); + + state = await msg("key", "VK_DOWN"); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 1); + + state = await msg("key", "VK_DOWN"); + checkState(state, "x", ["xfoo", "xbar"], 2); + + state = await msg("key", "VK_UP"); + checkState(state, "xbar", ["xfoo", "xbar"], 1); + + state = await msg("key", "VK_TAB"); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 0); + + state = await msg("key", "VK_TAB"); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 1); + + state = await msg("key", "VK_TAB"); + checkState(state, "xbar", [], -1); + + await msg("reset"); +}); + +add_task(async function cycleSuggestions() { + await focusContentSearchBar(); + await msg("key", { key: "x", waitForSuggestions: true }); + + let cycle = async function (aSelectedButtonIndex) { + let modifiers = { + shiftKey: true, + accelKey: true, + }; + + let state = await msg("key", { key: "VK_DOWN", modifiers }); + checkState(state, "xfoo", ["xfoo", "xbar"], 0, aSelectedButtonIndex); + + state = await msg("key", { key: "VK_DOWN", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1, aSelectedButtonIndex); + + state = await msg("key", { key: "VK_DOWN", modifiers }); + checkState(state, "x", ["xfoo", "xbar"], -1, aSelectedButtonIndex); + + state = await msg("key", { key: "VK_DOWN", modifiers }); + checkState(state, "xfoo", ["xfoo", "xbar"], 0, aSelectedButtonIndex); + + state = await msg("key", { key: "VK_UP", modifiers }); + checkState(state, "x", ["xfoo", "xbar"], -1, aSelectedButtonIndex); + + state = await msg("key", { key: "VK_UP", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1, aSelectedButtonIndex); + + state = await msg("key", { key: "VK_UP", modifiers }); + checkState(state, "xfoo", ["xfoo", "xbar"], 0, aSelectedButtonIndex); + + state = await msg("key", { key: "VK_UP", modifiers }); + checkState(state, "x", ["xfoo", "xbar"], -1, aSelectedButtonIndex); + }; + + await cycle(); + + // Repeat with a one-off selected. + let state = await msg("key", "VK_TAB"); + checkState(state, "x", ["xfoo", "xbar"], 2); + await cycle(0); + + // Repeat with the settings button selected. + state = await msg("key", "VK_TAB"); + checkState(state, "x", ["xfoo", "xbar"], 3); + await cycle(1); + + await msg("reset"); +}); + +add_task(async function cycleOneOffs() { + await focusContentSearchBar(); + await msg("key", { key: "x", waitForSuggestions: true }); + + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + let btn = + Cu.waiveXrays(content).gController._oneOffButtons[ + Cu.waiveXrays(content).gController._oneOffButtons.length - 1 + ]; + let newBtn = btn.cloneNode(true); + btn.parentNode.appendChild(newBtn); + Cu.waiveXrays(content).gController._oneOffButtons.push(newBtn); + }); + + let state = await msg("key", "VK_DOWN"); + state = await msg("key", "VK_DOWN"); + checkState(state, "xbar", ["xfoo", "xbar"], 1); + + let modifiers = { + altKey: true, + }; + + state = await msg("key", { key: "VK_DOWN", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 0); + + state = await msg("key", { key: "VK_DOWN", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 1); + + state = await msg("key", { key: "VK_DOWN", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1); + + state = await msg("key", { key: "VK_UP", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 1); + + state = await msg("key", { key: "VK_UP", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 0); + + state = await msg("key", { key: "VK_UP", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1); + + // If the settings button is selected, pressing alt+up/down should select the + // last/first one-off respectively (and deselect the settings button). + await msg("key", "VK_TAB"); + await msg("key", "VK_TAB"); + state = await msg("key", "VK_TAB"); // Settings button selected. + checkState(state, "xbar", ["xfoo", "xbar"], 1, 2); + + state = await msg("key", { key: "VK_UP", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 1); + + state = await msg("key", "VK_TAB"); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 2); + + state = await msg("key", { key: "VK_DOWN", modifiers }); + checkState(state, "xbar", ["xfoo", "xbar"], 1, 0); + + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + Cu.waiveXrays(content).gController._oneOffButtons.pop().remove(); + }); + await msg("reset"); +}); + +add_task(async function mouse() { + await focusContentSearchBar(); + + let state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + state = await msg("mousemove", 0); + checkState(state, "x", ["xfoo", "xbar"], 0); + + state = await msg("mousemove", 1); + checkState(state, "x", ["xfoo", "xbar"], 1); + + state = await msg("mousemove", 2); + checkState(state, "x", ["xfoo", "xbar"], 2, 0); + + state = await msg("mousemove", 3); + checkState(state, "x", ["xfoo", "xbar"], 3, 1); + + state = await msg("mousemove", -1); + checkState(state, "x", ["xfoo", "xbar"], -1); + + await msg("reset"); + await focusContentSearchBar(); + + state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + state = await msg("mousemove", 0); + checkState(state, "x", ["xfoo", "xbar"], 0); + + state = await msg("mousemove", 2); + checkState(state, "x", ["xfoo", "xbar"], 2, 0); + + state = await msg("mousemove", -1); + checkState(state, "x", ["xfoo", "xbar"], -1); + + await msg("reset"); +}); + +add_task(async function formHistory() { + await focusContentSearchBar(); + + // Type an X and add it to form history. + let state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + // Wait for Satchel to say it's been added to form history. + let observePromise = new Promise(resolve => { + Services.obs.addObserver(function onAdd(subj, topic, data) { + if (data == "formhistory-add") { + Services.obs.removeObserver(onAdd, "satchel-storage-changed"); + executeSoon(resolve); + } + }, "satchel-storage-changed"); + }); + + await FormHistoryTestUtils.clear("searchbar-history"); + let entry = await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + return Cu.waiveXrays(content).gController.addInputValueToFormHistory(); + }); + await observePromise; + Assert.greater( + await FormHistoryTestUtils.count("searchbar-history", { + source: entry.source, + }), + 0 + ); + + // Reset the input. + state = await msg("reset"); + checkState(state, "", [], -1); + + // Type an X again. The form history entry should appear. + state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState( + state, + "x", + [{ str: "x", type: "formHistory" }, "xfoo", "xbar"], + -1 + ); + + // Select the form history entry and delete it. + state = await msg("key", "VK_DOWN"); + checkState( + state, + "x", + [{ str: "x", type: "formHistory" }, "xfoo", "xbar"], + 0 + ); + + // Wait for Satchel. + observePromise = new Promise(resolve => { + Services.obs.addObserver(function onRemove(subj, topic, data) { + if (data == "formhistory-remove") { + Services.obs.removeObserver(onRemove, "satchel-storage-changed"); + executeSoon(resolve); + } + }, "satchel-storage-changed"); + }); + state = await msg("key", "VK_DELETE"); + checkState(state, "x", ["xfoo", "xbar"], -1); + + await observePromise; + + // Reset the input. + state = await msg("reset"); + checkState(state, "", [], -1); + + // Type an X again. The form history entry should still be gone. + state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + await msg("reset"); +}); + +add_task(async function formHistory_limit() { + info("Check long strings are not added to form history"); + await focusContentSearchBar(); + const gLongString = new Array( + SearchSuggestionController.SEARCH_HISTORY_MAX_VALUE_LENGTH + 1 + ) + .fill("x") + .join(""); + // Type and confirm a very long string. + let state = await msg("text", { + value: gLongString, + waitForSuggestions: true, + }); + checkState( + state, + gLongString, + [`${gLongString}foo`, `${gLongString}bar`], + -1 + ); + + await FormHistoryTestUtils.clear("searchbar-history"); + let entry = await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + return Cu.waiveXrays(content).gController.addInputValueToFormHistory(); + }); + // There's nothing we can wait for, since addition should not be happening. + /* eslint-disable mozilla/no-arbitrary-setTimeout */ + await new Promise(resolve => setTimeout(resolve, 500)); + Assert.equal( + await FormHistoryTestUtils.count("searchbar-history", { + source: entry.source, + }), + 0 + ); + + await msg("reset"); +}); + +add_task(async function cycleEngines() { + await focusContentSearchBar(); + await msg("key", { key: "VK_DOWN", waitForSuggestions: true }); + + Services.telemetry.clearEvents(); + Services.fog.testResetFOG(); + + let p = SearchTestUtils.promiseSearchNotification( + "engine-default", + "browser-search-engine-modified" + ); + await msg("key", { key: "VK_DOWN", modifiers: { accelKey: true } }); + let newEngine = await p; + Assert.equal( + newEngine.name, + TEST_ENGINE2.name, + "Should have correctly cycled the engine" + ); + TelemetryTestUtils.assertEvents( + [ + { + object: "change_default", + value: "user_searchbar", + extra: { + prev_id: TEST_ENGINE1.id, + new_id: TEST_ENGINE2.id, + new_name: TEST_ENGINE2.name, + new_load_path: TEST_ENGINE2.loadPath, + new_sub_url: "", + }, + }, + ], + { category: "search", method: "engine" } + ); + + let snapshot = await Glean.searchEngineDefault.changed.testGetValue(); + delete snapshot[0].timestamp; + Assert.deepEqual( + snapshot[0], + { + category: "search.engine.default", + name: "changed", + extra: { + new_load_path: TEST_ENGINE2.loadPath, + previous_engine_id: TEST_ENGINE1.id, + change_source: "user_searchbar", + new_engine_id: TEST_ENGINE2.id, + new_display_name: TEST_ENGINE2.name, + new_submission_url: "", + }, + }, + "Should have received the correct event details" + ); + + p = SearchTestUtils.promiseSearchNotification( + "engine-default", + "browser-search-engine-modified" + ); + await msg("key", { key: "VK_UP", modifiers: { accelKey: true } }); + newEngine = await p; + Assert.equal( + newEngine.name, + TEST_ENGINE1.name, + "Should have correctly cycled the engine" + ); + + TelemetryTestUtils.assertEvents( + [ + { + object: "change_default", + value: "user_searchbar", + extra: { + prev_id: TEST_ENGINE2.id, + new_id: TEST_ENGINE1.id, + new_name: TEST_ENGINE1.name, + new_load_path: TEST_ENGINE1.loadPath, + new_sub_url: "", + }, + }, + ], + { category: "search", method: "engine" } + ); + + snapshot = await Glean.searchEngineDefault.changed.testGetValue(); + delete snapshot[1].timestamp; + Assert.deepEqual( + snapshot[1], + { + category: "search.engine.default", + name: "changed", + extra: { + new_load_path: TEST_ENGINE1.loadPath, + previous_engine_id: TEST_ENGINE2.id, + change_source: "user_searchbar", + new_engine_id: TEST_ENGINE1.id, + new_display_name: TEST_ENGINE1.name, + new_submission_url: "", + }, + }, + "Should have received the correct event details" + ); + + await msg("reset"); +}); + +add_task(async function search() { + await focusContentSearchBar(); + + let modifiers = {}; + ["altKey", "ctrlKey", "metaKey", "shiftKey"].forEach( + k => (modifiers[k] = true) + ); + + // Test typing a query and pressing enter. + let p = waitForSearch(); + await msg("key", { key: "x", waitForSuggestions: true }); + await msg("key", { key: "VK_RETURN", modifiers }); + let mesg = await p; + let eventData = { + engineName: TEST_ENGINE1.name, + searchString: "x", + healthReportKey: "test", + searchPurpose: "test", + originalEvent: modifiers, + }; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + // Test typing a query, then selecting a suggestion and pressing enter. + p = waitForSearch(); + await msg("key", { key: "x", waitForSuggestions: true }); + await msg("key", "VK_DOWN"); + await msg("key", "VK_DOWN"); + await msg("key", { key: "VK_RETURN", modifiers }); + mesg = await p; + eventData.searchString = "xfoo"; + eventData.engineName = TEST_ENGINE1.name; + eventData.selection = { + index: 1, + kind: "key", + }; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + // Test typing a query, then selecting a one-off button and pressing enter. + p = waitForSearch(); + await msg("key", { key: "x", waitForSuggestions: true }); + await msg("key", "VK_UP"); + await msg("key", "VK_UP"); + await msg("key", { key: "VK_RETURN", modifiers }); + mesg = await p; + delete eventData.selection; + eventData.searchString = "x"; + eventData.engineName = TEST_ENGINE2.name; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + // Test typing a query and clicking the search engine header. + p = waitForSearch(); + modifiers.button = 0; + await msg("key", { key: "x", waitForSuggestions: true }); + await msg("mousemove", -1); + await msg("click", { eltIdx: -1, modifiers }); + mesg = await p; + eventData.originalEvent = modifiers; + eventData.engineName = TEST_ENGINE1.name; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + // Test typing a query and then clicking a suggestion. + await msg("key", { key: "x", waitForSuggestions: true }); + p = waitForSearch(); + await msg("mousemove", 1); + await msg("click", { eltIdx: 1, modifiers }); + mesg = await p; + eventData.searchString = "xfoo"; + eventData.selection = { + index: 1, + kind: "mouse", + }; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + // Test typing a query and then clicking a one-off button. + await msg("key", { key: "x", waitForSuggestions: true }); + p = waitForSearch(); + await msg("mousemove", 3); + await msg("click", { eltIdx: 3, modifiers }); + mesg = await p; + eventData.searchString = "x"; + eventData.engineName = TEST_ENGINE2.name; + delete eventData.selection; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + // Test selecting a suggestion, then clicking a one-off without deselecting the + // suggestion, using the keyboard. + delete modifiers.button; + await msg("key", { key: "x", waitForSuggestions: true }); + p = waitForSearch(); + await msg("key", "VK_DOWN"); + await msg("key", "VK_DOWN"); + await msg("key", "VK_TAB"); + await msg("key", { key: "VK_RETURN", modifiers }); + mesg = await p; + eventData.searchString = "xfoo"; + eventData.selection = { + index: 1, + kind: "key", + }; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + // Test searching when using IME composition. + let state = await msg("startComposition", { data: "" }); + checkState(state, "", [], -1); + state = await msg("changeComposition", { + data: "x", + waitForSuggestions: true, + }); + checkState( + state, + "x", + [ + { str: "x", type: "formHistory" }, + { str: "xfoo", type: "formHistory" }, + "xbar", + ], + -1 + ); + await msg("commitComposition"); + delete modifiers.button; + p = waitForSearch(); + await msg("key", { key: "VK_RETURN", modifiers }); + mesg = await p; + eventData.searchString = "x"; + eventData.originalEvent = modifiers; + eventData.engineName = TEST_ENGINE1.name; + delete eventData.selection; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + state = await msg("startComposition", { data: "" }); + checkState(state, "", [], -1); + state = await msg("changeComposition", { + data: "x", + waitForSuggestions: true, + }); + checkState( + state, + "x", + [ + { str: "x", type: "formHistory" }, + { str: "xfoo", type: "formHistory" }, + "xbar", + ], + -1 + ); + + // Mouse over the first suggestion. + state = await msg("mousemove", 0); + checkState( + state, + "x", + [ + { str: "x", type: "formHistory" }, + { str: "xfoo", type: "formHistory" }, + "xbar", + ], + 0 + ); + + // Mouse over the second suggestion. + state = await msg("mousemove", 1); + checkState( + state, + "x", + [ + { str: "x", type: "formHistory" }, + { str: "xfoo", type: "formHistory" }, + "xbar", + ], + 1 + ); + + modifiers.button = 0; + p = waitForSearch(); + await msg("click", { eltIdx: 1, modifiers }); + mesg = await p; + eventData.searchString = "xfoo"; + eventData.originalEvent = modifiers; + eventData.selection = { + index: 1, + kind: "mouse", + }; + SimpleTest.isDeeply(eventData, mesg, "Search event data"); + + await promiseTab(); + await focusContentSearchBar(); + + // Remove form history entries. + // Wait for Satchel. + let observePromise = new Promise(resolve => { + let historyCount = 2; + Services.obs.addObserver(function onRemove(subj, topic, data) { + if (data == "formhistory-remove") { + if (--historyCount) { + return; + } + Services.obs.removeObserver(onRemove, "satchel-storage-changed"); + executeSoon(resolve); + } + }, "satchel-storage-changed"); + }); + + await msg("key", { key: "x", waitForSuggestions: true }); + await msg("key", "VK_DOWN"); + await msg("key", "VK_DOWN"); + await msg("key", "VK_DELETE"); + await msg("key", "VK_DOWN"); + await msg("key", "VK_DELETE"); + await observePromise; + + await msg("reset"); + state = await msg("key", { key: "x", waitForSuggestions: true }); + checkState(state, "x", ["xfoo", "xbar"], -1); + + await promiseTab(); + await focusContentSearchBar(); + await msg("reset"); +}); + +add_task(async function settings() { + await focusContentSearchBar(); + await msg("key", { key: "VK_DOWN", waitForSuggestions: true }); + await msg("key", "VK_UP"); + let p = waitForSearchSettings(); + await msg("key", "VK_RETURN"); + await p; + + await msg("reset"); +}); + +add_task(async function cleanup() { + Services.search.restoreDefaultEngines(); +}); + +function checkState( + actualState, + expectedInputVal, + expectedSuggestions, + expectedSelectedIdx, + expectedSelectedButtonIdx +) { + expectedSuggestions = expectedSuggestions.map(sugg => { + return typeof sugg == "object" + ? sugg + : { + str: sugg, + type: "remote", + }; + }); + + if (expectedSelectedIdx == -1 && expectedSelectedButtonIdx != undefined) { + expectedSelectedIdx = + expectedSuggestions.length + expectedSelectedButtonIdx; + } + + let expectedState = { + selectedIndex: expectedSelectedIdx, + numSuggestions: expectedSuggestions.length, + suggestionAtIndex: expectedSuggestions.map(s => s.str), + isFormHistorySuggestionAtIndex: expectedSuggestions.map( + s => s.type == "formHistory" + ), + + tableHidden: !expectedSuggestions.length, + + inputValue: expectedInputVal, + ariaExpanded: !expectedSuggestions.length ? "false" : "true", + }; + if (expectedSelectedButtonIdx != undefined) { + expectedState.selectedButtonIndex = expectedSelectedButtonIdx; + } else if (expectedSelectedIdx < expectedSuggestions.length) { + expectedState.selectedButtonIndex = -1; + } else { + expectedState.selectedButtonIndex = + expectedSelectedIdx - expectedSuggestions.length; + } + + SimpleTest.isDeeply(actualState, expectedState, "State"); +} + +var gMsgMan; + +async function promiseTab() { + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + registerCleanupFunction(() => BrowserTestUtils.removeTab(tab)); + + let loadedPromise = BrowserTestUtils.firstBrowserLoaded(window); + openTrustedLinkIn("about:test-about-content-search-ui", "current"); + await loadedPromise; +} diff --git a/browser/components/search/test/browser/browser_contentSearchUI_default.js b/browser/components/search/test/browser/browser_contentSearchUI_default.js new file mode 100644 index 0000000000..c69326262a --- /dev/null +++ b/browser/components/search/test/browser/browser_contentSearchUI_default.js @@ -0,0 +1,210 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +const TEST_ENGINE_NAME = "searchSuggestionEngine"; +const HANDOFF_PREF = + "browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar"; + +let extension; +let defaultEngine; +let addedEngine; + +add_setup(async function () { + // Disable window occlusion. Bug 1733955 + if (navigator.platform.indexOf("Win") == 0) { + await SpecialPowers.pushPrefEnv({ + set: [["widget.windows.window_occlusion_tracking.enabled", false]], + }); + } + + defaultEngine = await Services.search.getDefault(); + + extension = await SearchTestUtils.installSearchExtension({ + id: TEST_ENGINE_NAME, + name: TEST_ENGINE_NAME, + suggest_url: + "https://example.com/browser/browser/components/search/test/browser/searchSuggestionEngine.sjs", + suggest_url_get_params: "query={searchTerms}", + }); + + addedEngine = await Services.search.getEngineByName(TEST_ENGINE_NAME); + + // Enable suggestions in this test. Otherwise, the string in the content + // search box changes. + await SpecialPowers.pushPrefEnv({ + set: [["browser.urlbar.suggest.searches", true]], + }); + + registerCleanupFunction(async () => { + await Services.search.setDefault( + defaultEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + }); +}); + +async function ensureIcon(tab, expectedIcon) { + await SpecialPowers.spawn( + tab.linkedBrowser, + [expectedIcon], + async function (icon) { + await ContentTaskUtils.waitForCondition(() => !content.document.hidden); + + let computedStyle = content.window.getComputedStyle( + content.document.body + ); + await ContentTaskUtils.waitForCondition( + () => computedStyle.getPropertyValue("--newtab-search-icon") != "null", + "Search Icon not set." + ); + + Assert.equal( + computedStyle.getPropertyValue("--newtab-search-icon"), + `url(${icon})`, + "Should have the expected icon" + ); + } + ); +} + +async function ensurePlaceholder(tab, expectedId, expectedEngine) { + await SpecialPowers.spawn( + tab.linkedBrowser, + [expectedId, expectedEngine], + async function (id, engine) { + await ContentTaskUtils.waitForCondition(() => !content.document.hidden); + + await ContentTaskUtils.waitForCondition( + () => content.document.querySelector(".search-handoff-button"), + "l10n ID not set." + ); + let buttonNode = content.document.querySelector(".search-handoff-button"); + let expectedAttributes = { id, args: engine ? { engine } : null }; + Assert.deepEqual( + content.document.l10n.getAttributes(buttonNode), + expectedAttributes, + "Expected updated l10n ID and args." + ); + } + ); +} + +async function runNewTabTest(isHandoff) { + let tab = await BrowserTestUtils.openNewForegroundTab({ + url: "about:newtab", + gBrowser, + waitForLoad: false, + }); + + let engineIcon = defaultEngine.getIconURLBySize(16, 16); + + await ensureIcon(tab, engineIcon); + if (isHandoff) { + await ensurePlaceholder( + tab, + "newtab-search-box-handoff-input", + Services.search.defaultEngine.name + ); + } + + await Services.search.setDefault( + addedEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + // We only show the engine's own icon for app provided engines, otherwise show + // a default. xref https://bugzilla.mozilla.org/show_bug.cgi?id=1449338#c19 + await ensureIcon(tab, "chrome://global/skin/icons/search-glass.svg"); + if (isHandoff) { + await ensurePlaceholder(tab, "newtab-search-box-handoff-input-no-engine"); + } + + // Disable suggestions in the Urlbar. This should update the placeholder + // string since handoff will now enter search mode. + if (isHandoff) { + await SpecialPowers.pushPrefEnv({ + set: [["browser.urlbar.suggest.searches", false]], + }); + await ensurePlaceholder(tab, "newtab-search-box-input"); + await SpecialPowers.popPrefEnv(); + } + + await Services.search.setDefault( + defaultEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + BrowserTestUtils.removeTab(tab); +} + +add_task(async function test_content_search_attributes() { + await SpecialPowers.pushPrefEnv({ + set: [[HANDOFF_PREF, true]], + }); + + await runNewTabTest(true); + await SpecialPowers.popPrefEnv(); +}); + +add_task(async function test_content_search_attributes_no_handoff() { + await SpecialPowers.pushPrefEnv({ + set: [[HANDOFF_PREF, false]], + }); + + await runNewTabTest(false); + await SpecialPowers.popPrefEnv(); +}); + +add_task(async function test_content_search_attributes_in_private_window() { + let win = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + waitForTabURL: "about:privatebrowsing", + }); + let tab = win.gBrowser.selectedTab; + + let engineIcon = defaultEngine.getIconURLBySize(16, 16); + + await ensureIcon(tab, engineIcon); + await ensurePlaceholder( + tab, + "about-private-browsing-handoff", + Services.search.defaultEngine.name + ); + + await Services.search.setDefault( + addedEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + // We only show the engine's own icon for app provided engines, otherwise show + // a default. xref https://bugzilla.mozilla.org/show_bug.cgi?id=1449338#c19 + await ensureIcon(tab, "chrome://global/skin/icons/search-glass.svg"); + await ensurePlaceholder(tab, "about-private-browsing-handoff-no-engine"); + + await SpecialPowers.pushPrefEnv({ + set: [["browser.urlbar.suggest.searches", false]], + }); + await ensurePlaceholder(tab, "about-private-browsing-search-btn"); + await SpecialPowers.popPrefEnv(); + + await Services.search.setDefault( + defaultEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + await BrowserTestUtils.closeWindow(win); +}); + +add_task(async function test_content_search_permanent_private_browsing() { + await SpecialPowers.pushPrefEnv({ + set: [ + [HANDOFF_PREF, true], + ["browser.privatebrowsing.autostart", true], + ], + }); + + let win = await BrowserTestUtils.openNewBrowserWindow(); + await runNewTabTest(true); + await BrowserTestUtils.closeWindow(win); + await SpecialPowers.popPrefEnv(); +}); diff --git a/browser/components/search/test/browser/browser_contextSearchTabPosition.js b/browser/components/search/test/browser/browser_contextSearchTabPosition.js new file mode 100644 index 0000000000..345167c5b8 --- /dev/null +++ b/browser/components/search/test/browser/browser_contextSearchTabPosition.js @@ -0,0 +1,94 @@ +/* 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/. */ + +let engine; + +add_setup(async function () { + engine = await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine.xml", + setAsDefault: true, + }); +}); + +add_task(async function test() { + let histogramKey = "other-" + engine.name + ".contextmenu"; + let numSearchesBefore = 0; + + try { + let hs = Services.telemetry + .getKeyedHistogramById("SEARCH_COUNTS") + .snapshot(); + if (histogramKey in hs) { + numSearchesBefore = hs[histogramKey].sum; + } + } catch (ex) { + // No searches performed yet, not a problem, |numSearchesBefore| is 0. + } + + let tabs = []; + let tabsLoadedDeferred = new Deferred(); + + function tabAdded(event) { + let tab = event.target; + tabs.push(tab); + + // We wait for the blank tab and the two context searches tabs to open. + if (tabs.length == 3) { + tabsLoadedDeferred.resolve(); + } + } + + let container = gBrowser.tabContainer; + container.addEventListener("TabOpen", tabAdded); + + BrowserTestUtils.addTab(gBrowser, "about:blank"); + BrowserSearch.loadSearchFromContext( + "mozilla", + false, + Services.scriptSecurityManager.getSystemPrincipal(), + Services.scriptSecurityManager.getSystemPrincipal().csp, + new MouseEvent("click") + ); + BrowserSearch.loadSearchFromContext( + "firefox", + false, + Services.scriptSecurityManager.getSystemPrincipal(), + Services.scriptSecurityManager.getSystemPrincipal().csp, + new MouseEvent("click") + ); + + // Wait for all the tabs to open. + await tabsLoadedDeferred.promise; + + is(tabs[0], gBrowser.tabs[3], "blank tab has been pushed to the end"); + is( + tabs[1], + gBrowser.tabs[1], + "first search tab opens next to the current tab" + ); + is( + tabs[2], + gBrowser.tabs[2], + "second search tab opens next to the first search tab" + ); + + container.removeEventListener("TabOpen", tabAdded); + tabs.forEach(gBrowser.removeTab, gBrowser); + + // Make sure that the context searches are correctly recorded in telemetry. + // Telemetry is not updated synchronously here, we must wait for it. + await TestUtils.waitForCondition(() => { + let hs = Services.telemetry + .getKeyedHistogramById("SEARCH_COUNTS") + .snapshot(); + return histogramKey in hs && hs[histogramKey].sum == numSearchesBefore + 2; + }, "The histogram must contain the correct search count"); +}); + +function Deferred() { + this.promise = new Promise((resolve, reject) => { + this.resolve = resolve; + this.reject = reject; + }); +} diff --git a/browser/components/search/test/browser/browser_contextmenu.js b/browser/components/search/test/browser/browser_contextmenu.js new file mode 100644 index 0000000000..67ba48da72 --- /dev/null +++ b/browser/components/search/test/browser/browser_contextmenu.js @@ -0,0 +1,249 @@ +/* Any copyright is dedicated to the Public Domain. + * * http://creativecommons.org/publicdomain/zero/1.0/ */ +/* + * Test searching for the selected text using the context menu + */ + +const { AddonTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/AddonTestUtils.sys.mjs" +); + +AddonTestUtils.initMochitest(this); + +const ENGINE_NAME = "mozSearch"; +const PRIVATE_ENGINE_NAME = "mozPrivateSearch"; +const ENGINE_DATA = new Map([ + [ + ENGINE_NAME, + "https://example.com/browser/browser/components/search/test/browser/mozsearch.sjs", + ], + [PRIVATE_ENGINE_NAME, "https://example.com:443/browser/"], +]); + +let engine; +let privateEngine; +let extensions = []; +let oldDefaultEngine; +let oldDefaultPrivateEngine; + +add_setup(async function () { + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.separatePrivateDefault", true], + ["browser.search.separatePrivateDefault.ui.enabled", true], + ], + }); + + await Services.search.init(); + + for (let [name, search_url] of ENGINE_DATA) { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + chrome_settings_overrides: { + search_provider: { + name, + search_url, + params: [ + { + name: "test", + value: "{searchTerms}", + }, + ], + }, + }, + }, + }); + + await extension.startup(); + await AddonTestUtils.waitForSearchProviderStartup(extension); + extensions.push(extension); + } + + engine = await Services.search.getEngineByName(ENGINE_NAME); + Assert.ok(engine, "Got a search engine"); + oldDefaultEngine = await Services.search.getDefault(); + await Services.search.setDefault( + engine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + privateEngine = await Services.search.getEngineByName(PRIVATE_ENGINE_NAME); + Assert.ok(privateEngine, "Got a search engine"); + oldDefaultPrivateEngine = await Services.search.getDefaultPrivate(); + await Services.search.setDefaultPrivate( + privateEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); +}); + +async function checkContextMenu( + win, + expectedName, + expectedBaseUrl, + expectedPrivateName +) { + let contextMenu = win.document.getElementById("contentAreaContextMenu"); + Assert.ok(contextMenu, "Got context menu XUL"); + + let tab = await BrowserTestUtils.openNewForegroundTab( + win.gBrowser, + "https://example.com/browser/browser/components/search/test/browser/test_search.html" + ); + + await SpecialPowers.spawn(tab.linkedBrowser, [""], async function () { + return new Promise(resolve => { + content.document.addEventListener( + "selectionchange", + function () { + resolve(); + }, + { once: true } + ); + content.document.getSelection().selectAllChildren(content.document.body); + }); + }); + + let eventDetails = { type: "contextmenu", button: 2 }; + + let popupPromise = BrowserTestUtils.waitForEvent(contextMenu, "popupshown"); + BrowserTestUtils.synthesizeMouseAtCenter( + "body", + eventDetails, + win.gBrowser.selectedBrowser + ); + await popupPromise; + + info("checkContextMenu"); + let searchItem = contextMenu.getElementsByAttribute( + "id", + "context-searchselect" + )[0]; + Assert.ok(searchItem, "Got search context menu item"); + Assert.equal( + searchItem.label, + "Search " + expectedName + " for \u201ctest%20search\u201d", + "Check context menu label" + ); + Assert.equal( + searchItem.disabled, + false, + "Check that search context menu item is enabled" + ); + + let loaded = BrowserTestUtils.waitForNewTab( + win.gBrowser, + expectedBaseUrl + "?test=test%2520search", + true + ); + contextMenu.activateItem(searchItem); + let searchTab = await loaded; + let browser = win.gBrowser.selectedBrowser; + await SpecialPowers.spawn(browser, [], async function () { + Assert.ok( + !/error/.test(content.document.body.innerHTML), + "Ensure there were no errors loading the search page" + ); + }); + + searchItem = contextMenu.getElementsByAttribute( + "id", + "context-searchselect-private" + )[0]; + Assert.ok(searchItem, "Got search in private window context menu item"); + if (PrivateBrowsingUtils.isWindowPrivate(win)) { + Assert.ok(searchItem.hidden, "Search in private window should be hidden"); + } else { + let expectedLabel = expectedPrivateName + ? "Search with " + expectedPrivateName + " in a Private Window" + : "Search in a Private Window"; + Assert.equal(searchItem.label, expectedLabel, "Check context menu label"); + Assert.equal( + searchItem.disabled, + false, + "Check that search context menu item is enabled" + ); + } + + contextMenu.hidePopup(); + + BrowserTestUtils.removeTab(searchTab); + BrowserTestUtils.removeTab(tab); +} + +add_task(async function test_normalWindow() { + await checkContextMenu( + window, + ENGINE_NAME, + "https://example.com/browser/browser/components/search/test/browser/mozsearch.sjs", + PRIVATE_ENGINE_NAME + ); +}); + +add_task(async function test_privateWindow() { + const win = await BrowserTestUtils.openNewBrowserWindow({ private: true }); + + registerCleanupFunction(async () => { + await BrowserTestUtils.closeWindow(win); + }); + + await checkContextMenu( + win, + PRIVATE_ENGINE_NAME, + "https://example.com/browser/" + ); +}); + +add_task(async function test_normalWindow_sameDefaults() { + // Set the private default engine to be the same as the current default engine + // in 'normal' mode. + await Services.search.setDefaultPrivate( + await Services.search.getDefault(), + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + await checkContextMenu( + window, + ENGINE_NAME, + "https://example.com/browser/browser/components/search/test/browser/mozsearch.sjs" + ); +}); + +add_task(async function test_privateWindow_no_separate_engine() { + await SpecialPowers.pushPrefEnv({ + set: [ + // We want select events to be fired. + ["browser.search.separatePrivateDefault", false], + ], + }); + + const win = await BrowserTestUtils.openNewBrowserWindow({ private: true }); + + registerCleanupFunction(async () => { + await BrowserTestUtils.closeWindow(win); + }); + + await checkContextMenu( + win, + ENGINE_NAME, + "https://example.com/browser/browser/components/search/test/browser/mozsearch.sjs" + ); +}); + +// We can't do the unload within registerCleanupFunction as that's too late for +// the test to be happy. Do it into a cleanup "test" here instead. +add_task(async function cleanup() { + await Services.search.setDefault( + oldDefaultEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + await Services.search.setDefaultPrivate( + oldDefaultPrivateEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + await Services.search.removeEngine(engine); + await Services.search.removeEngine(privateEngine); + + for (let extension of extensions) { + await extension.unload(); + } +}); diff --git a/browser/components/search/test/browser/browser_contextmenu_whereToOpenLink.js b/browser/components/search/test/browser/browser_contextmenu_whereToOpenLink.js new file mode 100644 index 0000000000..ed3fd6901d --- /dev/null +++ b/browser/components/search/test/browser/browser_contextmenu_whereToOpenLink.js @@ -0,0 +1,183 @@ +/* Any copyright is dedicated to the Public Domain. + * * http://creativecommons.org/publicdomain/zero/1.0/ */ +/* + * Test searching for the selected text using the context menu + */ + +const { SearchTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SearchTestUtils.sys.mjs" +); + +SearchTestUtils.init(this); + +const ENGINE_NAME = "mozSearch"; +const ENGINE_URL = + "https://example.com/browser/browser/components/search/test/browser/mozsearch.sjs"; + +add_setup(async function () { + await Services.search.init(); + + await SearchTestUtils.installSearchExtension( + { + name: ENGINE_NAME, + search_url: ENGINE_URL, + search_url_get_params: "test={searchTerms}", + }, + { setAsDefault: true } + ); +}); + +async function openNewSearchTab(event_args, expect_new_window = false) { + // open context menu with right click + let contextMenu = document.getElementById("contentAreaContextMenu"); + + let popupPromise = BrowserTestUtils.waitForEvent(contextMenu, "popupshown"); + BrowserTestUtils.synthesizeMouseAtCenter( + "body", + { type: "contextmenu", button: 2 }, + gBrowser.selectedBrowser + ); + await popupPromise; + + let searchItem = contextMenu.getElementsByAttribute( + "id", + "context-searchselect" + )[0]; + + // open new search tab with desired modifiers + let searchTabPromise; + if (expect_new_window) { + searchTabPromise = BrowserTestUtils.waitForNewWindow({ + url: ENGINE_URL + "?test=test%2520search", + }); + } else { + searchTabPromise = BrowserTestUtils.waitForNewTab( + gBrowser, + ENGINE_URL + "?test=test%2520search", + true + ); + } + + if ("button" in event_args) { + // Bug 1704879: activateItem does not currently support button + EventUtils.synthesizeMouseAtCenter(searchItem, event_args); + } else { + contextMenu.activateItem(searchItem, event_args); + } + + if (expect_new_window) { + let win = await searchTabPromise; + return win.gBrowser.selectedTab; + } + return searchTabPromise; +} + +add_task(async function test_whereToOpenLink() { + // open search test page and select search text + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "https://example.com/browser/browser/components/search/test/browser/test_search.html" + ); + + await SpecialPowers.spawn(tab.linkedBrowser, [""], async function () { + return new Promise(resolve => { + content.document.addEventListener( + "selectionchange", + function () { + resolve(); + }, + { once: true } + ); + content.document.getSelection().selectAllChildren(content.document.body); + }); + }); + + // check where context search opens for different buttons/modifiers + let searchTab = await openNewSearchTab({}); + is( + searchTab, + gBrowser.selectedTab, + "Search tab is opened in foreground (no modifiers)" + ); + BrowserTestUtils.removeTab(searchTab); + + // TODO bug 1704883: Re-enable this subtest. Native context menus on macOS do + // not yet support alternate mouse buttons. + if ( + !AppConstants.platform == "macosx" || + !Services.prefs.getBoolPref("widget.macos.native-context-menus", false) + ) { + searchTab = await openNewSearchTab({ button: 1 }); + isnot( + searchTab, + gBrowser.selectedTab, + "Search tab is opened in background (middle mouse)" + ); + BrowserTestUtils.removeTab(searchTab); + } + + searchTab = await openNewSearchTab({ ctrlKey: true }); + isnot( + searchTab, + gBrowser.selectedTab, + "Search tab is opened in background (Ctrl)" + ); + BrowserTestUtils.removeTab(searchTab); + + let current_browser = gBrowser.selectedBrowser; + searchTab = await openNewSearchTab({ shiftKey: true }, true); + isnot( + current_browser, + gBrowser.getBrowserForTab(searchTab), + "Search tab is opened in new window (Shift)" + ); + BrowserTestUtils.removeTab(searchTab); + + info("flipping browser.search.context.loadInBackground and re-checking"); + await SpecialPowers.pushPrefEnv({ + set: [["browser.search.context.loadInBackground", true]], + }); + + searchTab = await openNewSearchTab({}); + isnot( + searchTab, + gBrowser.selectedTab, + "Search tab is opened in background (no modifiers)" + ); + BrowserTestUtils.removeTab(searchTab); + + // TODO bug 1704883: Re-enable this subtest. Native context menus on macOS do + // not yet support alternate mouse buttons. + if ( + !AppConstants.platform == "macosx" || + !Services.prefs.getBoolPref("widget.macos.native-context-menus", false) + ) { + searchTab = await openNewSearchTab({ button: 1 }); + is( + searchTab, + gBrowser.selectedTab, + "Search tab is opened in foreground (middle mouse)" + ); + BrowserTestUtils.removeTab(searchTab); + } + + searchTab = await openNewSearchTab({ ctrlKey: true }); + is( + searchTab, + gBrowser.selectedTab, + "Search tab is opened in foreground (Ctrl)" + ); + BrowserTestUtils.removeTab(searchTab); + + current_browser = gBrowser.selectedBrowser; + searchTab = await openNewSearchTab({ shiftKey: true }, true); + isnot( + current_browser, + gBrowser.getBrowserForTab(searchTab), + "Search tab is opened in new window (Shift)" + ); + BrowserTestUtils.removeTab(searchTab); + + // cleanup + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_defaultPrivate_nimbus.js b/browser/components/search/test/browser/browser_defaultPrivate_nimbus.js new file mode 100644 index 0000000000..ce5acc91a0 --- /dev/null +++ b/browser/components/search/test/browser/browser_defaultPrivate_nimbus.js @@ -0,0 +1,155 @@ +/* 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 { ExperimentAPI } = ChromeUtils.importESModule( + "resource://nimbus/ExperimentAPI.sys.mjs" +); +const { ExperimentFakes } = ChromeUtils.importESModule( + "resource://testing-common/NimbusTestUtils.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + SearchTestUtils: "resource://testing-common/SearchTestUtils.sys.mjs", +}); + +const CONFIG_DEFAULT = [ + { + webExtension: { id: "basic@search.mozilla.org" }, + appliesTo: [{ included: { everywhere: true } }], + default: "yes", + }, + { + webExtension: { id: "private@search.mozilla.org" }, + appliesTo: [ + { + experiment: "testing", + included: { everywhere: true }, + }, + ], + defaultPrivate: "yes", + }, +]; + +SearchTestUtils.init(this); + +add_setup(async () => { + // Use engines in test directory + let searchExtensions = getChromeDir(getResolvedURI(gTestPath)); + searchExtensions.append("search-engines"); + await SearchTestUtils.useMochitestEngines(searchExtensions); + + // Current default values. + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.separatePrivateDefault.ui.enabled", false], + ["browser.search.separatePrivateDefault.urlbarResult.enabled", false], + ["browser.search.separatePrivateDefault", true], + ["browser.urlbar.suggest.searches", true], + ], + }); + + SearchTestUtils.useMockIdleService(); + await SearchTestUtils.updateRemoteSettingsConfig(CONFIG_DEFAULT); + + registerCleanupFunction(async () => { + let settingsWritten = SearchTestUtils.promiseSearchNotification( + "write-settings-to-disk-complete" + ); + await SearchTestUtils.updateRemoteSettingsConfig(); + await settingsWritten; + }); +}); + +add_task(async function test_nimbus_experiment() { + Assert.equal( + Services.search.defaultPrivateEngine.name, + "basic", + "Should have basic as private default while not in experiment" + ); + await ExperimentAPI.ready(); + + let reloadObserved = + SearchTestUtils.promiseSearchNotification("engines-reloaded"); + + let doExperimentCleanup = await ExperimentFakes.enrollWithFeatureConfig({ + featureId: "searchConfiguration", + value: { + seperatePrivateDefaultUIEnabled: true, + seperatePrivateDefaultUrlbarResultEnabled: false, + experiment: "testing", + }, + }); + await reloadObserved; + Assert.equal( + Services.search.defaultPrivateEngine.name, + "private", + "Should have private as private default while in experiment" + ); + reloadObserved = + SearchTestUtils.promiseSearchNotification("engines-reloaded"); + await doExperimentCleanup(); + await reloadObserved; + Assert.equal( + Services.search.defaultPrivateEngine.name, + "basic", + "Should turn off private default and restore default engine after experiment" + ); +}); + +add_task(async function test_nimbus_experiment_urlbar_result_enabled() { + Assert.equal( + Services.search.defaultPrivateEngine.name, + "basic", + "Should have basic as private default while not in experiment" + ); + await ExperimentAPI.ready(); + + let reloadObserved = + SearchTestUtils.promiseSearchNotification("engines-reloaded"); + + let doExperimentCleanup = await ExperimentFakes.enrollWithFeatureConfig({ + featureId: "searchConfiguration", + value: { + seperatePrivateDefaultUIEnabled: true, + seperatePrivateDefaultUrlbarResultEnabled: true, + experiment: "testing", + }, + }); + await reloadObserved; + Assert.equal( + Services.search.separatePrivateDefaultUrlbarResultEnabled, + true, + "Should have set the urlbar result enabled value to true" + ); + reloadObserved = + SearchTestUtils.promiseSearchNotification("engines-reloaded"); + await doExperimentCleanup(); + await reloadObserved; + Assert.equal( + Services.search.defaultPrivateEngine.name, + "basic", + "Should turn off private default and restore default engine after experiment" + ); +}); + +add_task(async function test_non_experiment_prefs() { + await SpecialPowers.pushPrefEnv({ + set: [["browser.search.separatePrivateDefault.ui.enabled", false]], + }); + let uiPref = () => + Services.prefs.getBoolPref( + "browser.search.separatePrivateDefault.ui.enabled" + ); + Assert.equal(uiPref(), false, "defaulted false"); + await ExperimentAPI.ready(); + let doExperimentCleanup = await ExperimentFakes.enrollWithFeatureConfig({ + featureId: "privatesearch", + value: { + seperatePrivateDefaultUIEnabled: true, + }, + }); + Assert.equal(uiPref(), false, "Pref did not change without experiment"); + await doExperimentCleanup(); + await SpecialPowers.popPrefEnv(); +}); diff --git a/browser/components/search/test/browser/browser_google_behavior.js b/browser/components/search/test/browser/browser_google_behavior.js new file mode 100644 index 0000000000..1d58ac77ee --- /dev/null +++ b/browser/components/search/test/browser/browser_google_behavior.js @@ -0,0 +1,215 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Test Google search plugin URLs + * TODO: This test is a near duplicate of browser_searchEngine_behaviors.js but + * specific to Google. This is required due to bug 1315953. + * + * Note: Although we have tests for codes in + * toolkit/components/tests/xpcshell/searchconfigs, we also need this test as an + * integration test to check the search service to selector integration is + * working correctly (especially the ESR codes). + */ + +"use strict"; + +let searchEngineDetails = [ + { + alias: "g", + codes: { + context: "", + keyword: "", + newTab: "", + submission: "", + }, + name: "Google", + }, +]; + +let region = Services.prefs.getCharPref("browser.search.region"); +let code = ""; +switch (region) { + case "US": + if (SearchUtils.MODIFIED_APP_CHANNEL == "esr") { + code = "firefox-b-1-e"; + } else { + code = "firefox-b-1-d"; + } + break; + case "DE": + if (SearchUtils.MODIFIED_APP_CHANNEL == "esr") { + code = "firefox-b-e"; + } else { + code = "firefox-b-d"; + } + break; +} + +if (code) { + let codes = searchEngineDetails[0].codes; + codes.context = code; + codes.newTab = code; + codes.submission = code; + codes.keyword = code; +} + +function promiseContentSearchReady(browser) { + return SpecialPowers.spawn(browser, [], async function (args) { + return new Promise(resolve => { + SpecialPowers.pushPrefEnv({ + set: [ + [ + "browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar", + false, + ], + ], + }); + if (content.wrappedJSObject.gContentSearchController) { + let searchController = content.wrappedJSObject.gContentSearchController; + if (searchController.defaultEngine) { + resolve(); + } + } + + content.addEventListener( + "ContentSearchService", + function listener(aEvent) { + if (aEvent.detail.type == "State") { + content.removeEventListener("ContentSearchService", listener); + resolve(); + } + } + ); + }); + }); +} + +add_setup(async function () { + await Services.search.init(); +}); + +for (let engine of searchEngineDetails) { + add_task(async function () { + let previouslySelectedEngine = Services.search.defaultEngine; + + registerCleanupFunction(function () { + Services.search.defaultEngine = previouslySelectedEngine; + }); + + await testSearchEngine(engine); + }); +} + +async function testSearchEngine(engineDetails) { + let engine = Services.search.getEngineByName(engineDetails.name); + Assert.ok(engine, `${engineDetails.name} is installed`); + + Services.search.defaultEngine = engine; + engine.alias = engineDetails.alias; + + // Test search URLs (including purposes). + let url = engine.getSubmission("foo").uri.spec; + let urlParams = new URLSearchParams(url.split("?")[1]); + Assert.equal(urlParams.get("q"), "foo", "Check search URL for 'foo'"); + + let engineTests = [ + { + name: "context menu search", + code: engineDetails.codes.context, + run() { + // Simulate a contextmenu search + // FIXME: This is a bit "low-level"... + BrowserSearch._loadSearch( + "foo", + false, + false, + "contextmenu", + Services.scriptSecurityManager.getSystemPrincipal() + ); + }, + }, + { + name: "keyword search", + code: engineDetails.codes.keyword, + run() { + gURLBar.value = "? foo"; + gURLBar.focus(); + EventUtils.synthesizeKey("KEY_Enter"); + }, + }, + { + name: "keyword search with alias", + code: engineDetails.codes.keyword, + run() { + gURLBar.value = `${engineDetails.alias} foo`; + gURLBar.focus(); + EventUtils.synthesizeKey("KEY_Enter"); + }, + }, + { + name: "search bar search", + code: engineDetails.codes.submission, + async preTest() { + await gCUITestUtils.addSearchBar(); + }, + run() { + let sb = BrowserSearch.searchBar; + sb.focus(); + sb.value = "foo"; + EventUtils.synthesizeKey("KEY_Enter"); + }, + postTest() { + BrowserSearch.searchBar.value = ""; + gCUITestUtils.removeSearchBar(); + }, + }, + { + name: "new tab search", + code: engineDetails.codes.newTab, + async preTest(tab) { + let browser = tab.linkedBrowser; + BrowserTestUtils.loadURIString(browser, "about:newtab"); + await BrowserTestUtils.browserLoaded(browser, false, "about:newtab"); + + await promiseContentSearchReady(browser); + }, + async run(tab) { + await SpecialPowers.spawn(tab.linkedBrowser, [], async function (args) { + let input = content.document.querySelector("input[id*=search-]"); + input.focus(); + input.value = "foo"; + }); + EventUtils.synthesizeKey("KEY_Enter"); + }, + }, + ]; + + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + for (let test of engineTests) { + info(`Running: ${test.name}`); + + if (test.preTest) { + await test.preTest(tab); + } + + let googleUrl = + "https://www.google.com/search?client=" + test.code + "&q=foo"; + let promises = [ + BrowserTestUtils.waitForDocLoadAndStopIt(googleUrl, tab), + BrowserTestUtils.browserStopped(tab.linkedBrowser, googleUrl, true), + ]; + + await test.run(tab); + + await Promise.all(promises); + + if (test.postTest) { + await test.postTest(tab); + } + } + + engine.alias = undefined; + BrowserTestUtils.removeTab(tab); +} diff --git a/browser/components/search/test/browser/browser_hiddenOneOffs_cleanup.js b/browser/components/search/test/browser/browser_hiddenOneOffs_cleanup.js new file mode 100644 index 0000000000..8be90b3288 --- /dev/null +++ b/browser/components/search/test/browser/browser_hiddenOneOffs_cleanup.js @@ -0,0 +1,117 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +const testPref = "Foo,FooDupe"; + +registerCleanupFunction(() => { + Services.prefs.clearUserPref("browser.search.hiddenOneOffs"); +}); + +add_task(async function test_remove() { + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine_dupe.xml", + }); + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine.xml", + }); + Services.prefs.setCharPref("browser.search.hiddenOneOffs", testPref); + + info("Removing testEngine_dupe.xml"); + await Services.search.removeEngine( + Services.search.getEngineByName("FooDupe") + ); + + let hiddenOneOffs = Services.prefs + .getCharPref("browser.search.hiddenOneOffs") + .split(","); + + is( + hiddenOneOffs.length, + 1, + "hiddenOneOffs has the correct engine count post removal." + ); + is( + hiddenOneOffs.some(x => x == "FooDupe"), + false, + "Removed Engine is not in hiddenOneOffs after removal" + ); + is( + hiddenOneOffs.some(x => x == "Foo"), + true, + "Current hidden engine is not affected by removal." + ); + + info("Removing testEngine.xml"); + await Services.search.removeEngine(Services.search.getEngineByName("Foo")); + + is( + Services.prefs.getCharPref("browser.search.hiddenOneOffs"), + "", + "hiddenOneOffs is empty after removing all hidden engines." + ); +}); + +add_task(async function test_add() { + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine.xml", + }); + info("setting prefs to " + testPref); + Services.prefs.setCharPref("browser.search.hiddenOneOffs", testPref); + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine_dupe.xml", + }); + let hiddenOneOffs = Services.prefs + .getCharPref("browser.search.hiddenOneOffs") + .split(","); + + is( + hiddenOneOffs.length, + 1, + "hiddenOneOffs has the correct number of hidden engines present post add." + ); + is( + hiddenOneOffs.some(x => x == "FooDupe"), + false, + "Added engine is not present in hidden list." + ); + is( + hiddenOneOffs.some(x => x == "Foo"), + true, + "Adding an engine does not remove engines from hidden list." + ); +}); + +add_task(async function test_diacritics() { + const diacritic_engine = "Foo \u2661"; + let { Preferences } = ChromeUtils.importESModule( + "resource://gre/modules/Preferences.sys.mjs" + ); + + Preferences.set("browser.search.hiddenOneOffs", diacritic_engine); + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine_diacritics.xml", + }); + + let hiddenOneOffs = Preferences.get("browser.search.hiddenOneOffs").split( + "," + ); + is( + hiddenOneOffs.some(x => x == diacritic_engine), + false, + "Observer cleans up added hidden engines that include a diacritic." + ); + + Preferences.set("browser.search.hiddenOneOffs", diacritic_engine); + + info("Removing testEngine_diacritics.xml"); + await Services.search.removeEngine( + Services.search.getEngineByName(diacritic_engine) + ); + + hiddenOneOffs = Preferences.get("browser.search.hiddenOneOffs").split(","); + is( + hiddenOneOffs.some(x => x == diacritic_engine), + false, + "Observer cleans up removed hidden engines that include a diacritic." + ); +}); diff --git a/browser/components/search/test/browser/browser_hiddenOneOffs_diacritics.js b/browser/components/search/test/browser/browser_hiddenOneOffs_diacritics.js new file mode 100644 index 0000000000..a583aad7b3 --- /dev/null +++ b/browser/components/search/test/browser/browser_hiddenOneOffs_diacritics.js @@ -0,0 +1,74 @@ +/* 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/. */ +// Tests that keyboard navigation in the search panel works as designed. + +const searchPopup = document.getElementById("PopupSearchAutoComplete"); + +const diacritic_engine = "Foo \u2661"; + +var { Preferences } = ChromeUtils.importESModule( + "resource://gre/modules/Preferences.sys.mjs" +); + +let searchIcon; + +add_setup(async function () { + let searchbar = await gCUITestUtils.addSearchBar(); + registerCleanupFunction(() => { + gCUITestUtils.removeSearchBar(); + }); + searchIcon = searchbar.querySelector(".searchbar-search-button"); + + let defaultEngine = await Services.search.getDefault(); + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine_diacritics.xml", + }); + registerCleanupFunction(async () => { + await Services.search.setDefault( + defaultEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + Services.prefs.clearUserPref("browser.search.hiddenOneOffs"); + }); +}); + +add_task(async function test_hidden() { + Preferences.set("browser.search.hiddenOneOffs", diacritic_engine); + + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + await promise; + + ok( + !getOneOffs().some(x => x.getAttribute("tooltiptext") == diacritic_engine), + "Search engines with diacritics are hidden when added to hiddenOneOffs preference." + ); + + promise = promiseEvent(searchPopup, "popuphidden"); + info("Closing search panel"); + EventUtils.synthesizeKey("KEY_Escape"); + await promise; +}); + +add_task(async function test_shown() { + Preferences.set("browser.search.hiddenOneOffs", ""); + + let oneOffsContainer = searchPopup.searchOneOffsContainer; + let shownPromise = promiseEvent(searchPopup, "popupshown"); + let builtPromise = promiseEvent(oneOffsContainer, "rebuild"); + info("Opening search panel"); + + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + await Promise.all([shownPromise, builtPromise]); + + ok( + getOneOffs().some(x => x.getAttribute("tooltiptext") == diacritic_engine), + "Search engines with diacritics are shown when removed from hiddenOneOffs preference." + ); + + let promise = promiseEvent(searchPopup, "popuphidden"); + searchPopup.hidePopup(); + await promise; +}); diff --git a/browser/components/search/test/browser/browser_ime_composition.js b/browser/components/search/test/browser/browser_ime_composition.js new file mode 100644 index 0000000000..763885aad6 --- /dev/null +++ b/browser/components/search/test/browser/browser_ime_composition.js @@ -0,0 +1,77 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Tests ime composition handling on searchbar. + +add_setup(async function () { + await gCUITestUtils.addSearchBar(); + + await SearchTestUtils.installSearchExtension({}, { setAsDefault: true }); + + registerCleanupFunction(async function () { + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function test_composition_with_focus() { + info("Open a page"); + await BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com"); + + info("Focus on the search bar"); + const searchBarTextBox = BrowserSearch.searchBar.textbox; + EventUtils.synthesizeMouseAtCenter(searchBarTextBox, {}); + is( + document.activeElement, + BrowserSearch.searchBar.textbox, + "The text box of search bar has focus" + ); + + info("Do search with new tab"); + EventUtils.synthesizeKey("x"); + EventUtils.synthesizeKey("KEY_Enter", { altKey: true, type: "keydown" }); + is(gBrowser.tabs.length, 3, "Alt+Return key added new tab"); + await TestUtils.waitForCondition( + () => document.activeElement === gBrowser.selectedBrowser, + "Wait for focus to be moved to the browser" + ); + info("The focus is moved to the browser"); + + info("Focus on the search bar again"); + EventUtils.synthesizeMouseAtCenter(searchBarTextBox, {}); + is( + document.activeElement, + BrowserSearch.searchBar.textbox, + "The textbox of search bar has focus again" + ); + + info("Type some characters during composition"); + const string = "ex"; + EventUtils.synthesizeCompositionChange({ + composition: { + string, + clauses: [ + { + length: string.length, + attr: Ci.nsITextInputProcessor.ATTR_RAW_CLAUSE, + }, + ], + }, + caret: { start: string.length, length: 0 }, + key: { key: string[string.length - 1] }, + }); + + info("Commit the composition"); + EventUtils.synthesizeComposition({ + type: "compositioncommitasis", + key: { key: "KEY_Enter" }, + }); + is( + document.activeElement, + BrowserSearch.searchBar.textbox, + "The search bar still has focus" + ); + + // Close all open tabs + await BrowserTestUtils.removeTab(gBrowser.tabs[2]); + await BrowserTestUtils.removeTab(gBrowser.tabs[1]); +}); diff --git a/browser/components/search/test/browser/browser_oneOffContextMenu.js b/browser/components/search/test/browser/browser_oneOffContextMenu.js new file mode 100644 index 0000000000..c036a5f007 --- /dev/null +++ b/browser/components/search/test/browser/browser_oneOffContextMenu.js @@ -0,0 +1,89 @@ +"use strict"; + +const TEST_ENGINE_NAME = "Foo"; +const TEST_ENGINE_BASENAME = "testEngine.xml"; + +let searchbar; +let searchIcon; + +add_setup(async function () { + searchbar = await gCUITestUtils.addSearchBar(); + registerCleanupFunction(() => { + gCUITestUtils.removeSearchBar(); + }); + searchIcon = searchbar.querySelector(".searchbar-search-button"); + + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + TEST_ENGINE_BASENAME, + }); +}); + +add_task(async function telemetry() { + let searchPopup = document.getElementById("PopupSearchAutoComplete"); + let oneOffInstance = searchPopup.oneOffButtons; + + let oneOffButtons = oneOffInstance.buttons; + + // Open the popup. + let shownPromise = promiseEvent(searchPopup, "popupshown"); + let builtPromise = promiseEvent(oneOffInstance, "rebuild"); + info("Opening search panel"); + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + await Promise.all([shownPromise, builtPromise]); + + // Get the one-off button for the test engine. + let oneOffButton; + for (let node of oneOffButtons.children) { + if (node.engine && node.engine.name == TEST_ENGINE_NAME) { + oneOffButton = node; + break; + } + } + Assert.notEqual( + oneOffButton, + undefined, + "One-off for test engine should exist" + ); + + // Open the context menu on the one-off. + let contextMenu = oneOffInstance.querySelector( + ".search-one-offs-context-menu" + ); + let promise = BrowserTestUtils.waitForEvent(contextMenu, "popupshown"); + EventUtils.synthesizeMouseAtCenter(oneOffButton, { + type: "contextmenu", + button: 2, + }); + await promise; + + // Click the Search in New Tab menu item. + let searchInNewTabMenuItem = contextMenu.querySelector( + ".search-one-offs-context-open-in-new-tab" + ); + promise = BrowserTestUtils.waitForNewTab(gBrowser); + contextMenu.activateItem(searchInNewTabMenuItem); + let tab = await promise; + + // By default the search will open in the background and the popup will stay open: + promise = promiseEvent(searchPopup, "popuphidden"); + info("Closing search panel"); + EventUtils.synthesizeKey("KEY_Escape"); + await promise; + + // Check the loaded tab. + Assert.equal( + tab.linkedBrowser.currentURI.spec, + "http://mochi.test:8888/browser/browser/components/search/test/browser/", + "Expected search tab should have loaded" + ); + + BrowserTestUtils.removeTab(tab); + + // Move the cursor out of the panel area to avoid messing with other tests. + await EventUtils.promiseNativeMouseEvent({ + type: "mousemove", + target: searchbar, + offsetX: 0, + offsetY: 0, + }); +}); diff --git a/browser/components/search/test/browser/browser_oneOffContextMenu_setDefault.js b/browser/components/search/test/browser/browser_oneOffContextMenu_setDefault.js new file mode 100644 index 0000000000..569e56b9ff --- /dev/null +++ b/browser/components/search/test/browser/browser_oneOffContextMenu_setDefault.js @@ -0,0 +1,236 @@ +"use strict"; + +const TEST_ENGINE_NAME = "Foo"; +const TEST_ENGINE_BASENAME = "testEngine.xml"; +const SEARCHBAR_BASE_ID = "searchbar-engine-one-off-item-"; + +let originalEngine; +let originalPrivateEngine; + +async function resetEngines() { + await Services.search.setDefault( + originalEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + await Services.search.setDefaultPrivate( + originalPrivateEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); +} + +registerCleanupFunction(resetEngines); + +add_setup(async function () { + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.separatePrivateDefault.ui.enabled", true], + ["browser.search.separatePrivateDefault", true], + ["browser.search.widget.inNavBar", true], + ], + }); + originalEngine = await Services.search.getDefault(); + originalPrivateEngine = await Services.search.getDefaultPrivate(); + registerCleanupFunction(async () => { + await resetEngines(); + }); + + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + TEST_ENGINE_BASENAME, + }); +}); + +async function testSearchBarChangeEngine(win, testPrivate, isPrivateWindow) { + info( + `Testing search bar with testPrivate: ${testPrivate} isPrivateWindow: ${isPrivateWindow}` + ); + + const searchPopup = win.document.getElementById("PopupSearchAutoComplete"); + const searchOneOff = searchPopup.oneOffButtons; + + // Ensure the engine is reset. + await resetEngines(); + + let oneOffButton = await openPopupAndGetEngineButton( + searchPopup, + searchOneOff, + SEARCHBAR_BASE_ID, + TEST_ENGINE_NAME + ); + + const contextMenu = searchOneOff.contextMenuPopup; + const setDefaultEngineMenuItem = searchOneOff.querySelector( + ".search-one-offs-context-set-default" + (testPrivate ? "-private" : "") + ); + + // Click the set default engine menu item. + let promise = promiseDefaultEngineChanged(testPrivate); + contextMenu.activateItem(setDefaultEngineMenuItem); + + // This also checks the engine correctly changed. + await promise; + + if (testPrivate == isPrivateWindow) { + let expectedName = originalEngine.name; + let expectedImage = originalEngine.iconURI.spec; + if (isPrivateWindow) { + expectedName = originalPrivateEngine.name; + expectedImage = originalPrivateEngine.iconURI.spec; + } + + Assert.equal( + oneOffButton.getAttribute("tooltiptext"), + expectedName, + "Should now have the original engine's name for the tooltip" + ); + Assert.equal( + oneOffButton.image, + expectedImage, + "Should now have the original engine's uri for the image" + ); + } + + await promiseClosePopup(searchPopup); +} + +add_task(async function test_searchBarChangeEngine() { + await testSearchBarChangeEngine(window, false, false); + await testSearchBarChangeEngine(window, true, false); +}); + +add_task(async function test_searchBarChangeEngine_privateWindow() { + const win = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + await testSearchBarChangeEngine(win, true, true); + await BrowserTestUtils.closeWindow(win); +}); + +/** + * Promises that an engine change has happened for the current engine, which + * has resulted in the test engine now being the current engine. + * + * @param {boolean} testPrivate + * Set to true if we're testing the private default engine. + * @returns {Promise} Resolved once the test engine is set as the current engine. + */ +function promiseDefaultEngineChanged(testPrivate) { + const expectedNotification = testPrivate + ? "engine-default-private" + : "engine-default"; + return new Promise(resolve => { + function observer(aSub, aTopic, aData) { + if (aData == expectedNotification) { + Assert.equal( + Services.search[ + testPrivate ? "defaultPrivateEngine" : "defaultEngine" + ].name, + TEST_ENGINE_NAME, + "defaultEngine set" + ); + Services.obs.removeObserver(observer, "browser-search-engine-modified"); + resolve(); + } + } + + Services.obs.addObserver(observer, "browser-search-engine-modified"); + }); +} + +/** + * Opens the specified search popup and gets the test engine from the + * one-off buttons. + * + * @param {object} popup The expected popup. + * @param {object} oneOffInstance The expected one-off instance for the popup. + * @param {string} baseId The expected string for the id of the current + * engine button, without the engine name. + * @param {string} engineName The engine name for finding the one-off button. + * @returns {object} Returns an object that represents the one off button for the + * test engine. + */ +async function openPopupAndGetEngineButton( + popup, + oneOffInstance, + baseId, + engineName +) { + const win = oneOffInstance.container.ownerGlobal; + // Open the popup. + win.gURLBar.blur(); + let shownPromise = promiseEvent(popup, "popupshown"); + let builtPromise = promiseEvent(oneOffInstance, "rebuild"); + let searchbar = win.document.getElementById("searchbar"); + let searchIcon = searchbar.querySelector(".searchbar-search-button"); + // Use the search icon to avoid hitting the network. + EventUtils.synthesizeMouseAtCenter(searchIcon, {}, win); + await Promise.all([shownPromise, builtPromise]); + + const contextMenu = oneOffInstance.contextMenuPopup; + let oneOffButton = oneOffInstance.buttons; + + // Get the one-off button for the test engine. + for ( + oneOffButton = oneOffButton.firstChild; + oneOffButton; + oneOffButton = oneOffButton.nextSibling + ) { + if ( + oneOffButton.nodeType == Node.ELEMENT_NODE && + oneOffButton.engine && + oneOffButton.engine.name == engineName + ) { + break; + } + } + + Assert.notEqual( + oneOffButton, + undefined, + "One-off for test engine should exist" + ); + Assert.equal( + oneOffButton.getAttribute("tooltiptext"), + engineName, + "One-off should have the tooltip set to the engine name" + ); + + Assert.ok( + oneOffButton.id.startsWith(baseId + "engine-"), + "Should have an appropriate id" + ); + + // Open the context menu on the one-off. + let promise = BrowserTestUtils.waitForEvent(contextMenu, "popupshown"); + EventUtils.synthesizeMouseAtCenter( + oneOffButton, + { + type: "contextmenu", + button: 2, + }, + win + ); + await promise; + + return oneOffButton; +} + +/** + * Closes the popup and moves the mouse away from it. + * + * @param {Button} popup The popup to close. + */ +async function promiseClosePopup(popup) { + // close the panel using the escape key. + let promise = promiseEvent(popup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Escape", {}, popup.ownerGlobal); + await promise; + + // Move the cursor out of the panel area to avoid messing with other tests. + EventUtils.synthesizeNativeMouseEvent({ + type: "mousemove", + target: popup, + offsetX: 0, + offsetY: 0, + win: popup.ownerGlobal, + }); +} diff --git a/browser/components/search/test/browser/browser_private_search_perwindowpb.js b/browser/components/search/test/browser/browser_private_search_perwindowpb.js new file mode 100644 index 0000000000..b1ca3cb962 --- /dev/null +++ b/browser/components/search/test/browser/browser_private_search_perwindowpb.js @@ -0,0 +1,84 @@ +// This test performs a search in a public window, then a different +// search in a private window, and then checks in the public window +// whether there is an autocomplete entry for the private search. + +add_task(async function test_setup() { + await gCUITestUtils.addSearchBar(); + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "426329.xml", + setAsDefault: true, + }); + + registerCleanupFunction(async () => { + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function () { + let windowsToClose = []; + + function performSearch(aWin, aIsPrivate) { + let searchBar = aWin.BrowserSearch.searchBar; + ok(searchBar, "got search bar"); + + let loadPromise = BrowserTestUtils.browserLoaded( + aWin.gBrowser.selectedBrowser + ); + + searchBar.value = aIsPrivate ? "private test" : "public test"; + searchBar.focus(); + EventUtils.synthesizeKey("VK_RETURN", {}, aWin); + + return loadPromise; + } + + async function testOnWindow(aIsPrivate) { + let win = await BrowserTestUtils.openNewBrowserWindow({ + private: aIsPrivate, + }); + await SimpleTest.promiseFocus(win); + windowsToClose.push(win); + return win; + } + + let newWindow = await testOnWindow(false); + await performSearch(newWindow, false); + + newWindow = await testOnWindow(true); + await performSearch(newWindow, true); + + newWindow = await testOnWindow(false); + + let searchBar = newWindow.BrowserSearch.searchBar; + searchBar.value = "p"; + searchBar.focus(); + + let popup = searchBar.textbox.popup; + let popupPromise = BrowserTestUtils.waitForEvent(popup, "popupshown"); + searchBar.textbox.showHistoryPopup(); + await popupPromise; + + let entries = getMenuEntries(searchBar); + for (let i = 0; i < entries.length; i++) { + isnot( + entries[i], + "private test", + "shouldn't see private autocomplete entries" + ); + } + + searchBar.textbox.toggleHistoryPopup(); + searchBar.value = ""; + + windowsToClose.forEach(function (win) { + win.close(); + }); +}); + +function getMenuEntries(searchBar) { + // Could perhaps pull values directly from the controller, but it seems + // more reliable to test the values that are actually in the richlistbox? + return Array.from(searchBar.textbox.popup.richlistbox.itemChildren, item => + item.getAttribute("ac-value") + ); +} diff --git a/browser/components/search/test/browser/browser_rich_suggestions.js b/browser/components/search/test/browser/browser_rich_suggestions.js new file mode 100644 index 0000000000..b92cdb5a6a --- /dev/null +++ b/browser/components/search/test/browser/browser_rich_suggestions.js @@ -0,0 +1,110 @@ +/* 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 CONFIG_DEFAULT = [ + { + webExtension: { id: "basic@search.mozilla.org" }, + urls: { + trending: { + fullPath: + "https://example.com/browser/browser/components/search/test/browser/trendingSuggestionEngine.sjs?richsuggestions=true", + query: "", + }, + }, + appliesTo: [{ included: { everywhere: true } }], + default: "yes", + }, +]; + +SearchTestUtils.init(this); + +add_setup(async () => { + // Use engines in test directory + let searchExtensions = getChromeDir(getResolvedURI(gTestPath)); + searchExtensions.append("search-engines"); + await SearchTestUtils.useMochitestEngines(searchExtensions); + + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.urlbar.suggest.searches", true], + ["browser.urlbar.trending.featureGate", true], + ["browser.urlbar.trending.requireSearchMode", false], + ["browser.urlbar.eventTelemetry.enabled", true], + // Bug 1775917: Disable the persisted-search-terms search tip because if + // not dismissed, it can cause issues with other search tests. + ["browser.urlbar.tipShownCount.searchTip_persist", 999], + ], + }); + + SearchTestUtils.useMockIdleService(); + await SearchTestUtils.updateRemoteSettingsConfig(CONFIG_DEFAULT); + + registerCleanupFunction(async () => { + let settingsWritten = SearchTestUtils.promiseSearchNotification( + "write-settings-to-disk-complete" + ); + await SearchTestUtils.updateRemoteSettingsConfig(); + await settingsWritten; + }); +}); + +add_task(async function test_trending_results() { + await check_results({ featureEnabled: true }); + await check_results({ featureEnabled: false }); +}); + +async function check_results({ featureEnabled = false }) { + Services.telemetry.clearEvents(); + Services.telemetry.clearScalars(); + await SpecialPowers.pushPrefEnv({ + set: [["browser.urlbar.richSuggestions.featureGate", featureEnabled]], + }); + + await UrlbarTestUtils.promiseAutocompleteResultPopup({ + window, + value: "", + waitForFocus: SimpleTest.waitForFocus, + }); + + let numResults = UrlbarTestUtils.getResultCount(window); + + for (let i = 0; i < numResults; i++) { + let { result } = await UrlbarTestUtils.getDetailsOfResultAt(window, i); + Assert.equal(result.type, UrlbarUtils.RESULT_TYPE.SEARCH); + Assert.equal(result.providerName, "SearchSuggestions"); + Assert.equal(result.payload.engine, "basic"); + Assert.equal(result.payload.isRichSuggestion, featureEnabled); + if (featureEnabled) { + Assert.equal(typeof result.payload.description, "string"); + Assert.ok(result.payload.icon.startsWith("data:")); + } + } + + info("Select first remote search suggestion & hit Enter."); + EventUtils.synthesizeKey("KEY_ArrowDown", {}, window); + EventUtils.synthesizeKey("VK_RETURN", {}, window); + + let event = { + category: "urlbar", + method: "engagement", + object: "enter", + value: "typed", + extra: { + elapsed: val => parseInt(val) > 0, + numChars: "0", + numWords: "0", + selIndex: "0", + selType: featureEnabled ? "trending_rich" : "trending", + provider: "SearchSuggestions", + }, + }; + + TelemetryTestUtils.assertEvents([event], { + category: "urlbar", + }); + let scalars = TelemetryTestUtils.getProcessScalars("parent", false, true); + TelemetryTestUtils.assertScalar(scalars, "urlbar.engagement", 1); + + await SpecialPowers.popPrefEnv(); +} diff --git a/browser/components/search/test/browser/browser_searchEngine_behaviors.js b/browser/components/search/test/browser/browser_searchEngine_behaviors.js new file mode 100644 index 0000000000..4303249e63 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchEngine_behaviors.js @@ -0,0 +1,223 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Test search plugin URLs + */ + +"use strict"; + +const SEARCH_ENGINE_DETAILS = [ + { + alias: "a", + baseURL: + "https://www.amazon.com/exec/obidos/external-search/?field-keywords=foo&ie=UTF-8&mode=blended&tag=moz-us-20&sourceid=Mozilla-search", + codes: { + context: "", + keyword: "", + newTab: "", + submission: "", + }, + name: "Amazon.com", + }, + { + alias: "b", + baseURL: `https://www.bing.com/search?{code}pc=${ + SearchUtils.MODIFIED_APP_CHANNEL == "esr" ? "MOZR" : "MOZI" + }&q=foo`, + codes: { + context: "form=MOZCON&", + keyword: "form=MOZLBR&", + newTab: "form=MOZTSB&", + submission: "form=MOZSBR&", + }, + name: "Bing", + }, + { + alias: "d", + baseURL: `https://duckduckgo.com/?{code}t=${ + SearchUtils.MODIFIED_APP_CHANNEL == "esr" ? "ftsa" : "ffab" + }&q=foo`, + codes: { + context: "", + keyword: "", + newTab: "", + submission: "", + }, + name: "DuckDuckGo", + }, + { + alias: "e", + baseURL: + "https://www.ebay.com/sch/?toolid=20004&campid=5338192028&mkevt=1&mkcid=1&mkrid=711-53200-19255-0&kw=foo", + codes: { + context: "", + keyword: "", + newTab: "", + submission: "", + }, + name: "eBay", + }, + // { + // TODO: Google is tested in browser_google_behaviors.js - we can't test it here + // yet because of bug 1315953. + // alias: "g", + // baseURL: "https://www.google.com/search?q=foo&ie=utf-8&oe=utf-8", + // codes: { + // context: "", + // keyword: "", + // newTab: "", + // submission: "", + // }, + // name: "Google", + // }, +]; + +function promiseContentSearchReady(browser) { + return SpecialPowers.spawn(browser, [], async function (args) { + SpecialPowers.pushPrefEnv({ + set: [ + [ + "browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar", + false, + ], + ], + }); + await ContentTaskUtils.waitForCondition( + () => + content.wrappedJSObject.gContentSearchController && + content.wrappedJSObject.gContentSearchController.defaultEngine + ); + }); +} + +add_task(async function test_setup() { + await gCUITestUtils.addSearchBar(); + registerCleanupFunction(() => { + gCUITestUtils.removeSearchBar(); + }); +}); + +for (let engine of SEARCH_ENGINE_DETAILS) { + add_task(async function () { + let previouslySelectedEngine = await Services.search.getDefault(); + + registerCleanupFunction(async function () { + await Services.search.setDefault( + previouslySelectedEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + }); + + await testSearchEngine(engine); + }); +} + +async function testSearchEngine(engineDetails) { + let engine = Services.search.getEngineByName(engineDetails.name); + Assert.ok(engine, `${engineDetails.name} is installed`); + + await Services.search.setDefault( + engine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + engine.alias = engineDetails.alias; + + let base = engineDetails.baseURL; + + // Test search URLs (including purposes). + let url = engine.getSubmission("foo").uri.spec; + Assert.equal( + url, + base.replace("{code}", engineDetails.codes.submission), + "Check search URL for 'foo'" + ); + let sb = BrowserSearch.searchBar; + + let engineTests = [ + { + name: "context menu search", + searchURL: base.replace("{code}", engineDetails.codes.context), + run() { + // Simulate a contextmenu search + // FIXME: This is a bit "low-level"... + BrowserSearch._loadSearch( + "foo", + false, + false, + "contextmenu", + Services.scriptSecurityManager.getSystemPrincipal() + ); + }, + }, + { + name: "keyword search", + searchURL: base.replace("{code}", engineDetails.codes.keyword), + run() { + gURLBar.value = "? foo"; + gURLBar.focus(); + EventUtils.synthesizeKey("KEY_Enter"); + }, + }, + { + name: "keyword search with alias", + searchURL: base.replace("{code}", engineDetails.codes.keyword), + run() { + gURLBar.value = `${engineDetails.alias} foo`; + gURLBar.focus(); + EventUtils.synthesizeKey("KEY_Enter"); + }, + }, + { + name: "search bar search", + searchURL: base.replace("{code}", engineDetails.codes.submission), + run() { + sb.focus(); + sb.value = "foo"; + EventUtils.synthesizeKey("KEY_Enter"); + }, + }, + { + name: "new tab search", + searchURL: base.replace("{code}", engineDetails.codes.newTab), + async preTest(tab) { + let browser = tab.linkedBrowser; + BrowserTestUtils.loadURIString(browser, "about:newtab"); + + await BrowserTestUtils.browserLoaded(browser, false, "about:newtab"); + await promiseContentSearchReady(browser); + }, + async run(tab) { + await SpecialPowers.spawn(tab.linkedBrowser, [], async function () { + let input = content.document.querySelector("input[id*=search-]"); + input.focus(); + input.value = "foo"; + }); + EventUtils.synthesizeKey("KEY_Enter"); + }, + }, + ]; + + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + for (let test of engineTests) { + info(`Running: ${test.name}`); + + if (test.preTest) { + await test.preTest(tab); + } + + let promises = [ + BrowserTestUtils.waitForDocLoadAndStopIt(test.searchURL, tab), + BrowserTestUtils.browserStopped(tab.linkedBrowser, test.searchURL, true), + ]; + + await test.run(tab); + + await Promise.all(promises); + } + + engine.alias = undefined; + sb.value = ""; + BrowserTestUtils.removeTab(tab); +} diff --git a/browser/components/search/test/browser/browser_search_annotation.js b/browser/components/search/test/browser/browser_search_annotation.js new file mode 100644 index 0000000000..991646657e --- /dev/null +++ b/browser/components/search/test/browser/browser_search_annotation.js @@ -0,0 +1,176 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +// Test whether a visit information is annotated correctly when searching on searchbar. + +ChromeUtils.defineESModuleGetters(this, { + PlacesTestUtils: "resource://testing-common/PlacesTestUtils.sys.mjs", +}); + +const FRECENCY = { + SEARCHED: 100, + BOOKMARKED: 175, +}; + +const { VISIT_SOURCE_BOOKMARKED, VISIT_SOURCE_SEARCHED } = PlacesUtils.history; + +async function assertDatabase({ targetURL, expected }) { + const frecency = await PlacesTestUtils.getDatabaseValue( + "moz_places", + "frecency", + { url: targetURL } + ); + Assert.equal(frecency, expected.frecency, "Frecency is correct"); + + const placesId = await PlacesTestUtils.getDatabaseValue("moz_places", "id", { + url: targetURL, + }); + const db = await PlacesUtils.promiseDBConnection(); + const rows = await db.execute( + "SELECT source, triggeringPlaceId FROM moz_historyvisits WHERE place_id = :place_id AND source = :source", + { + place_id: placesId, + source: expected.source, + } + ); + Assert.equal(rows.length, 1); + Assert.equal( + rows[0].getResultByName("triggeringPlaceId"), + null, + `The triggeringPlaceId in database is correct for ${targetURL}` + ); +} + +add_setup(async function () { + await PlacesUtils.history.clear(); + await PlacesUtils.bookmarks.eraseEverything(); + + await gCUITestUtils.addSearchBar(); + await SearchTestUtils.installSearchExtension( + { + name: "Example", + keyword: "@test", + }, + { setAsDefault: true } + ); + + registerCleanupFunction(async function () { + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function basic() { + const testData = [ + { + description: "Normal search", + input: "abc", + resultURL: "https://example.com/?q=abc", + expected: { + source: VISIT_SOURCE_SEARCHED, + frecency: FRECENCY.SEARCHED, + }, + }, + { + description: "Search but the url is bookmarked", + input: "abc", + resultURL: "https://example.com/?q=abc", + bookmarks: [ + { + parentGuid: PlacesUtils.bookmarks.toolbarGuid, + url: Services.io.newURI("https://example.com/?q=abc"), + title: "test bookmark", + }, + ], + expected: { + source: VISIT_SOURCE_BOOKMARKED, + frecency: FRECENCY.BOOKMARKED, + }, + }, + ]; + + for (const { + description, + input, + resultURL, + bookmarks, + expected, + } of testData) { + info(description); + + for (const bookmark of bookmarks || []) { + await PlacesUtils.bookmarks.insert(bookmark); + } + + const onLoad = BrowserTestUtils.browserLoaded( + gBrowser.selectedBrowser, + false, + resultURL + ); + await searchInSearchbar(input); + let promiseVisited = PlacesTestUtils.waitForNotification( + "page-visited", + events => events.some(e => e.url == resultURL) + ); + EventUtils.synthesizeKey("KEY_Enter"); + await onLoad; + await promiseVisited; + await assertDatabase({ targetURL: resultURL, expected }); + + await PlacesUtils.history.clear(); + await PlacesUtils.bookmarks.eraseEverything(); + } +}); + +add_task(async function contextmenu() { + await BrowserTestUtils.withNewTab( + "https://example.com/browser/browser/components/search/test/browser/test_search.html", + async () => { + // Select html content. + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => { + await new Promise(resolve => { + content.document.addEventListener("selectionchange", resolve, { + once: true, + }); + content.document + .getSelection() + .selectAllChildren(content.document.body); + }); + }); + + const onPopup = BrowserTestUtils.waitForEvent(document, "popupshown"); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#id", + { type: "contextmenu" }, + gBrowser.selectedBrowser + ); + await onPopup; + + const targetURL = "https://example.com/?q=test%2520search"; + const onLoad = BrowserTestUtils.waitForNewTab(gBrowser, targetURL, true); + const contextMenu = document.getElementById("contentAreaContextMenu"); + const openLinkMenuItem = contextMenu.querySelector( + "#context-searchselect" + ); + let promiseVisited = PlacesTestUtils.waitForNotification( + "page-visited", + events => events.some(e => e.url == targetURL) + ); + contextMenu.activateItem(openLinkMenuItem); + const tab = await onLoad; + await promiseVisited; + await assertDatabase({ + targetURL, + expected: { + source: VISIT_SOURCE_SEARCHED, + frecency: FRECENCY.SEARCHED, + }, + }); + + BrowserTestUtils.removeTab(tab); + await PlacesUtils.history.clear(); + await PlacesUtils.bookmarks.eraseEverything(); + } + ); +}); diff --git a/browser/components/search/test/browser/browser_search_discovery.js b/browser/components/search/test/browser/browser_search_discovery.js new file mode 100644 index 0000000000..94c198776c --- /dev/null +++ b/browser/components/search/test/browser/browser_search_discovery.js @@ -0,0 +1,132 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-disable mozilla/no-arbitrary-setTimeout */ + +// Bug 1588193 - BrowserTestUtils.waitForContentEvent now resolves slightly +// earlier than before, so it no longer suffices to only wait for a single event +// tick before checking if browser.engines has been updated. Instead we use a 1s +// timeout, which may cause the test to take more time. +requestLongerTimeout(2); + +add_task(async function () { + let url = + "http://mochi.test:8888/browser/browser/components/search/test/browser/discovery.html"; + info("Test search discovery"); + await BrowserTestUtils.withNewTab(url, searchDiscovery); +}); + +let searchDiscoveryTests = [ + { text: "rel search discovered" }, + { rel: "SEARCH", text: "rel is case insensitive" }, + { rel: "-search-", pass: false, text: "rel -search- not discovered" }, + { + rel: "foo bar baz search quux", + text: "rel may contain additional rels separated by spaces", + }, + { href: "https://not.mozilla.com", text: "HTTPS ok" }, + { href: "data:text/foo,foo", pass: false, text: "data URI not permitted" }, + { href: "javascript:alert(0)", pass: false, text: "JS URI not permitted" }, + { + type: "APPLICATION/OPENSEARCHDESCRIPTION+XML", + text: "type is case insensitve", + }, + { + type: " application/opensearchdescription+xml ", + text: "type may contain extra whitespace", + }, + { + type: "application/opensearchdescription+xml; charset=utf-8", + text: "type may have optional parameters (RFC2046)", + }, + { + type: "aapplication/opensearchdescription+xml", + pass: false, + text: "type should not be loosely matched", + }, + { + rel: "search search search", + count: 1, + text: "only one engine should be added", + }, +]; + +async function searchDiscovery() { + let browser = gBrowser.selectedBrowser; + + for (let testCase of searchDiscoveryTests) { + if (testCase.pass == undefined) { + testCase.pass = true; + } + testCase.title = testCase.title || searchDiscoveryTests.indexOf(testCase); + + let promiseLinkAdded = BrowserTestUtils.waitForContentEvent( + gBrowser.selectedBrowser, + "DOMLinkAdded", + false, + null, + true + ); + + await SpecialPowers.spawn(gBrowser.selectedBrowser, [testCase], test => { + let doc = content.document; + let head = doc.getElementById("linkparent"); + let link = doc.createElement("link"); + link.rel = test.rel || "search"; + link.href = test.href || "http://so.not.here.mozilla.com/search.xml"; + link.type = test.type || "application/opensearchdescription+xml"; + link.title = test.title; + head.appendChild(link); + }); + + await promiseLinkAdded; + await new Promise(resolve => setTimeout(resolve, 1000)); + + if (browser.engines) { + info(`Found ${browser.engines.length} engines`); + info(`First engine title: ${browser.engines[0].title}`); + let hasEngine = testCase.count + ? browser.engines[0].title == testCase.title && + browser.engines.length == testCase.count + : browser.engines[0].title == testCase.title; + ok(hasEngine, testCase.text); + browser.engines = null; + } else { + ok(!testCase.pass, testCase.text); + } + } + + info("Test multiple engines with the same title"); + let promiseLinkAdded = BrowserTestUtils.waitForContentEvent( + gBrowser.selectedBrowser, + "DOMLinkAdded", + false, + e => e.target.href == "http://second.mozilla.com/search.xml", + true + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + let doc = content.document; + let head = doc.getElementById("linkparent"); + let link = doc.createElement("link"); + link.rel = "search"; + link.href = "http://first.mozilla.com/search.xml"; + link.type = "application/opensearchdescription+xml"; + link.title = "Test Engine"; + let link2 = link.cloneNode(false); + link2.href = "http://second.mozilla.com/search.xml"; + head.appendChild(link); + head.appendChild(link2); + }); + + await promiseLinkAdded; + await new Promise(resolve => setTimeout(resolve, 1000)); + + ok(browser.engines, "has engines"); + is(browser.engines.length, 1, "only one engine"); + is( + browser.engines[0].uri, + "http://first.mozilla.com/search.xml", + "first engine wins" + ); + browser.engines = null; +} diff --git a/browser/components/search/test/browser/browser_search_glean_serp_telemetry_enabled_by_nimbus_variable.js b/browser/components/search/test/browser/browser_search_glean_serp_telemetry_enabled_by_nimbus_variable.js new file mode 100644 index 0000000000..99be6ca76b --- /dev/null +++ b/browser/components/search/test/browser/browser_search_glean_serp_telemetry_enabled_by_nimbus_variable.js @@ -0,0 +1,159 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test to verify we can toggle the Glean SERP telemetry feature via a Nimbus +// variable. + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + ExperimentAPI: "resource://nimbus/ExperimentAPI.sys.mjs", + ExperimentFakes: "resource://testing-common/NimbusTestUtils.sys.mjs", +}); + +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "serpEventsEnabled", + "browser.search.serpEventTelemetry.enabled", + false +); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetry(?:Ad)?.html/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad2?/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +async function verifyEventsRecorded() { + function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; + } + + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl("searchTelemetryAd.html") + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + await waitForPageWithAdImpressions(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + ads_loaded: "2", + ads_visible: "2", + ads_hidden: "0", + }, + ]); + + BrowserTestUtils.removeTab(tab); + + assertAbandonmentEvent({ + abandonment: { + reason: SearchSERPTelemetryUtils.ABANDONMENTS.TAB_CLOSE, + }, + }); +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + + await SpecialPowers.pushPrefEnv({ + set: [["browser.search.log", true]], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + await SpecialPowers.popPrefEnv(); + resetTelemetry(); + }); +}); + +add_task(async function test_enable_experiment() { + Assert.equal( + lazy.serpEventsEnabled, + false, + "serpEventsEnabled should be false when not enrolled in experiment." + ); + + await lazy.ExperimentAPI.ready(); + + let doExperimentCleanup = await lazy.ExperimentFakes.enrollWithFeatureConfig( + { + featureId: NimbusFeatures.search.featureId, + value: { + serpEventTelemetryEnabled: true, + }, + }, + { isRollout: true } + ); + + Assert.equal( + lazy.serpEventsEnabled, + true, + "serpEventsEnabled should be true when enrolled in experiment." + ); + + // To ensure Nimbus set "browser.search.serpEventTelemetry.enabled" to true, + // we test that an impression, ad_impression and abandonment event are + // recorded correctly. + await verifyEventsRecorded(); + + await doExperimentCleanup(); + + Assert.equal( + lazy.serpEventsEnabled, + false, + "serpEventsEnabled should be false after experiment." + ); +}); diff --git a/browser/components/search/test/browser/browser_search_nimbus_reload.js b/browser/components/search/test/browser/browser_search_nimbus_reload.js new file mode 100644 index 0000000000..19247c9a02 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_nimbus_reload.js @@ -0,0 +1,55 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { ExperimentFakes } = ChromeUtils.importESModule( + "resource://testing-common/NimbusTestUtils.sys.mjs" +); + +const { SearchService } = ChromeUtils.importESModule( + "resource://gre/modules/SearchService.sys.mjs" +); +const { sinon } = ChromeUtils.importESModule( + "resource://testing-common/Sinon.sys.mjs" +); + +add_task(async function test_engines_reloaded_nimbus() { + let reloadSpy = sinon.spy(SearchService.prototype, "_maybeReloadEngines"); + let getVariableSpy = sinon.spy( + NimbusFeatures.searchConfiguration, + "getVariable" + ); + + let doExperimentCleanup = await ExperimentFakes.enrollWithFeatureConfig({ + featureId: "searchConfiguration", + value: { experiment: "nimbus-search-mochitest" }, + }); + + Assert.equal(reloadSpy.callCount, 1, "Called by experiment enrollment"); + await BrowserTestUtils.waitForCondition( + () => getVariableSpy.calledWith("experiment"), + "Wait for SearchService update to run" + ); + Assert.equal( + getVariableSpy.callCount, + 3, + "Called by update function to fetch engines" + ); + Assert.ok( + getVariableSpy.calledWith("experiment"), + "Called by search service observer" + ); + Assert.equal( + NimbusFeatures.searchConfiguration.getVariable("experiment"), + "nimbus-search-mochitest", + "Should have expected value" + ); + + await doExperimentCleanup(); + + Assert.equal(reloadSpy.callCount, 2, "Called by experiment unenrollment"); + + reloadSpy.restore(); + getVariableSpy.restore(); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_abandonment.js b/browser/components/search/test/browser/browser_search_telemetry_abandonment.js new file mode 100644 index 0000000000..f599ad79f9 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_abandonment.js @@ -0,0 +1,243 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Tests for the Glean SERP abandonment event + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetry(?:Ad)?.html/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad2?/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + resetTelemetry(); + }); +}); + +add_task(async function test_tab_close() { + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl("searchTelemetry.html") + ); + + BrowserTestUtils.removeTab(tab); + + assertAbandonmentEvent({ + abandonment: { + reason: SearchSERPTelemetryUtils.ABANDONMENTS.TAB_CLOSE, + }, + }); +}); + +add_task(async function test_window_close() { + resetTelemetry(); + + let serpUrl = getSERPUrl("searchTelemetry.html"); + let otherWindow = await BrowserTestUtils.openNewBrowserWindow(); + let browserLoadedPromise = BrowserTestUtils.browserLoaded( + otherWindow.gBrowser, + false, + serpUrl + ); + BrowserTestUtils.loadURIString(otherWindow.gBrowser, serpUrl); + await browserLoadedPromise; + + await BrowserTestUtils.closeWindow(otherWindow); + + assertAbandonmentEvent({ + abandonment: { + reason: SearchSERPTelemetryUtils.ABANDONMENTS.WINDOW_CLOSE, + }, + }); +}); + +add_task(async function test_navigation_via_urlbar() { + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl("searchTelemetry.html") + ); + let browserLoadedPromise = BrowserTestUtils.browserLoaded( + gBrowser, + false, + "https://www.example.com/" + ); + BrowserTestUtils.loadURIString(gBrowser, "https://www.example.com"); + await browserLoadedPromise; + + assertAbandonmentEvent({ + abandonment: { + reason: SearchSERPTelemetryUtils.ABANDONMENTS.NAVIGATION, + }, + }); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_navigation_via_back_button() { + resetTelemetry(); + + let exampleUrl = "https://example.com/"; + let serpUrl = getSERPUrl("searchTelemetry.html"); + await BrowserTestUtils.withNewTab(exampleUrl, async browser => { + info("example.com is now loaded."); + + let pageLoadPromise = BrowserTestUtils.browserLoaded( + browser, + false, + serpUrl + ); + BrowserTestUtils.loadURIString(browser, serpUrl); + await pageLoadPromise; + info("Serp is now loaded."); + + let pageShowPromise = BrowserTestUtils.waitForContentEvent( + browser, + "pageshow" + ); + browser.goBack(); + await pageShowPromise; + + info("Previous page (example.com) is now loaded after back navigation."); + }); + + assertAbandonmentEvent({ + abandonment: { + reason: SearchSERPTelemetryUtils.ABANDONMENTS.NAVIGATION, + }, + }); +}); + +add_task(async function test_click_ad() { + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl("searchTelemetryAd.html") + ); + + await TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length; + }, "Should have received an ad impression."); + + let browserLoadedPromise = BrowserTestUtils.browserLoaded(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "a", + {}, + gBrowser.selectedBrowser + ); + await browserLoadedPromise; + + Assert.equal( + !!Glean.serp.abandonment.testGetValue(), + false, + "Should not have any abandonment events." + ); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_without_components() { + // Mock a provider that doesn't have components. + let providerInfo = [ + { + ...TEST_PROVIDER_INFO[0], + components: [], + }, + ]; + SearchSERPTelemetry.overrideSearchTelemetryForTests(providerInfo); + await waitForIdle(); + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl("searchTelemetryAd.html") + ); + + // We shouldn't expect a SERP impression, so instead wait roughly + // around how long it would usually take to receive an impression following + // a page load. + await promiseWaitForAdLinkCheck(); + Assert.equal( + !!Glean.serp.impression.testGetValue(), + false, + "Should not have any impression events." + ); + + let browserLoadedPromise = BrowserTestUtils.browserLoaded( + gBrowser, + false, + "https://www.example.com/" + ); + BrowserTestUtils.loadURIString(gBrowser, "https://www.example.com"); + await browserLoadedPromise; + + Assert.equal( + !!Glean.serp.abandonment.testGetValue(), + false, + "Should not have any abandonment events." + ); + + BrowserTestUtils.removeTab(tab); + + // Allow subsequent tests to use the default provider. + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_aboutHome.js b/browser/components/search/test/browser/browser_search_telemetry_aboutHome.js new file mode 100644 index 0000000000..702cbabb0f --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_aboutHome.js @@ -0,0 +1,135 @@ +"use strict"; + +const SCALAR_ABOUT_HOME = "browser.engagement.navigation.about_home"; + +add_setup(async function () { + // about:home uses IndexedDB. However, the test finishes too quickly and doesn't + // allow it enougth time to save. So it throws. This disables all the uncaught + // exception in this file and that's the reason why we split about:home tests + // out of the other UsageTelemetry files. + ignoreAllUncaughtExceptions(); + + // Create two new search engines. Mark one as the default engine, so + // the test don't crash. We need to engines for this test as the searchbar + // in content doesn't display the default search engine among the one-off engines. + await SearchTestUtils.installSearchExtension( + { + name: "MozSearch", + keyword: "mozalias", + }, + { setAsDefault: true } + ); + await SearchTestUtils.installSearchExtension({ + name: "MozSearch2", + keyword: "mozalias2", + }); + + // Move the second engine at the beginning of the one-off list. + let engineOneOff = Services.search.getEngineByName("MozSearch2"); + await Services.search.moveEngine(engineOneOff, 0); + + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + + // Enable event recording for the events tested here. + Services.telemetry.setEventRecordingEnabled("navigation", true); + + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar", + false, + ], + ], + }); + + registerCleanupFunction(async function () { + await PlacesUtils.history.clear(); + Services.telemetry.setEventRecordingEnabled("navigation", false); + Services.telemetry.canRecordExtended = oldCanRecord; + }); +}); + +add_task(async function test_abouthome_activitystream_simpleQuery() { + // Let's reset the counts. + Services.telemetry.clearScalars(); + Services.telemetry.clearEvents(); + Services.fog.testResetFOG(); + let search_hist = + TelemetryTestUtils.getAndClearKeyedHistogram("SEARCH_COUNTS"); + + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + info("Load about:home."); + BrowserTestUtils.loadURIString(tab.linkedBrowser, "about:home"); + await BrowserTestUtils.browserStopped(tab.linkedBrowser, "about:home"); + + info("Wait for ContentSearchUI search provider to initialize."); + await SpecialPowers.spawn(tab.linkedBrowser, [], async function () { + await ContentTaskUtils.waitForCondition( + () => content.wrappedJSObject.gContentSearchController.defaultEngine + ); + }); + + info("Trigger a simple search, just test + enter."); + let p = BrowserTestUtils.browserStopped( + tab.linkedBrowser, + "https://example.com/?q=test+query" + ); + await typeInSearchField( + tab.linkedBrowser, + "test query", + "newtab-search-text" + ); + await BrowserTestUtils.synthesizeKey("VK_RETURN", {}, tab.linkedBrowser); + await p; + + // Check if the scalars contain the expected values. + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, false); + TelemetryTestUtils.assertKeyedScalar( + scalars, + SCALAR_ABOUT_HOME, + "search_enter", + 1 + ); + Assert.equal( + Object.keys(scalars[SCALAR_ABOUT_HOME]).length, + 1, + "This search must only increment one entry in the scalar." + ); + + // Make sure SEARCH_COUNTS contains identical values. + TelemetryTestUtils.assertKeyedHistogramSum( + search_hist, + "other-MozSearch.abouthome", + 1 + ); + + // Also check events. + TelemetryTestUtils.assertEvents( + [ + { + object: "about_home", + value: "enter", + extra: { engine: "other-MozSearch" }, + }, + ], + { category: "navigation", method: "search" } + ); + + // Also also check Glean events. + const record = Glean.newtabSearch.issued.testGetValue(); + Assert.ok(!!record, "Must have recorded a search issuance"); + Assert.equal(record.length, 1, "One search, one event"); + Assert.deepEqual( + { + search_access_point: "about_home", + telemetry_id: "other-MozSearch", + }, + record[0].extra, + "Must have recorded the expected information." + ); + + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_adImpression_component.js b/browser/components/search/test/browser/browser_search_telemetry_adImpression_component.js new file mode 100644 index 0000000000..c9a4c6a8be --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_adImpression_component.js @@ -0,0 +1,401 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const WINDOW_HEIGHT = 768; +const WINDOW_WIDTH = 1024; + +// Note: example.org is used for the SERP page, and example.com is used to serve +// the ads. This is done to simulate different domains like the real servers. +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["mozAttr"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + included: { + parent: { + selector: ".moz-carousel", + }, + children: [ + { + selector: ".moz-carousel-card", + countChildren: true, + }, + ], + }, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS, + included: { + parent: { + selector: ".refined-search-buttons", + }, + children: [ + { + selector: "a", + }, + ], + }, + topDown: true, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + included: { + parent: { + selector: ".moz_ad", + }, + children: [ + { + selector: ".multi-col", + type: SearchSERPTelemetryUtils.COMPONENTS.AD_SITELINK, + }, + ], + }, + excluded: { + parent: { + selector: ".rhs", + }, + }, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_SIDEBAR, + included: { + parent: { + selector: ".rhs", + }, + }, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +async function promiseAdImpressionReceived() { + return TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length; + }, "Should have received an ad impression."); +} + +async function promiseResize(width, height) { + return TestUtils.waitForCondition(() => { + return window.outerWidth === width && window.outerHeight === height; + }, "Waiting for window to resize"); +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + // The tests evaluate whether or not ads are visible depending on whether + // they are within the view of the window. To ensure the test results + // are consistent regardless of where they are launched, + // set the window size to something reasonable. + let originalWidth = window.outerWidth; + let originalHeight = window.outerHeight; + window.resizeTo(WINDOW_WIDTH, WINDOW_HEIGHT); + await promiseResize(WINDOW_WIDTH, WINDOW_HEIGHT); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + window.resizeTo(originalWidth, originalHeight); + await promiseResize(originalWidth, originalHeight); + resetTelemetry(); + }); +}); + +add_task(async function test_ad_impressions_with_one_carousel() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_carousel.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + ads_loaded: "4", + ads_visible: "3", + ads_hidden: "0", + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// This is to ensure we're not counting two carousel components as two +// separate components but as one record with a sum of the results. +add_task(async function test_ad_impressions_with_two_carousels() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_carousel_doubled.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + // This is to ensure we've seen the other carousel regardless the + // size of the browser window. + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + let el = content.document + .getElementById("second-ad") + .getBoundingClientRect(); + // The 100 is just to guarantee we've scrolled past the element. + content.scrollTo(0, el.top + el.height + 100); + }); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + ads_loaded: "8", + ads_visible: "6", + ads_hidden: "0", + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task( + async function test_ad_impressions_with_carousels_with_outer_container() { + resetTelemetry(); + let url = getSERPUrl( + "searchTelemetryAd_components_carousel_outer_container.html" + ); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + ads_loaded: "4", + ads_visible: "3", + ads_hidden: "0", + }, + ]); + + BrowserTestUtils.removeTab(tab); + } +); + +add_task(async function test_ad_impressions_with_carousels_tabhistory() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_carousel.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await promiseAdImpressionReceived(); + + // Reset telemetry because we care about the telemetry upon going back. + resetTelemetry(); + + let browserLoadedPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + BrowserTestUtils.loadURIString( + tab.linkedBrowser, + "https://www.example.com/some_url" + ); + await browserLoadedPromise; + + let pageShowPromise = BrowserTestUtils.waitForContentEvent( + tab.linkedBrowser, + "pageshow" + ); + tab.linkedBrowser.goBack(); + await pageShowPromise; + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + ads_loaded: "4", + ads_visible: "3", + ads_hidden: "0", + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_ad_impressions_with_hidden_carousels() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_carousel_hidden.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + ads_loaded: "4", + ads_visible: "0", + ads_hidden: "4", + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_ad_impressions_with_carousel_scrolled_left() { + resetTelemetry(); + let url = getSERPUrl( + "searchTelemetryAd_components_carousel_first_element_non_visible.html" + ); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + ads_loaded: "4", + ads_visible: "2", + ads_hidden: "0", + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_ad_impressions_with_carousel_below_the_fold() { + resetTelemetry(); + let url = getSERPUrl( + "searchTelemetryAd_components_carousel_below_the_fold.html" + ); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + ads_loaded: "4", + ads_visible: "0", + ads_hidden: "0", + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_ad_impressions_with_text_links() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_SITELINK, + ads_loaded: "1", + ads_visible: "1", + ads_hidden: "0", + }, + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + ads_loaded: "2", + ads_visible: "2", + ads_hidden: "0", + }, + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_SIDEBAR, + ads_loaded: "1", + ads_visible: "1", + ads_hidden: "0", + }, + ]); + BrowserTestUtils.removeTab(tab); +}); + +// An ad is considered visible if at least one link is within the viewable +// content area when the impression was taken. Since the user can scroll +// the page before ad impression is recorded, we should ensure that an +// ad that was scrolled onto the screen before the impression is taken is +// properly recorded. Additionally, some ads might have a large content +// area that extends beyond the viewable area, but as long as a single +// ad link was viewable within the area, we should count the ads as visible. +add_task(async function test_ad_visibility() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_visibility.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => { + let el = content.document + .getElementById("second-ad") + .getBoundingClientRect(); + // The 100 is just to guarantee we've scrolled past the element. + content.scrollTo(0, el.top + el.height + 100); + }); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + ads_loaded: "6", + ads_visible: "4", + ads_hidden: "0", + }, + ]); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_impressions_without_ads() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await promiseAdImpressionReceived(); + + assertAdImpressionEvents([ + { + component: SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS, + ads_loaded: "1", + ads_visible: "1", + ads_hidden: "0", + }, + ]); + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_categorization_timing.js b/browser/components/search/test/browser/browser_search_telemetry_categorization_timing.js new file mode 100644 index 0000000000..69b43ae19a --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_categorization_timing.js @@ -0,0 +1,107 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Checks that telemetry on the runtime performance of categorizing the SERP + * works as normal. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetry(?:Ad)/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad2?/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + resetTelemetry(); + }); +}); + +add_task(async function test_tab_contains_measurement() { + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl("searchTelemetryAd_components_text.html") + ); + await waitForPageWithAdImpressions(); + + await Services.fog.testFlushAllChildren(); + Assert.ok( + Glean.serp.adImpression.testGetValue().length, + "Should have received ad impressions." + ); + + let durations = Glean.serp.categorizationDuration.testGetValue(); + Assert.ok(durations.sum > 0, "Sum should be more than 0."); + + BrowserTestUtils.removeTab(tab); +}); + +// If the user opened a SERP and closed it quickly or navigated away from it +// and no ad impressions were recorded, we shouldn't record a measurement. +add_task(async function test_before_ad_impressions_recorded() { + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl("searchTelemetryAd_components_text.html") + ); + BrowserTestUtils.removeTab(tab); + + Assert.ok( + !Glean.serp.adImpression.testGetValue(), + "Should not have an ad impression." + ); + + await Services.fog.testFlushAllChildren(); + let durations = Glean.serp.categorizationDuration.testGetValue(); + Assert.equal(durations, undefined, "Should not have received any values."); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_content.js b/browser/components/search/test/browser/browser_search_telemetry_content.js new file mode 100644 index 0000000000..b17604badd --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_content.js @@ -0,0 +1,204 @@ +"use strict"; + +const BASE_PROBE_NAME = "browser.engagement.navigation."; +const SCALAR_CONTEXT_MENU = BASE_PROBE_NAME + "contextmenu"; +const SCALAR_ABOUT_NEWTAB = BASE_PROBE_NAME + "about_newtab"; + +add_setup(async function () { + // Create two new search engines. Mark one as the default engine, so + // the test don't crash. We need to engines for this test as the searchbar + // in content doesn't display the default search engine among the one-off engines. + await SearchTestUtils.installSearchExtension( + { + name: "MozSearch", + keyword: "mozalias", + }, + { setAsDefault: true } + ); + await SearchTestUtils.installSearchExtension({ + name: "MozSearch2", + keyword: "mozalias2", + }); + + // Move the second engine at the beginning of the one-off list. + let engineOneOff = Services.search.getEngineByName("MozSearch2"); + await Services.search.moveEngine(engineOneOff, 0); + + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + + // Enable event recording for the events tested here. + Services.telemetry.setEventRecordingEnabled("navigation", true); + + registerCleanupFunction(async function () { + await PlacesUtils.history.clear(); + Services.telemetry.setEventRecordingEnabled("navigation", false); + Services.telemetry.canRecordExtended = oldCanRecord; + }); +}); + +add_task(async function test_context_menu() { + // Let's reset the Telemetry data. + Services.telemetry.clearScalars(); + Services.telemetry.clearEvents(); + let search_hist = + TelemetryTestUtils.getAndClearKeyedHistogram("SEARCH_COUNTS"); + + // Open a new tab with a page containing some text. + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "data:text/plain;charset=utf8,test%20search" + ); + + info("Select all the text in the page."); + await SpecialPowers.spawn(tab.linkedBrowser, [""], async function () { + return new Promise(resolve => { + content.document.addEventListener("selectionchange", () => resolve(), { + once: true, + }); + content.document.getSelection().selectAllChildren(content.document.body); + }); + }); + + info("Open the context menu."); + let contextMenu = document.getElementById("contentAreaContextMenu"); + let popupPromise = BrowserTestUtils.waitForEvent(contextMenu, "popupshown"); + BrowserTestUtils.synthesizeMouseAtCenter( + "body", + { type: "contextmenu", button: 2 }, + gBrowser.selectedBrowser + ); + await popupPromise; + + info("Click on search."); + let searchItem = contextMenu.getElementsByAttribute( + "id", + "context-searchselect" + )[0]; + contextMenu.activateItem(searchItem); + + info("Validate the search metrics."); + + // Telemetry is not updated synchronously here, we must wait for it. + await TestUtils.waitForCondition(() => { + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, false); + return Object.keys(scalars[SCALAR_CONTEXT_MENU] || {}).length == 1; + }, "This search must increment one entry in the scalar."); + + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, false); + TelemetryTestUtils.assertKeyedScalar( + scalars, + SCALAR_CONTEXT_MENU, + "search", + 1 + ); + + // Make sure SEARCH_COUNTS contains identical values. + TelemetryTestUtils.assertKeyedHistogramSum( + search_hist, + "other-MozSearch.contextmenu", + 1 + ); + + // Also check events. + TelemetryTestUtils.assertEvents( + [ + { + object: "contextmenu", + value: null, + extra: { engine: "other-MozSearch" }, + }, + ], + { category: "navigation", method: "search" } + ); + + contextMenu.hidePopup(); + BrowserTestUtils.removeTab(gBrowser.selectedTab); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_about_newtab() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar", + false, + ], + ], + }); + // Let's reset the counts. + Services.telemetry.clearScalars(); + Services.telemetry.clearEvents(); + Services.fog.testResetFOG(); + let search_hist = + TelemetryTestUtils.getAndClearKeyedHistogram("SEARCH_COUNTS"); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:newtab", + false + ); + await SpecialPowers.spawn(tab.linkedBrowser, [], async function () { + await ContentTaskUtils.waitForCondition(() => !content.document.hidden); + }); + + info("Trigger a simple serch, just text + enter."); + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + await typeInSearchField( + tab.linkedBrowser, + "test query", + "newtab-search-text" + ); + await BrowserTestUtils.synthesizeKey("VK_RETURN", {}, tab.linkedBrowser); + await p; + + // Check if the scalars contain the expected values. + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, false); + TelemetryTestUtils.assertKeyedScalar( + scalars, + SCALAR_ABOUT_NEWTAB, + "search_enter", + 1 + ); + Assert.equal( + Object.keys(scalars[SCALAR_ABOUT_NEWTAB]).length, + 1, + "This search must only increment one entry in the scalar." + ); + + // Make sure SEARCH_COUNTS contains identical values. + TelemetryTestUtils.assertKeyedHistogramSum( + search_hist, + "other-MozSearch.newtab", + 1 + ); + + // Also check events. + TelemetryTestUtils.assertEvents( + [ + { + object: "about_newtab", + value: "enter", + extra: { engine: "other-MozSearch" }, + }, + ], + { category: "navigation", method: "search" } + ); + + // Also also check Glean events. + const record = Glean.newtabSearch.issued.testGetValue(); + Assert.ok(!!record, "Must have recorded a search issuance"); + Assert.equal(record.length, 1, "One search, one event"); + Assert.deepEqual( + { + search_access_point: "about_newtab", + telemetry_id: "other-MozSearch", + }, + record[0].extra, + "Must have recorded the expected information." + ); + + BrowserTestUtils.removeTab(tab); + await SpecialPowers.popPrefEnv(); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_engagement_cached.js b/browser/components/search/test/browser/browser_search_telemetry_engagement_cached.js new file mode 100644 index 0000000000..6def0ef3ad --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_engagement_cached.js @@ -0,0 +1,199 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * These tests load SERPs and click on cacheable links. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["mozAttr"], + nonAdsLinkRegexps: [], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + included: { + parent: { + selector: ".moz-carousel", + }, + children: [ + { + selector: ".moz-carousel-card", + countChildren: true, + }, + ], + related: { + selector: "button", + }, + }, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + included: { + parent: { + selector: ".moz_ad", + }, + children: [ + { + selector: ".multi-col", + type: SearchSERPTelemetryUtils.COMPONENTS.AD_SITELINK, + }, + ], + related: { + selector: "button", + }, + }, + excluded: { + parent: { + selector: ".rhs", + }, + }, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + included: { + parent: { + selector: "form", + }, + children: [ + { + selector: "input", + }, + ], + related: { + selector: "div", + }, + }, + topDown: true, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +async function promiseImpressionReceived() { + return TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length; + }, "Should have received an ad impression."); +} + +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + resetTelemetry(); + }); +}); + +add_task(async function test_click_cached_page() { + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let cacheableUrl = + "https://example.com/browser/browser/components/search/test/browser/cacheable.html"; + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange( + gBrowser, + cacheableUrl + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "a#non_ads_link", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + gBrowser.goBack(); + await waitForPageWithAdImpressions(); + + pageLoadPromise = BrowserTestUtils.waitForLocationChange( + gBrowser, + cacheableUrl + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "a#non_ads_link", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "tabhistory", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_engagement_cached_serp.js b/browser/components/search/test/browser/browser_search_telemetry_engagement_cached_serp.js new file mode 100644 index 0000000000..26ebea5a56 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_engagement_cached_serp.js @@ -0,0 +1,239 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * These tests check when a SERP retrieves data from the BFCache as SERPs + * typically set their response headers with Cache-Control as private. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["mozAttr"], + nonAdsLinkRegexps: [/^https:\/\/example.com/], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + included: { + parent: { + selector: "form", + }, + children: [ + { + selector: "input", + }, + ], + related: { + selector: "div", + }, + }, + topDown: true, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getSERPUrl(page, term) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=${term}`; +} + +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + resetTelemetry(); + }); +}); + +async function goBack(tab, callback = async () => {}) { + info("Go back."); + let pageShowPromise = BrowserTestUtils.waitForContentEvent( + tab.linkedBrowser, + "pageshow" + ); + tab.linkedBrowser.goBack(); + await pageShowPromise; + await callback(); +} + +async function goForward(tab, callback = async () => {}) { + info("Go forward."); + let pageShowPromise = BrowserTestUtils.waitForContentEvent( + tab.linkedBrowser, + "pageshow" + ); + tab.linkedBrowser.goForward(); + await pageShowPromise; + await callback(); +} + +// This test loads a cached SERP and checks returning to it and interacting +// with elements on the page don't count the events more than once. +// This is a proxy for ensuring we remove event listeners. +add_task(async function test_cached_serp() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox.html"); + info("Load search page."); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + for (let index = 0; index < 3; ++index) { + info("Load non-search page."); + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser, true); + BrowserTestUtils.loadURIString( + tab.linkedBrowser, + "https://www.example.com" + ); + await loadPromise; + await goBack(tab, async () => { + await waitForPageWithAdImpressions(); + }); + } + + info("Click on searchbox."); + await BrowserTestUtils.synthesizeMouseAtCenter( + "input", + {}, + tab.linkedBrowser + ); + + await Services.fog.testFlushAllChildren(); + let engagements = Glean.serp.engagement.testGetValue() ?? []; + Assert.equal( + engagements.length, + 1, + "There should be 1 engagement event recorded." + ); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_back_and_forward_serp_to_serp() { + await SpecialPowers.pushPrefEnv({ + // This has to be disabled or else using back and forward in the test won't + // trigger responses in the network listener in SearchSERPTelemetry. The + // page will still load from a BFCache. + set: [["fission.bfcacheInParent", false]], + }); + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_searchbox.html"); + info("Load search page."); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser, false); + info("Click on a suggested search term."); + BrowserTestUtils.synthesizeMouseAtCenter("#suggest", {}, tab.linkedBrowser); + await loadPromise; + await waitForPageWithAdImpressions(); + + for (let index = 0; index < 3; ++index) { + info("Return to first search page."); + await goBack(tab, async () => { + await waitForPageWithAdImpressions(); + }); + info("Return to second search page."); + await goForward(tab, async () => { + await waitForPageWithAdImpressions(); + }); + } + + await Services.fog.testFlushAllChildren(); + let engagements = Glean.serp.engagement.testGetValue() ?? []; + let abandonments = Glean.serp.abandonment.testGetValue() ?? []; + Assert.equal(engagements.length, 1, "There should be 1 engagement."); + Assert.equal(abandonments.length, 6, "There should be 6 abandonments."); + + BrowserTestUtils.removeTab(tab); + await SpecialPowers.popPrefEnv(); +}); + +add_task(async function test_back_and_forward_content_to_serp_to_serp() { + await SpecialPowers.pushPrefEnv({ + // This has to be disabled or else using back and forward in the test won't + // trigger responses in the network listener in SearchSERPTelemetry. The + // page will still load from a BFCache. + set: [["fission.bfcacheInParent", false]], + }); + resetTelemetry(); + + info("Load non-search page."); + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "https://www.example.com/" + ); + + info("Load search page."); + let url = getSERPUrl("searchTelemetryAd_searchbox.html"); + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser, true); + BrowserTestUtils.loadURIString(tab.linkedBrowser, url); + await loadPromise; + await waitForPageWithAdImpressions(); + + loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser, false); + info("Click on a suggested search term."); + BrowserTestUtils.synthesizeMouseAtCenter("#suggest", {}, tab.linkedBrowser); + await loadPromise; + await waitForPageWithAdImpressions(); + + info("Return to first search page."); + await goBack(tab, async () => { + await waitForPageWithAdImpressions(); + }); + + info("Return to non-search page."); + await goBack(tab); + + info("Return to first search page."); + await goForward(tab, async () => { + await waitForPageWithAdImpressions(); + }); + + info("Return to second search page."); + await goForward(tab, async () => { + await waitForPageWithAdImpressions(); + }); + + await Services.fog.testFlushAllChildren(); + let engagements = Glean.serp.engagement.testGetValue() ?? []; + let abandonments = Glean.serp.abandonment.testGetValue() ?? []; + Assert.equal(engagements.length, 1, "There should be 1 engagement."); + Assert.equal(abandonments.length, 3, "There should be 3 abandonments."); + + BrowserTestUtils.removeTab(tab); + await SpecialPowers.popPrefEnv(); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_engagement_content.js b/browser/components/search/test/browser/browser_search_telemetry_engagement_content.js new file mode 100644 index 0000000000..e42fe4c293 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_engagement_content.js @@ -0,0 +1,486 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * These tests load a SERP that has multiple ways of refining a search term + * within content, or moving it into another search engine. It is also common + * for providers to remove tracking params. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_searchbox_with_content.html/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["mozAttr"], + nonAdsLinkRegexps: [ + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_searchbox_with_content_redirect.html/, + ], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad/], + shoppingTab: { + selector: "nav a", + regexp: "&page=shopping", + inspectRegexpInSERP: true, + }, + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + included: { + parent: { + selector: "form", + }, + children: [ + { + selector: "input", + }, + ], + related: { + selector: "div", + }, + }, + topDown: true, + nonAd: true, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS, + included: { + parent: { + selector: ".refined-search-buttons", + }, + children: [ + { + selector: "a", + }, + ], + }, + topDown: true, + nonAd: true, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +async function promiseImpressionReceived() { + return TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length; + }, "Should have received an ad impression."); +} + +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + resetTelemetry(); + }); +}); + +// "Tabs" are considered to be links the navigation of a SERP. Their hrefs +// may look similar to a search page, including related searches. +add_task(async function test_click_tab() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#images", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// Ensure that shopping links on a page with many non-ad link regular +// expressions doesn't get confused for a non-ads link. +add_task(async function test_click_shopping() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#shopping", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.SHOPPING_TAB, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "unknown", + is_shopping_page: "true", + shopping_tab_displayed: "true", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_click_related_search_in_new_tab() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_searchbox_with_content.html?s=test+one+two+three"; + + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, targetUrl, true); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#related-new-tab", + {}, + tab.linkedBrowser + ); + let tab2 = await tabPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "opened_in_new_tab", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); + BrowserTestUtils.removeTab(tab2); +}); + +// We consider regular expressions in nonAdsLinkRegexps and searchPageRegexp +// as valid non ads links when recording an engagement event. +add_task(async function test_click_redirect_search_in_newtab() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_searchbox_with_content.html?s=test+one+two+three"; + + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, targetUrl, true); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#related-redirect", + {}, + tab.linkedBrowser + ); + let tab2 = await tabPromise; + + await waitForPageWithAdImpressions(); + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "opened_in_new_tab", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); + BrowserTestUtils.removeTab(tab2); +}); + +// Ensure if a user does a search that uses one of the in-content sources, +// we clear the cached source value. +add_task(async function test_content_source_reset() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + // Do a text search to trigger a defined target. + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "form input", + {}, + tab.linkedBrowser + ); + EventUtils.synthesizeKey("KEY_Enter"); + await pageLoadPromise; + + // Click on a related search that will load within the same page and should + // have an unknown target. + await waitForPageWithAdImpressions(); + pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#related-in-page", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression.testGetValue()?.length == 3; + }, "Should have three impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + }, + { + action: SearchSERPTelemetryUtils.ACTIONS.SUBMITTED, + target: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "follow_on_from_refine_on_incontent_search", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// This test also deliberately includes an anchor with a reserved character in +// the href that gets parsed on page load. This is because when the URL is +// requested and observed in the network process, it is converted into a +// percent encoded string, so we want to ensure we're categorizing the +// component properly. This can happen with refinement buttons. +add_task(async function test_click_refinement_button() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_searchbox_with_content.html?s=test%27s"; + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange( + gBrowser, + targetUrl + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#refined-search-button", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "follow_on_from_refine_on_SERP", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_engagement_multiple_tabs.js b/browser/components/search/test/browser/browser_search_telemetry_engagement_multiple_tabs.js new file mode 100644 index 0000000000..8010434b88 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_engagement_multiple_tabs.js @@ -0,0 +1,225 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * This test ensures that recorded telemetry is consistent even with multiple + * tabs opened and closed. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["mozAttr"], + nonAdsLinkRegexps: [ + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_nonAdsLink_redirect/, + ], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + included: { + parent: { + selector: "form", + }, + children: [ + { + // This isn't contained in any of the HTML examples but the + // presence of the entry ensures that if it is not found during + // a topDown examination, the next element in the array is + // inspected and found. + selector: "textarea", + }, + { + selector: "input", + }, + ], + related: { + selector: "div", + }, + }, + topDown: true, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +// Deliberately make the web isolated process count as small as possible +// so that we don't have to create a ton of tabs to reuse a process. +const MAX_IPC = 1; +const TABS_TO_OPEN = 2; + +function getSERPUrl(page, term) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=${term}`; +} + +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ["dom.ipc.processCount.webIsolated", MAX_IPC], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + resetTelemetry(); + }); +}); + +async function do_test(tab, impressionId, switchTab) { + if (switchTab) { + await BrowserTestUtils.switchTab(gBrowser, tab); + } + await BrowserTestUtils.synthesizeMouseAtCenter( + "input", + {}, + tab.linkedBrowser + ); + + await BrowserTestUtils.synthesizeMouseAtCenter( + "a#images", + {}, + tab.linkedBrowser + ); + + await BrowserTestUtils.browserLoaded(tab.linkedBrowser, true); + + await Services.fog.testFlushAllChildren(); + let engagements = Glean.serp.engagement.testGetValue() ?? []; + Assert.equal(engagements.length, 2, "Should have two events recorded."); + + Assert.deepEqual( + engagements[0].extra, + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + impression_id: impressionId, + }, + "Search box engagement event should match." + ); + Assert.deepEqual( + engagements[1].extra, + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + impression_id: impressionId, + }, + "Non ads page engagement event should match." + ); + resetTelemetry(); +} + +// This test deliberately opens a lot of tabs to ensure SERPs share the +// same process. It interacts with the page to ensure the engagement +// has the correct recording, especially the impression id which can be out of +// sync if data in the child process isn't cached properly. +add_task(async function test_multiple_tabs_forward() { + resetTelemetry(); + + let tabs = []; + let pid; + + // Open multiple tabs. + for (let index = 0; index < TABS_TO_OPEN; ++index) { + let url = getSERPUrl( + "searchTelemetryAd_searchbox_with_content.html", + `hello+world+${index}` + ); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + tabs.push(tab); + let currentPid = E10SUtils.getBrowserPids(tab.linkedBrowser).at(0); + if (pid == null) { + pid = currentPid; + } else { + Assert.ok(pid == currentPid, "The process ID should be the same."); + } + } + + // Extract the impression IDs. + await Services.fog.testFlushAllChildren(); + let recordedImpressions = Glean.serp.impression.testGetValue() ?? []; + let impressionIds = recordedImpressions.map( + impression => impression.extra.impression_id + ); + + // Reset telemetry because we're not concerned about inspecting every + // impression event. + resetTelemetry(); + + for (let index = 0; index < TABS_TO_OPEN; ++index) { + let tab = tabs[index]; + let impressionId = impressionIds[index]; + await do_test(tab, impressionId, true); + BrowserTestUtils.removeTab(tab); + } +}); + +add_task(async function test_multiple_tabs_backward() { + resetTelemetry(); + + let tabs = []; + let pid; + + for (let index = 0; index < TABS_TO_OPEN; ++index) { + let url = getSERPUrl( + "searchTelemetryAd_searchbox_with_content.html", + `hello+world+${index}` + ); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + tabs.push(tab); + let currentPid = E10SUtils.getBrowserPids(tab.linkedBrowser).at(0); + if (pid == null) { + pid = currentPid; + } else { + Assert.ok(pid == currentPid, "The process ID should be the same."); + } + } + + // Extract the impression IDs. + await Services.fog.testFlushAllChildren(); + let recordedImpressions = Glean.serp.impression.testGetValue() ?? []; + let impressionIds = recordedImpressions.map( + impression => impression.extra.impression_id + ); + + // Reset telemetry because we're not concerned about inspecting every + // impression event. + resetTelemetry(); + + for (let index = TABS_TO_OPEN - 1; index >= 0; --index) { + let tab = tabs[index]; + let impressionId = impressionIds[index]; + await do_test(tab, impressionId, false); + BrowserTestUtils.removeTab(tab); + } +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_engagement_non_ad.js b/browser/components/search/test/browser/browser_search_telemetry_engagement_non_ad.js new file mode 100644 index 0000000000..ebec383e92 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_engagement_non_ad.js @@ -0,0 +1,164 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * These tests load SERPs and click on links that are non ads. Non ads can have + * slightly different behavior from ads. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["mozAttr"], + nonAdsLinkRegexps: [], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +async function promiseImpressionReceived() { + return TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length; + }, "Should have received an ad impression."); +} + +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + resetTelemetry(); + }); +}); + +// If an anchor is a non_ads_link and it doesn't match a non-ads regular +// expression, it should still be categorize it as a non ad. +add_task(async function test_click_non_ads_link() { + await waitForIdle(); + + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + // Click a non ad. + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#non_ads_link", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); + + // Reset state for other tests. + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); +}); + +// Click on an non-ad element while no ads are present. +add_task(async function test_click_non_ad_with_no_ads() { + await waitForIdle(); + + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_searchbox.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let browserLoadedPromise = BrowserTestUtils.browserLoaded( + tab.linkedBrowser, + true, + "https://example.com/hello_world" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#non_ads_link", + {}, + tab.linkedBrowser + ); + await browserLoadedPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); + + // Reset state for other tests. + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_engagement_redirect.js b/browser/components/search/test/browser/browser_search_telemetry_engagement_redirect.js new file mode 100644 index 0000000000..30c18b8059 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_engagement_redirect.js @@ -0,0 +1,346 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * These tests load SERPs and click on both ad and non-ad links that can be + * redirected. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["mozAttr"], + nonAdsLinkRegexps: [ + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_nonAdsLink_redirect.html/, + ], + extraAdServersRegexps: [ + /^https:\/\/example\.com\/ad/, + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/redirect_ad/, + ], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +async function promiseImpressionReceived() { + return TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length; + }, "Should have received an ad impression."); +} + +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + resetTelemetry(); + }); +}); + +add_task(async function test_click_non_ads_link_redirected() { + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = "https://example.com/hello_world"; + + let browserLoadedPromise = BrowserTestUtils.browserLoaded( + tab.linkedBrowser, + true, + targetUrl + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#non_ads_link_redirected", + {}, + tab.linkedBrowser + ); + + await browserLoadedPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// If a provider does a re-direct and we open it in a new tab, we should +// record the click and have the correct number of engagements. +add_task(async function test_click_non_ads_link_redirected_new_tab() { + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let redirectUrl = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_nonAdsLink_redirect.html"; + let targetUrl = "https://example.com/hello_world"; + + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, targetUrl, true); + + await SpecialPowers.spawn(tab.linkedBrowser, [redirectUrl], urls => { + content.document + .getElementById(["non_ads_link"]) + .addEventListener("click", e => { + e.preventDefault(); + content.window.open([urls], "_blank"); + }); + content.document.getElementById("non_ads_link").click(); + }); + let tab2 = await tabPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); + BrowserTestUtils.removeTab(tab2); +}); + +// Some providers load a URL of a non ad within a subframe before loading the +// target website in the top level frame. +add_task(async function test_click_non_ads_link_redirect_non_top_level() { + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = "https://example.com/hello_world"; + + let browserPromise = BrowserTestUtils.browserLoaded( + tab.linkedBrowser, + true, + targetUrl + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#non_ads_link_redirected_no_top_level", + {}, + tab.linkedBrowser + ); + + await browserPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_multiple_redirects_non_ad_link() { + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = "https://example.com/hello_world"; + + let browserLoadedPromise = BrowserTestUtils.browserLoaded( + tab.linkedBrowser, + true, + targetUrl + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#non_ads_link_multiple_redirects", + {}, + tab.linkedBrowser + ); + + await browserLoadedPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_click_ad_link_redirected() { + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = "https://example.com/hello_world"; + + let browserLoadedPromise = BrowserTestUtils.browserLoaded( + tab.linkedBrowser, + true, + targetUrl + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#ad_link_redirect", + {}, + tab.linkedBrowser + ); + + await browserLoadedPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_click_ad_link_redirected_new_tab() { + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = "https://example.com/hello_world"; + + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, targetUrl, true); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#ad_link_redirect", + { button: 1 }, + tab.linkedBrowser + ); + let tab2 = await tabPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); + BrowserTestUtils.removeTab(tab2); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_engagement_target.js b/browser/components/search/test/browser/browser_search_telemetry_engagement_target.js new file mode 100644 index 0000000000..d29169b776 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_engagement_target.js @@ -0,0 +1,433 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * These tests load SERPs and click on links that can either be ads or non ads + * and verifies that the engagement events and the target associated with them + * are correct. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["mozAttr"], + nonAdsLinkRegexps: [ + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_nonAdsLink_redirect.html/, + ], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + included: { + parent: { + selector: ".moz-carousel", + }, + children: [ + { + selector: ".moz-carousel-card", + countChildren: true, + }, + ], + related: { + selector: "button", + }, + }, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + included: { + parent: { + selector: ".moz_ad", + }, + children: [ + { + selector: ".multi-col", + type: SearchSERPTelemetryUtils.COMPONENTS.AD_SITELINK, + }, + ], + related: { + selector: "button", + }, + }, + excluded: { + parent: { + selector: ".rhs", + }, + }, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + included: { + parent: { + selector: "form", + }, + children: [ + { + // This isn't contained in any of the HTML examples but the + // presence of the entry ensures that if it is not found during + // a topDown examination, the next element in the array is + // inspected and found. + selector: "textarea", + }, + { + selector: "input", + }, + ], + related: { + selector: "div", + }, + }, + topDown: true, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +// This is used to check if not providing an nonAdsLinkRegexp can still +// reliably categorize non_ads_links. +const TEST_PROVIDER_INFO_NO_NON_ADS_REGEXP = [ + { + ...TEST_PROVIDER_INFO[0], + nonAdsLinkRegexps: [], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +async function promiseImpressionReceived() { + return TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length; + }, "Should have received an ad impression."); +} + +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + resetTelemetry(); + }); +}); + +// This test ensures clicking a non-first link in a component registers the +// proper component. This is because the first link of a component does the +// heavy lifting in finding the parent and best categorization of the +// component. Subsequent anchors that have the same parent get grouped into it. +// Additionally, this test deliberately has ads with different paths so that +// there are no collisions in hrefs. +add_task(async function test_click_second_ad_in_component() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#deep_ad_sitelink", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_SITELINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// If a provider appends query parameters to a link after the page has been +// parsed, we should still be able to record the click. +add_task(async function test_click_ads_link_modified() { + resetTelemetry(); + + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let browserLoadedPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + await SpecialPowers.spawn(tab.linkedBrowser, [], () => { + let target = content.document.getElementById("deep_ad_sitelink"); + let href = target.getAttribute("href"); + target.setAttribute("href", href + "?foo=bar"); + content.document.getElementById("deep_ad_sitelink").click(); + }); + await browserLoadedPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_SITELINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// Search box is a special case which has to be tracked in the child process. +add_task(async function test_click_and_submit_incontent_searchbox() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + // Click on the searchbox. + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser, url); + await BrowserTestUtils.synthesizeMouseAtCenter( + "form input", + {}, + tab.linkedBrowser + ); + EventUtils.synthesizeKey("KEY_Enter"); + await pageLoadPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + }, + { + action: SearchSERPTelemetryUtils.ACTIONS.SUBMITTED, + target: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "follow_on_from_refine_on_incontent_search", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// Click an auto-suggested term. The element that is clicked is related +// to the searchbox but not in search-telemetry-v2 because it can be too +// difficult to determine ahead of time since the elements are generated +// dynamically. So instead it should listen to an element higher in the DOM. +add_task(async function test_click_autosuggest() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + // Click an autosuggested term. + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser, url); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#suggest", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.SUBMITTED, + target: SearchSERPTelemetryUtils.COMPONENTS.INCONTENT_SEARCHBOX, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "follow_on_from_refine_on_incontent_search", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// Carousel related buttons expand content. +add_task(async function test_click_carousel_expand() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_carousel.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + // Click a button that is expected to expand. + await SpecialPowers.spawn(tab.linkedBrowser, [], () => { + content.document.querySelector("button").click(); + }); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.EXPANDED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_CAROUSEL, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +// This test clicks a link that has apostrophes in the both the path and list +// of query parameters, and uses search telemetry with no nonAdsRegexps defined, +// which will force us to cache every non ads link in a map and pass it back to +// the parent. +// If this test fails, it means we're doing the conversion wrong, because when +// we observe the clicked URL in the parent process, it should look exactly the +// same as how it was saved in the hrefToComponent map. +add_task(async function test_click_link_with_special_characters_in_path() { + SearchSERPTelemetry.overrideSearchTelemetryForTests( + TEST_PROVIDER_INFO_NO_NON_ADS_REGEXP + ); + await waitForIdle(); + + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_components_text.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange( + gBrowser, + "https://example.com/path'?hello_world&foo=bar%27s" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#non_ads_link_with_special_characters_in_path", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); + + // Reset state for other tests. + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_searchbar.js b/browser/components/search/test/browser/browser_search_telemetry_searchbar.js new file mode 100644 index 0000000000..15f512452a --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_searchbar.js @@ -0,0 +1,440 @@ +"use strict"; + +const SCALAR_SEARCHBAR = "browser.engagement.navigation.searchbar"; + +ChromeUtils.defineESModuleGetters(this, { + UrlbarTestUtils: "resource://testing-common/UrlbarTestUtils.sys.mjs", +}); + +let suggestionEngine; + +function checkHistogramResults(resultIndexes, expected, histogram) { + for (let [i, val] of Object.entries(resultIndexes.values)) { + if (i == expected) { + Assert.equal( + val, + 1, + `expected counts should match for ${histogram} index ${i}` + ); + } else { + Assert.equal( + !!val, + false, + `unexpected counts should be zero for ${histogram} index ${i}` + ); + } + } +} + +/** + * Click one of the entries in the search suggestion popup. + * + * @param {string} entryName + * The name of the elemet to click on. + * @param {object} [clickOptions] + * The options to use for the click. + */ +function clickSearchbarSuggestion(entryName, clickOptions = {}) { + let richlistbox = BrowserSearch.searchBar.textbox.popup.richlistbox; + let richlistitem = Array.prototype.find.call( + richlistbox.children, + item => item.getAttribute("ac-value") == entryName + ); + + // Make sure the suggestion is visible and simulate the click. + richlistbox.ensureElementIsVisible(richlistitem); + EventUtils.synthesizeMouseAtCenter(richlistitem, clickOptions); +} + +add_setup(async function () { + await gCUITestUtils.addSearchBar(); + const url = getRootDirectory(gTestPath) + "telemetrySearchSuggestions.xml"; + suggestionEngine = await SearchTestUtils.promiseNewSearchEngine({ url }); + + registerCleanupFunction(() => { + gCUITestUtils.removeSearchBar(); + }); + + // Create two new search engines. Mark one as the default engine, so + // the test don't crash. We need to engines for this test as the searchbar + // doesn't display the default search engine among the one-off engines. + await SearchTestUtils.installSearchExtension( + { + name: "MozSearch", + keyword: "mozalias", + }, + { setAsDefault: true } + ); + await SearchTestUtils.installSearchExtension({ + name: "MozSearch2", + keyword: "mozalias2", + }); + + // Move the second engine at the beginning of the one-off list. + let engineOneOff = Services.search.getEngineByName("MozSearch2"); + await Services.search.moveEngine(engineOneOff, 0); + + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + + // Enable event recording for the events tested here. + Services.telemetry.setEventRecordingEnabled("navigation", true); + + registerCleanupFunction(async function () { + Services.telemetry.canRecordExtended = oldCanRecord; + Services.telemetry.setEventRecordingEnabled("navigation", false); + }); +}); + +add_task(async function test_plainQuery() { + // Let's reset the counts. + Services.telemetry.clearScalars(); + Services.telemetry.clearEvents(); + let resultMethodHist = TelemetryTestUtils.getAndClearHistogram( + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + let search_hist = + TelemetryTestUtils.getAndClearKeyedHistogram("SEARCH_COUNTS"); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + + info("Simulate entering a simple search."); + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + await searchInSearchbar("simple query"); + EventUtils.synthesizeKey("KEY_Enter"); + await p; + + // Check if the scalars contain the expected values. + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, false); + TelemetryTestUtils.assertKeyedScalar( + scalars, + SCALAR_SEARCHBAR, + "search_enter", + 1 + ); + Assert.equal( + Object.keys(scalars[SCALAR_SEARCHBAR]).length, + 1, + "This search must only increment one entry in the scalar." + ); + + // Make sure SEARCH_COUNTS contains identical values. + TelemetryTestUtils.assertKeyedHistogramSum( + search_hist, + "other-MozSearch.searchbar", + 1 + ); + + // Also check events. + TelemetryTestUtils.assertEvents( + [ + { + object: "searchbar", + value: "enter", + extra: { engine: "other-MozSearch" }, + }, + ], + { category: "navigation", method: "search" } + ); + + // Check the histograms as well. + let resultMethods = resultMethodHist.snapshot(); + checkHistogramResults( + resultMethods, + UrlbarTestUtils.SELECTED_RESULT_METHODS.enter, + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + BrowserTestUtils.removeTab(tab); +}); + +// Performs a search using the first result, a one-off button, and the Return +// (Enter) key. +add_task(async function test_oneOff_enter() { + // Let's reset the counts. + Services.telemetry.clearScalars(); + Services.telemetry.clearEvents(); + let resultMethodHist = TelemetryTestUtils.getAndClearHistogram( + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + let search_hist = + TelemetryTestUtils.getAndClearKeyedHistogram("SEARCH_COUNTS"); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + + info("Perform a one-off search using the first engine."); + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + await searchInSearchbar("query"); + + info("Pressing Alt+Down to highlight the first one off engine."); + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + EventUtils.synthesizeKey("KEY_Enter"); + await p; + + // Check if the scalars contain the expected values. + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, false); + TelemetryTestUtils.assertKeyedScalar( + scalars, + SCALAR_SEARCHBAR, + "search_oneoff", + 1 + ); + Assert.equal( + Object.keys(scalars[SCALAR_SEARCHBAR]).length, + 1, + "This search must only increment one entry in the scalar." + ); + + // Make sure SEARCH_COUNTS contains identical values. + TelemetryTestUtils.assertKeyedHistogramSum( + search_hist, + "other-MozSearch2.searchbar", + 1 + ); + + // Also check events. + TelemetryTestUtils.assertEvents( + [ + { + object: "searchbar", + value: "oneoff", + extra: { engine: "other-MozSearch2" }, + }, + ], + { category: "navigation", method: "search" } + ); + + // Check the histograms as well. + let resultMethods = resultMethodHist.snapshot(); + checkHistogramResults( + resultMethods, + UrlbarTestUtils.SELECTED_RESULT_METHODS.enter, + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + BrowserTestUtils.removeTab(tab); +}); + +// Performs a search using the second result, a one-off button, and the Return +// (Enter) key. This only tests the FX_SEARCHBAR_SELECTED_RESULT_METHOD +// histogram since test_oneOff_enter covers everything else. +add_task(async function test_oneOff_enterSelection() { + // Let's reset the counts. + Services.telemetry.clearScalars(); + let resultMethodHist = TelemetryTestUtils.getAndClearHistogram( + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + let previousEngine = await Services.search.getDefault(); + await Services.search.setDefault( + suggestionEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + + info("Type a query. Suggestions should be generated by the test engine."); + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + await searchInSearchbar("query"); + + info( + "Select the second result, press Alt+Down to take us to the first one-off engine." + ); + EventUtils.synthesizeKey("KEY_ArrowDown"); + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + EventUtils.synthesizeKey("KEY_Enter"); + await p; + + let resultMethods = resultMethodHist.snapshot(); + checkHistogramResults( + resultMethods, + UrlbarTestUtils.SELECTED_RESULT_METHODS.enterSelection, + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + await Services.search.setDefault( + previousEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + BrowserTestUtils.removeTab(tab); +}); + +// Performs a search using a click on a one-off button. This only tests the +// FX_SEARCHBAR_SELECTED_RESULT_METHOD histogram since test_oneOff_enter covers +// everything else. +add_task(async function test_oneOff_click() { + // Let's reset the counts. + Services.telemetry.clearScalars(); + let resultMethodHist = TelemetryTestUtils.getAndClearHistogram( + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + + info("Type a query."); + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + let popup = await searchInSearchbar("query"); + info("Click the first one-off button."); + popup.oneOffButtons.getSelectableButtons(false)[0].click(); + await p; + + let resultMethods = resultMethodHist.snapshot(); + checkHistogramResults( + resultMethods, + UrlbarTestUtils.SELECTED_RESULT_METHODS.click, + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + BrowserTestUtils.removeTab(tab); +}); + +async function checkSuggestionClick(clickOptions, waitForActionFn) { + // Let's reset the counts. + Services.telemetry.clearScalars(); + Services.telemetry.clearEvents(); + let resultMethodHist = TelemetryTestUtils.getAndClearHistogram( + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + let search_hist = + TelemetryTestUtils.getAndClearKeyedHistogram("SEARCH_COUNTS"); + + let previousEngine = await Services.search.getDefault(); + await Services.search.setDefault( + suggestionEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + + info("Perform a one-off search using the first engine."); + let p = waitForActionFn(tab); + await searchInSearchbar("query"); + info("Clicking the searchbar suggestion."); + clickSearchbarSuggestion("queryfoo", clickOptions); + await p; + + // Check if the scalars contain the expected values. + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, false); + TelemetryTestUtils.assertKeyedScalar( + scalars, + SCALAR_SEARCHBAR, + "search_suggestion", + 1 + ); + Assert.equal( + Object.keys(scalars[SCALAR_SEARCHBAR]).length, + 1, + "This search must only increment one entry in the scalar." + ); + + // Make sure SEARCH_COUNTS contains identical values. + let searchEngineId = "other-" + suggestionEngine.name; + TelemetryTestUtils.assertKeyedHistogramSum( + search_hist, + searchEngineId + ".searchbar", + 1 + ); + + // Also check events. + TelemetryTestUtils.assertEvents( + [ + { + object: "searchbar", + value: "suggestion", + extra: { engine: searchEngineId }, + }, + ], + { category: "navigation", method: "search" } + ); + + // Check the histograms as well. + let resultMethods = resultMethodHist.snapshot(); + checkHistogramResults( + resultMethods, + UrlbarTestUtils.SELECTED_RESULT_METHODS.click, + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + await Services.search.setDefault( + previousEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + BrowserTestUtils.removeTab(tab); +} + +// Clicks the first suggestion offered by the test search engine. +add_task(async function test_suggestion_click() { + await checkSuggestionClick({}, tab => { + return BrowserTestUtils.browserLoaded(tab.linkedBrowser); + }); +}); + +add_task(async function test_suggestion_middle_click() { + let openedTab; + await checkSuggestionClick({ button: 1 }, () => { + return BrowserTestUtils.waitForNewTab(gBrowser, "http://example.com/").then( + tab => (openedTab = tab) + ); + }); + BrowserTestUtils.removeTab(openedTab); +}); + +// Selects and presses the Return (Enter) key on the first suggestion offered by +// the test search engine. This only tests the +// FX_SEARCHBAR_SELECTED_RESULT_METHOD histogram since test_suggestion_click +// covers everything else. +add_task(async function test_suggestion_enterSelection() { + // Let's reset the counts. + Services.telemetry.clearScalars(); + let resultMethodHist = TelemetryTestUtils.getAndClearHistogram( + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + let previousEngine = await Services.search.getDefault(); + await Services.search.setDefault( + suggestionEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + + info("Type a query. Suggestions should be generated by the test engine."); + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + await searchInSearchbar("query"); + info("Select the second result and press Return."); + EventUtils.synthesizeKey("KEY_ArrowDown"); + EventUtils.synthesizeKey("KEY_Enter"); + await p; + + let resultMethods = resultMethodHist.snapshot(); + checkHistogramResults( + resultMethods, + UrlbarTestUtils.SELECTED_RESULT_METHODS.enterSelection, + "FX_SEARCHBAR_SELECTED_RESULT_METHOD" + ); + + await Services.search.setDefault( + previousEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_shopping.js b/browser/components/search/test/browser/browser_search_telemetry_shopping.js new file mode 100644 index 0000000000..2623562a8f --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_shopping.js @@ -0,0 +1,149 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * Check the existence of a shopping tab and navigation to a shopping page. + * Most existing tests don't include shopping tabs, so this explicitly loads a + * page with a shopping tab and clicks on it. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +// The setup for each test is the same, the only differences are the various +// permutations of the search tests. +const BASE_TEST_PROVIDER = { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + extraAdServersRegexps: [/^https:\/\/example\.org\/ad/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], +}; + +const TEST_PROVIDER_INFO_1 = [ + { + ...BASE_TEST_PROVIDER, + shoppingTab: { + selector: "nav a", + regexp: "&page=shopping&", + inspectRegexpInSERP: true, + }, + }, +]; + +const TEST_PROVIDER_INFO_2 = [ + { + ...BASE_TEST_PROVIDER, + shoppingTab: { + selector: "nav a#shopping", + regexp: "&page=shopping&", + inspectRegexpInSERP: false, + }, + }, +]; + +function getSERPUrl(page) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test&abc=ff`; +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO_1); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + resetTelemetry(); + }); +}); + +async function loadSerpAndClickShoppingTab(page) { + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(page) + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + }, + ]); + await waitForPageWithAdImpressions(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + BrowserTestUtils.synthesizeMouseAtCenter("#shopping", {}, tab.linkedBrowser); + await pageLoadPromise; + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "true", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.SHOPPING_TAB, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +} + +add_task(async function test_inspect_shopping_tab_regexp_on_serp() { + resetTelemetry(); + await loadSerpAndClickShoppingTab("searchTelemetryAd_shopping.html"); +}); + +add_task(async function test_no_inspect_shopping_tab_regexp_on_serp() { + resetTelemetry(); + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO_2); + await waitForIdle(); + await loadSerpAndClickShoppingTab("searchTelemetryAd_shopping.html"); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_sources.js b/browser/components/search/test/browser/browser_search_telemetry_sources.js new file mode 100644 index 0000000000..173bc09694 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_sources.js @@ -0,0 +1,497 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Main tests for SearchSERPTelemetry - general engine visiting and link clicking. + * + * NOTE: As this test file is already fairly long-running, adding to this file + * will likely cause timeout errors with test-verify jobs on Treeherder. + * Therefore, please do not add further tasks to this file. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetry(?:Ad)?/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad2?/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getPageUrl(useAdPage = false) { + let page = useAdPage ? "searchTelemetryAd.html" : "searchTelemetry.html"; + return `https://example.org/browser/browser/components/search/test/browser/${page}`; +} + +/** + * Returns the index of the first search suggestion in the urlbar results. + * + * @returns {number} An index, or -1 if there are no search suggestions. + */ +async function getFirstSuggestionIndex() { + const matchCount = UrlbarTestUtils.getResultCount(window); + for (let i = 0; i < matchCount; i++) { + let result = await UrlbarTestUtils.getDetailsOfResultAt(window, i); + if ( + result.type == UrlbarUtils.RESULT_TYPE.SEARCH && + result.searchParams.suggestion + ) { + return i; + } + } + return -1; +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +SearchTestUtils.init(this); + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.urlbar.suggest.searches", true], + [ + "browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar", + true, + ], + // Ensure to add search suggestion telemetry as search_suggestion not search_formhistory. + ["browser.urlbar.maxHistoricalSearchSuggestions", 0], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + Services.prefs.setBoolPref("browser.search.log", true); + + await SearchTestUtils.installSearchExtension( + { + search_url: getPageUrl(true), + search_url_get_params: "s={searchTerms}&abc=ff", + suggest_url: + "https://example.org/browser/browser/components/search/test/browser/searchSuggestionEngine.sjs", + suggest_url_get_params: "query={searchTerms}", + }, + { setAsDefault: true } + ); + + await gCUITestUtils.addSearchBar(); + + registerCleanupFunction(async () => { + gCUITestUtils.removeSearchBar(); + Services.prefs.clearUserPref("browser.search.log"); + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + resetTelemetry(); + }); +}); + +async function track_ad_click( + expectedHistogramSource, + expectedScalarSource, + searchAdsFn, + cleanupFn +) { + searchCounts.clear(); + Services.telemetry.clearScalars(); + + let expectedContentScalarKey = "example:tagged:ff"; + let expectedScalarKey = "example:tagged"; + let expectedHistogramSAPSourceKey = `other-Example.${expectedHistogramSource}`; + let expectedContentScalar = `browser.search.content.${expectedScalarSource}`; + let expectedWithAdsScalar = `browser.search.withads.${expectedScalarSource}`; + let expectedAdClicksScalar = `browser.search.adclicks.${expectedScalarSource}`; + + let tab = await searchAdsFn(); + + await assertSearchSourcesTelemetry( + { + [expectedHistogramSAPSourceKey]: 1, + }, + { + [expectedContentScalar]: { [expectedContentScalarKey]: 1 }, + [expectedWithAdsScalar]: { [expectedScalarKey]: 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: expectedScalarSource, + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + // Ad impression data is needed to categorize ads on the page in order to + // register ad click events before a click occurs. We don't assert their + // precise values here because other tests cover that the component + // categorizations are valid. + await promiseAdImpressionReceived(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + BrowserTestUtils.synthesizeMouseAtCenter("#ad1", {}, tab.linkedBrowser); + await pageLoadPromise; + await promiseWaitForAdLinkCheck(); + + await assertSearchSourcesTelemetry( + { + [expectedHistogramSAPSourceKey]: 1, + }, + { + [expectedContentScalar]: { [expectedContentScalarKey]: 1 }, + [expectedWithAdsScalar]: { [expectedScalarKey]: 1 }, + [expectedAdClicksScalar]: { [expectedScalarKey]: 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: expectedScalarSource, + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); + + await cleanupFn(); + + Services.fog.testResetFOG(); +} + +add_task(async function test_source_urlbar() { + let tab; + await track_ad_click( + "urlbar", + "urlbar", + async () => { + tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + await UrlbarTestUtils.promiseAutocompleteResultPopup({ + window, + value: "searchSuggestion", + }); + let idx = await getFirstSuggestionIndex(); + Assert.greaterOrEqual(idx, 0, "there should be a first suggestion"); + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + while (idx--) { + EventUtils.sendKey("down"); + } + EventUtils.sendKey("return"); + await loadPromise; + return tab; + }, + async () => { + BrowserTestUtils.removeTab(tab); + } + ); +}); + +add_task(async function test_source_urlbar_handoff() { + let tab; + await track_ad_click( + "urlbar-handoff", + "urlbar_handoff", + async () => { + Services.fog.testResetFOG(); + tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + BrowserTestUtils.loadURIString(tab.linkedBrowser, "about:newtab"); + await BrowserTestUtils.browserStopped(tab.linkedBrowser, "about:newtab"); + + info("Focus on search input in newtab content"); + await BrowserTestUtils.synthesizeMouseAtCenter( + ".fake-editable", + {}, + tab.linkedBrowser + ); + + info("Get suggestions"); + for (const c of "searchSuggestion".split("")) { + EventUtils.synthesizeKey(c); + /* eslint-disable mozilla/no-arbitrary-setTimeout */ + await new Promise(r => setTimeout(r, 50)); + } + await TestUtils.waitForCondition(async () => { + const index = await getFirstSuggestionIndex(); + return index >= 0; + }, "Wait until suggestions are ready"); + + let idx = await getFirstSuggestionIndex(); + Assert.greaterOrEqual(idx, 0, "there should be a first suggestion"); + const onLoaded = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + while (idx--) { + EventUtils.sendKey("down"); + } + EventUtils.sendKey("return"); + await onLoaded; + + return tab; + }, + async () => { + const issueRecords = Glean.newtabSearch.issued.testGetValue(); + Assert.ok(!!issueRecords, "Must have recorded a search issuance"); + Assert.equal(issueRecords.length, 1, "One search, one event"); + const newtabVisitId = issueRecords[0].extra.newtab_visit_id; + Assert.ok(!!newtabVisitId, "Must have a visit id"); + Assert.deepEqual( + { + // Yes, this is tautological. But I want to use deepEqual. + newtab_visit_id: newtabVisitId, + search_access_point: "urlbar_handoff", + telemetry_id: "other-Example", + }, + issueRecords[0].extra, + "Must have recorded the expected information." + ); + const impRecords = Glean.newtabSearchAd.impression.testGetValue(); + Assert.equal(impRecords.length, 1, "One impression, one event."); + Assert.deepEqual( + { + newtab_visit_id: newtabVisitId, + search_access_point: "urlbar_handoff", + telemetry_id: "example", + is_tagged: "true", + is_follow_on: "false", + }, + impRecords[0].extra, + "Must have recorded the expected information." + ); + const clickRecords = Glean.newtabSearchAd.click.testGetValue(); + Assert.equal(clickRecords.length, 1, "One click, one event."); + Assert.deepEqual( + { + newtab_visit_id: newtabVisitId, + search_access_point: "urlbar_handoff", + telemetry_id: "example", + is_tagged: "true", + is_follow_on: "false", + }, + clickRecords[0].extra, + "Must have recorded the expected information." + ); + BrowserTestUtils.removeTab(tab); + } + ); +}); + +add_task(async function test_source_searchbar() { + let tab; + await track_ad_click( + "searchbar", + "searchbar", + async () => { + tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + let sb = BrowserSearch.searchBar; + // Write the search query in the searchbar. + sb.focus(); + sb.value = "searchSuggestion"; + sb.textbox.controller.startSearch("searchSuggestion"); + // Wait for the popup to show. + await BrowserTestUtils.waitForEvent(sb.textbox.popup, "popupshown"); + // And then for the search to complete. + await BrowserTestUtils.waitForCondition( + () => + sb.textbox.controller.searchStatus >= + Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH, + "The search in the searchbar must complete." + ); + + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + EventUtils.synthesizeKey("KEY_Enter"); + await loadPromise; + return tab; + }, + async () => { + BrowserTestUtils.removeTab(tab); + } + ); +}); + +async function checkAboutPage( + page, + expectedHistogramSource, + expectedScalarSource +) { + let tab; + await track_ad_click( + expectedHistogramSource, + expectedScalarSource, + async () => { + tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + BrowserTestUtils.loadURIString(tab.linkedBrowser, page); + await BrowserTestUtils.browserStopped(tab.linkedBrowser, page); + + // Wait for the full load. + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "browser.newtabpage.activity-stream.improvesearch.handoffToAwesomebar", + false, + ], + ], + }); + await SpecialPowers.spawn(tab.linkedBrowser, [], async function () { + await ContentTaskUtils.waitForCondition( + () => content.wrappedJSObject.gContentSearchController.defaultEngine + ); + }); + + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + await typeInSearchField( + tab.linkedBrowser, + "test query", + "newtab-search-text" + ); + await BrowserTestUtils.synthesizeKey("VK_RETURN", {}, tab.linkedBrowser); + await p; + return tab; + }, + async () => { + BrowserTestUtils.removeTab(tab); + await SpecialPowers.popPrefEnv(); + } + ); +} + +add_task(async function test_source_about_home() { + await checkAboutPage("about:home", "abouthome", "about_home"); +}); + +add_task(async function test_source_about_newtab() { + await checkAboutPage("about:newtab", "newtab", "about_newtab"); +}); + +add_task(async function test_source_system() { + let tab; + await track_ad_click( + "system", + "system", + async () => { + tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + // This is not quite the same as calling from the commandline, but close + // enough for this test. + BrowserSearch.loadSearchFromCommandLine( + "searchSuggestion", + false, + Services.scriptSecurityManager.getSystemPrincipal(), + gBrowser.selectedBrowser.csp + ); + + await loadPromise; + return tab; + }, + async () => { + BrowserTestUtils.removeTab(tab); + } + ); +}); + +add_task(async function test_source_webextension_search() { + /* global browser */ + async function background(SEARCH_TERM) { + // Search with no tabId + browser.search.search({ query: "searchSuggestion", engine: "Example" }); + } + + let searchExtension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["search", "tabs"], + }, + background, + useAddonManager: "temporary", + }); + + let tab; + await track_ad_click( + "webextension", + "webextension", + async () => { + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true); + + await searchExtension.startup(); + + return (tab = await tabPromise); + }, + async () => { + await searchExtension.unload(); + BrowserTestUtils.removeTab(tab); + } + ); +}); + +add_task(async function test_source_webextension_query() { + async function background(SEARCH_TERM) { + // Search with no tabId + browser.search.query({ + text: "searchSuggestion", + disposition: "NEW_TAB", + }); + } + + let searchExtension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["search", "tabs"], + }, + background, + useAddonManager: "temporary", + }); + + let tab; + await track_ad_click( + "webextension", + "webextension", + async () => { + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true); + + await searchExtension.startup(); + + return (tab = await tabPromise); + }, + async () => { + await searchExtension.unload(); + BrowserTestUtils.removeTab(tab); + } + ); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_sources_ads.js b/browser/components/search/test/browser/browser_search_telemetry_sources_ads.js new file mode 100644 index 0000000000..880497f993 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_sources_ads.js @@ -0,0 +1,841 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Main tests for SearchSERPTelemetry - general engine visiting and link clicking. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +// Note: example.org is used for the SERP page, and example.com is used to serve +// the ads. This is done to simulate different domains like the real servers. +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetry(?:Ad)?.html/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad2?/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, + { + telemetryId: "example-data-attributes", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetryAd_dataAttributes(?:_none|_href)?.html/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + adServerAttributes: ["xyz"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, + { + telemetryId: "slow-page-load", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/slow_loading_page_with_ads(_on_load_event)?.html/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad2?/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getPageUrl(useAdPage = false) { + let page = useAdPage ? "searchTelemetryAd.html" : "searchTelemetry.html"; + return `https://example.org/browser/browser/components/search/test/browser/${page}`; +} + +function getSERPUrl(page, organic = false) { + return `${page}?s=test${organic ? "" : "&abc=ff"}`; +} + +function getSERPFollowOnUrl(page) { + return page + "?s=test&abc=ff&a=foo"; +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.log", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + + registerCleanupFunction(async () => { + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + resetTelemetry(); + }); +}); + +add_task(async function test_simple_search_page_visit() { + resetTelemetry(); + + await BrowserTestUtils.withNewTab( + { + gBrowser, + url: getSERPUrl(getPageUrl()), + }, + async () => { + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "example:tagged:ff": 1 }, + } + ); + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); +}); + +add_task(async function test_simple_search_page_visit_telemetry() { + resetTelemetry(); + + await BrowserTestUtils.withNewTab( + { + gBrowser, + /* URL must not be in the cache */ + url: getSERPUrl(getPageUrl()) + `&random=${Math.random()}`, + }, + async () => { + let scalars = {}; + const key = "browser.search.data_transferred"; + + await TestUtils.waitForCondition(() => { + scalars = + Services.telemetry.getSnapshotForKeyedScalars("main", false).parent || + {}; + return key in scalars; + }, "should have the expected keyed scalars"); + + const scalar = scalars[key]; + Assert.ok("example" in scalar, "correct telemetry category"); + Assert.notEqual(scalars[key].example, 0, "bandwidth logged"); + } + ); + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); +}); + +add_task(async function test_follow_on_visit() { + await BrowserTestUtils.withNewTab( + { + gBrowser, + url: getSERPFollowOnUrl(getPageUrl()), + }, + async () => { + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { + "example:tagged:ff": 1, + "example:tagged-follow-on:ff": 1, + }, + } + ); + } + ); + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); +}); + +add_task(async function test_track_ad() { + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(getPageUrl(true)) + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "example:tagged:ff": 1 }, + "browser.search.withads.unknown": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_track_ad_on_data_attributes() { + resetTelemetry(); + + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_dataAttributes.html"; + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(url) + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { + "example-data-attributes:tagged:ff": 1, + }, + "browser.search.withads.unknown": { + "example-data-attributes:tagged": 1, + }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example-data-attributes", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_track_ad_on_data_attributes_and_hrefs() { + resetTelemetry(); + + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_dataAttributes_href.html"; + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(url) + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { + "example-data-attributes:tagged:ff": 1, + }, + "browser.search.withads.unknown": { + "example-data-attributes:tagged": 1, + }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example-data-attributes", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_track_no_ad_on_data_attributes_and_hrefs() { + resetTelemetry(); + + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_dataAttributes_none.html"; + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(url) + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { + "example-data-attributes:tagged:ff": 1, + }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example-data-attributes", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_track_ad_on_DOMContentLoaded() { + resetTelemetry(); + + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "slow_loading_page_with_ads.html"; + + let observeAdPreviouslyRecorded = TestUtils.consoleMessageObserved(msg => { + return ( + typeof msg.wrappedJSObject.arguments?.[0] == "string" && + msg.wrappedJSObject.arguments[0].includes( + "Ad was previously reported for browser with URI" + ) + ); + }); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(url) + ); + + // Observe ad was counted on DOMContentLoaded. + // We do not count the ad again on load. + await observeAdPreviouslyRecorded; + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "slow-page-load:tagged:ff": 1 }, + "browser.search.withads.unknown": { "slow-page-load:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "slow-page-load", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_track_ad_on_load_event() { + resetTelemetry(); + + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "slow_loading_page_with_ads_on_load_event.html"; + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(url) + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "slow-page-load:tagged:ff": 1 }, + "browser.search.withads.unknown": { "slow-page-load:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "slow-page-load", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_track_ad_organic() { + resetTelemetry(); + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(getPageUrl(true), true) + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "example:organic:none": 1 }, + "browser.search.withads.unknown": { "example:organic": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_track_ad_new_window() { + resetTelemetry(); + + let win = await BrowserTestUtils.openNewBrowserWindow(); + + let url = getSERPUrl(getPageUrl(true)); + BrowserTestUtils.loadURIString(win.gBrowser.selectedBrowser, url); + await BrowserTestUtils.browserLoaded( + win.gBrowser.selectedBrowser, + false, + url + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "example:tagged:ff": 1 }, + "browser.search.withads.unknown": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + await BrowserTestUtils.closeWindow(win); +}); + +add_task(async function test_track_ad_pages_without_ads() { + // Note: the above tests have already checked a page with no ad-urls. + resetTelemetry(); + + let tabs = []; + + tabs.push( + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(getPageUrl(false)) + ) + ); + tabs.push( + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(getPageUrl(true)) + ) + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "example:tagged:ff": 2 }, + "browser.search.withads.unknown": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + for (let tab of tabs) { + BrowserTestUtils.removeTab(tab); + } +}); + +async function track_ad_click(testOrganic) { + // Note: the above tests have already checked a page with no ad-urls. + resetTelemetry(); + + let expectedScalarKey = `example:${testOrganic ? "organic" : "tagged"}`; + let expectedContentScalarKey = `example:${ + testOrganic ? "organic:none" : "tagged:ff" + }`; + let tagged = testOrganic ? "false" : "true"; + let partnerCode = testOrganic ? "" : "ff"; + + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + getSERPUrl(getPageUrl(true), testOrganic) + ); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { [expectedContentScalarKey]: 1 }, + "browser.search.withads.unknown": { + [expectedScalarKey.replace("sap", "tagged")]: 1, + }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged, + partner_code: partnerCode, + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + await promiseAdImpressionReceived(1); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + BrowserTestUtils.synthesizeMouseAtCenter("#ad1", {}, tab.linkedBrowser); + await pageLoadPromise; + await promiseWaitForAdLinkCheck(); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { [expectedContentScalarKey]: 1 }, + "browser.search.withads.unknown": { [expectedScalarKey]: 1 }, + "browser.search.adclicks.unknown": { [expectedScalarKey]: 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged, + partner_code: partnerCode, + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); + + // Now go back, and click again. + pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + gBrowser.goBack(); + await pageLoadPromise; + await promiseWaitForAdLinkCheck(); + + // We've gone back, so we register an extra display & if it is with ads or not. + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.tabhistory": { [expectedContentScalarKey]: 1 }, + "browser.search.content.unknown": { [expectedContentScalarKey]: 1 }, + "browser.search.withads.tabhistory": { [expectedScalarKey]: 1 }, + "browser.search.withads.unknown": { [expectedScalarKey]: 1 }, + "browser.search.adclicks.unknown": { [expectedScalarKey]: 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged, + partner_code: partnerCode, + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged, + partner_code: partnerCode, + source: "tabhistory", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + await promiseAdImpressionReceived(2); + + pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + BrowserTestUtils.synthesizeMouseAtCenter("#ad1", {}, tab.linkedBrowser); + await pageLoadPromise; + await promiseWaitForAdLinkCheck(); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.tabhistory": { [expectedContentScalarKey]: 1 }, + "browser.search.content.unknown": { [expectedContentScalarKey]: 1 }, + "browser.search.withads.tabhistory": { [expectedScalarKey]: 1 }, + "browser.search.withads.unknown": { [expectedScalarKey]: 1 }, + "browser.search.adclicks.tabhistory": { [expectedScalarKey]: 1 }, + "browser.search.adclicks.unknown": { [expectedScalarKey]: 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged, + partner_code: partnerCode, + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged, + partner_code: partnerCode, + source: "tabhistory", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(tab); +} + +add_task(async function test_track_ad_click() { + await track_ad_click(false); +}); + +add_task(async function test_track_ad_click_organic() { + await track_ad_click(true); +}); + +add_task(async function test_track_ad_click_with_location_change_other_tab() { + resetTelemetry(); + const url = getSERPUrl(getPageUrl(true)); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "example:tagged:ff": 1 }, + "browser.search.withads.unknown": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + await promiseAdImpressionReceived(); + + const newTab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "https://example.com" + ); + + await BrowserTestUtils.switchTab(gBrowser, tab); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + BrowserTestUtils.synthesizeMouseAtCenter("#ad1", {}, tab.linkedBrowser); + await pageLoadPromise; + + await assertSearchSourcesTelemetry( + {}, + { + "browser.search.content.unknown": { "example:tagged:ff": 1 }, + "browser.search.withads.unknown": { "example:tagged": 1 }, + "browser.search.adclicks.unknown": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); + + BrowserTestUtils.removeTab(newTab); + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_sources_in_content.js b/browser/components/search/test/browser/browser_search_telemetry_sources_in_content.js new file mode 100644 index 0000000000..003b54cc8e --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_sources_in_content.js @@ -0,0 +1,435 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * SearchSERPTelemetry tests related to in-content sources. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetry(?:Ad)?/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad2?/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + { + type: SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS, + included: { + parent: { + selector: ".refined-search-buttons", + }, + children: [ + { + selector: "a", + }, + ], + }, + topDown: true, + }, + ], + }, +]; + +function getSERPUrl(page, organic = false) { + let url = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + page; + return `${url}?s=test${organic ? "" : "&abc=ff"}`; +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +add_setup(async function () { + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + await SpecialPowers.pushPrefEnv({ + set: [["browser.search.serpEventTelemetry.enabled", true]], + }); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + Services.prefs.setBoolPref("browser.search.log", true); + + registerCleanupFunction(async () => { + Services.prefs.clearUserPref("browser.search.log"); + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + resetTelemetry(); + }); +}); + +add_task(async function test_source_opened_in_new_tab_via_middle_click() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab1 = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_searchbox_with_content.html?s=test+one+two+three"; + + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, targetUrl, true); + await BrowserTestUtils.synthesizeMouseAtCenter( + "a#related-in-page", + { button: 1 }, + tab1.linkedBrowser + ); + let tab2 = await tabPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "opened_in_new_tab", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab1); + BrowserTestUtils.removeTab(tab2); +}); + +add_task(async function test_source_opened_in_new_tab_via_target_blank() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab1 = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_searchbox_with_content.html?s=test+one+two+three"; + + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, targetUrl, true); + // Note: the anchor element with id "related-new-tab" has a target=_blank + // attribute. + await BrowserTestUtils.synthesizeMouseAtCenter( + "a#related-new-tab", + {}, + tab1.linkedBrowser + ); + let tab2 = await tabPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "opened_in_new_tab", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab1); + BrowserTestUtils.removeTab(tab2); +}); + +add_task(async function test_source_opened_in_new_tab_via_context_menu() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab1 = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_searchbox_with_content.html?s=test+one+two+three"; + + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, targetUrl, true); + + let contextMenu = document.getElementById("contentAreaContextMenu"); + let popupShownPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "a#related-in-page", + { + button: 2, + type: "contextmenu", + }, + tab1.linkedBrowser + ); + await popupShownPromise; + + let openLinkInNewTabMenuItem = contextMenu.querySelector( + "#context-openlinkintab" + ); + contextMenu.activateItem(openLinkInNewTabMenuItem); + + let tab2 = await tabPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.NON_ADS_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "opened_in_new_tab", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab1); + BrowserTestUtils.removeTab(tab2); +}); + +add_task( + async function test_source_refinement_button_clicked_no_partner_code() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#refined-search-button", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "false", + partner_code: "", + source: "follow_on_from_refine_on_SERP", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); + } +); + +add_task( + async function test_source_refinement_button_clicked_with_partner_code() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#refined-search-button-with-partner-code", + {}, + tab.linkedBrowser + ); + await pageLoadPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "follow_on_from_refine_on_SERP", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab); + } +); + +// When a user opens a refinement button link in a new tab, we want the +// source to be recorded as "follow_on_from_refine_on_SERP", not +// "opened_in_new_tab", since the refinement button click provides greater +// context. +add_task(async function test_refinement_button_vs_opened_in_new_tab() { + resetTelemetry(); + let url = getSERPUrl("searchTelemetryAd_searchbox_with_content.html"); + let tab1 = await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + await waitForPageWithAdImpressions(); + + let targetUrl = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.org" + ) + "searchTelemetryAd_searchbox_with_content.html?s=test2&abc=ff"; + + let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, targetUrl, true); + await BrowserTestUtils.synthesizeMouseAtCenter( + "#refined-search-button-with-partner-code", + { button: 1 }, + tab1.linkedBrowser + ); + let tab2 = await tabPromise; + + await TestUtils.waitForCondition(() => { + return Glean.serp.impression?.testGetValue()?.length == 2; + }, "Should have two impressions."); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "unknown", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.REFINED_SEARCH_BUTTONS, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "follow_on_from_refine_on_SERP", + is_shopping_page: "false", + shopping_tab_displayed: "false", + }, + }, + ]); + + BrowserTestUtils.removeTab(tab1); + BrowserTestUtils.removeTab(tab2); +}); diff --git a/browser/components/search/test/browser/browser_search_telemetry_sources_navigation.js b/browser/components/search/test/browser/browser_search_telemetry_sources_navigation.js new file mode 100644 index 0000000000..4269649992 --- /dev/null +++ b/browser/components/search/test/browser/browser_search_telemetry_sources_navigation.js @@ -0,0 +1,549 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Main tests for SearchSERPTelemetry - general engine visiting and link clicking. + */ + +"use strict"; + +const { SearchSERPTelemetry, SearchSERPTelemetryUtils } = + ChromeUtils.importESModule("resource:///modules/SearchSERPTelemetry.sys.mjs"); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: + /^https:\/\/example.org\/browser\/browser\/components\/search\/test\/browser\/searchTelemetry(?:Ad)?.html/, + queryParamName: "s", + codeParamName: "abc", + taggedCodes: ["ff"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/example\.com\/ad2?/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +function getPageUrl(useAdPage = false) { + let page = useAdPage ? "searchTelemetryAd.html" : "searchTelemetry.html"; + return `https://example.org/browser/browser/components/search/test/browser/${page}`; +} + +/** + * Returns the index of the first search suggestion in the urlbar results. + * + * @returns {number} An index, or -1 if there are no search suggestions. + */ +async function getFirstSuggestionIndex() { + const matchCount = UrlbarTestUtils.getResultCount(window); + for (let i = 0; i < matchCount; i++) { + let result = await UrlbarTestUtils.getDetailsOfResultAt(window, i); + if ( + result.type == UrlbarUtils.RESULT_TYPE.SEARCH && + result.searchParams.suggestion + ) { + return i; + } + } + return -1; +} + +// sharedData messages are only passed to the child on idle. Therefore +// we wait for a few idles to try and ensure the messages have been able +// to be passed across and handled. +async function waitForIdle() { + for (let i = 0; i < 10; i++) { + await new Promise(resolve => Services.tm.idleDispatchToMainThread(resolve)); + } +} + +function resetTelemetry() { + searchCounts.clear(); + Services.telemetry.clearScalars(); + Services.fog.testResetFOG(); +} + +SearchTestUtils.init(this); + +let tab; + +add_setup(async function () { + searchCounts.clear(); + Services.telemetry.clearScalars(); + + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + await waitForIdle(); + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.urlbar.suggest.searches", true], + ["browser.search.serpEventTelemetry.enabled", true], + ], + }); + // Enable local telemetry recording for the duration of the tests. + let oldCanRecord = Services.telemetry.canRecordExtended; + Services.telemetry.canRecordExtended = true; + Services.prefs.setBoolPref("browser.search.log", true); + + await SearchTestUtils.installSearchExtension( + { + search_url: getPageUrl(true), + search_url_get_params: "s={searchTerms}&abc=ff", + suggest_url: + "https://example.com/browser/browser/components/search/test/browser/searchSuggestionEngine.sjs", + suggest_url_get_params: "query={searchTerms}", + }, + { setAsDefault: true } + ); + + tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + registerCleanupFunction(async () => { + BrowserTestUtils.removeTab(tab); + Services.prefs.clearUserPref("browser.search.log"); + SearchSERPTelemetry.overrideSearchTelemetryForTests(); + Services.telemetry.canRecordExtended = oldCanRecord; + Services.telemetry.clearScalars(); + }); +}); + +// These tests are consecutive and intentionally build on the results of the +// previous test. + +async function loadSearchPage() { + await UrlbarTestUtils.promiseAutocompleteResultPopup({ + window, + value: "searchSuggestion", + }); + let idx = await getFirstSuggestionIndex(); + Assert.greaterOrEqual(idx, 0, "there should be a first suggestion"); + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + while (idx--) { + EventUtils.sendKey("down"); + } + EventUtils.sendKey("return"); + await loadPromise; +} + +add_task(async function test_search() { + Services.fog.testResetFOG(); + // Load a page via the address bar. + await loadSearchPage(); + + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + ]); +}); + +add_task(async function test_reload() { + let promise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + tab.linkedBrowser.reload(); + await promise; + await promiseWaitForAdLinkCheck(); + + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.content.reload": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + "browser.search.withads.reload": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "reload", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + ]); + await promiseAdImpressionReceived(); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter("#ad1", {}, tab.linkedBrowser); + await pageLoadPromise; + + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.content.reload": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + "browser.search.withads.reload": { "example:tagged": 1 }, + "browser.search.adclicks.reload": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "reload", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); +}); + +let searchUrl; + +add_task(async function test_fresh_search() { + resetTelemetry(); + + // Load a page via the address bar. + await loadSearchPage(); + + searchUrl = tab.linkedBrowser.url; + + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + ]); + await promiseAdImpressionReceived(1); +}); + +add_task(async function test_click_ad() { + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter("#ad1", {}, tab.linkedBrowser); + await pageLoadPromise; + + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + "browser.search.adclicks.urlbar": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); +}); + +add_task(async function test_go_back() { + let promise = BrowserTestUtils.waitForLocationChange(gBrowser, searchUrl); + tab.linkedBrowser.goBack(); + await promise; + await promiseWaitForAdLinkCheck(); + + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.content.tabhistory": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + "browser.search.withads.tabhistory": { "example:tagged": 1 }, + "browser.search.adclicks.urlbar": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "tabhistory", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + ]); + await promiseAdImpressionReceived(2); + + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter("#ad1", {}, tab.linkedBrowser); + await pageLoadPromise; + + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.content.tabhistory": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + "browser.search.withads.tabhistory": { "example:tagged": 1 }, + "browser.search.adclicks.urlbar": { "example:tagged": 1 }, + "browser.search.adclicks.tabhistory": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "tabhistory", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); +}); + +// Conduct a search from the Urlbar with showSearchTerms enabled. +add_task(async function test_fresh_search_with_urlbar_persisted() { + resetTelemetry(); + + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.urlbar.showSearchTerms.featureGate", true], + ["browser.urlbar.tipShownCount.searchTip_persist", 999], + ], + }); + + // Load a SERP once in order to show the search term in the Urlbar. + await loadSearchPage(); + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + ]); + await promiseAdImpressionReceived(1); + + // Do another search from the context of the default SERP. + await loadSearchPage(); + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + "other-Example.urlbar-persisted": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + "browser.search.content.urlbar_persisted": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar_persisted": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar_persisted", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + ]); + await promiseAdImpressionReceived(2); + + // Click on an ad. + let pageLoadPromise = BrowserTestUtils.waitForLocationChange(gBrowser); + await BrowserTestUtils.synthesizeMouseAtCenter("#ad1", {}, tab.linkedBrowser); + + await pageLoadPromise; + await assertSearchSourcesTelemetry( + { + "other-Example.urlbar": 1, + "other-Example.urlbar-persisted": 1, + }, + { + "browser.search.content.urlbar": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar": { "example:tagged": 1 }, + "browser.search.content.urlbar_persisted": { "example:tagged:ff": 1 }, + "browser.search.withads.urlbar_persisted": { "example:tagged": 1 }, + "browser.search.adclicks.urlbar_persisted": { "example:tagged": 1 }, + } + ); + + assertImpressionEvents([ + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + }, + { + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + source: "urlbar_persisted", + shopping_tab_displayed: "false", + is_shopping_page: "false", + }, + engagements: [ + { + action: SearchSERPTelemetryUtils.ACTIONS.CLICKED, + target: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + }, + ], + }, + ]); + + await SpecialPowers.popPrefEnv(); +}); diff --git a/browser/components/search/test/browser/browser_searchbar_addEngine.js b/browser/components/search/test/browser/browser_searchbar_addEngine.js new file mode 100644 index 0000000000..7d72d63dab --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_addEngine.js @@ -0,0 +1,99 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Tests the Add Search Engine option in the search bar. + */ + +"use strict"; + +const { PromptTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/PromptTestUtils.sys.mjs" +); + +const searchPopup = document.getElementById("PopupSearchAutoComplete"); +let searchbar; + +add_setup(async function () { + searchbar = await gCUITestUtils.addSearchBar(); + + registerCleanupFunction(async function () { + gCUITestUtils.removeSearchBar(); + Services.search.restoreDefaultEngines(); + }); +}); + +add_task(async function test_invalidEngine() { + let rootDir = getRootDirectory(gTestPath); + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + rootDir + "opensearch.html" + ); + let promise = promiseEvent(searchPopup, "popupshown"); + await EventUtils.synthesizeMouseAtCenter( + searchbar.querySelector(".searchbar-search-button"), + {} + ); + await promise; + + let addEngineList = searchPopup.querySelectorAll( + ".searchbar-engine-one-off-add-engine" + ); + let item = addEngineList[addEngineList.length - 1]; + + await TestUtils.waitForCondition( + () => item.tooltipText.includes("engineInvalid"), + "Wait until the tooltip will be correct" + ); + Assert.ok(true, "Last item should be the invalid entry"); + + let promptPromise = PromptTestUtils.waitForPrompt(tab.linkedBrowser, { + modalType: Ci.nsIPromptService.MODAL_TYPE_CONTENT, + promptType: "alert", + }); + + await EventUtils.synthesizeMouseAtCenter(item, {}); + + let prompt = await promptPromise; + + Assert.ok( + prompt.ui.infoBody.textContent.includes( + "http://mochi.test:8888/browser/browser/components/search/test/browser/testEngine_404.xml" + ), + "Should have included the url in the prompt body" + ); + + await PromptTestUtils.handlePrompt(prompt); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_onOnlyDefaultEngine() { + info("Remove engines except default"); + const defaultEngine = Services.search.defaultEngine; + const engines = await Services.search.getVisibleEngines(); + for (const engine of engines) { + if (defaultEngine.name !== engine.name) { + await Services.search.removeEngine(engine); + } + } + + info("Show popup"); + const rootDir = getRootDirectory(gTestPath); + const tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + rootDir + "opensearch.html" + ); + const onShown = promiseEvent(searchPopup, "popupshown"); + await EventUtils.synthesizeMouseAtCenter( + searchbar.querySelector(".searchbar-search-button"), + {} + ); + await onShown; + + const addEngineList = searchPopup.querySelectorAll( + ".searchbar-engine-one-off-add-engine" + ); + Assert.equal(addEngineList.length, 3, "Add engines should be shown"); + + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_searchbar_context.js b/browser/components/search/test/browser/browser_searchbar_context.js new file mode 100644 index 0000000000..4a3d20fc50 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_context.js @@ -0,0 +1,246 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Tests the context menu for the search bar. + */ + +"use strict"; + +let win; + +XPCOMUtils.defineLazyServiceGetter( + this, + "clipboardHelper", + "@mozilla.org/widget/clipboardhelper;1", + "nsIClipboardHelper" +); + +add_setup(async function () { + await gCUITestUtils.addSearchBar(); + + await SearchTestUtils.installSearchExtension({}, { setAsDefault: true }); + + win = await BrowserTestUtils.openNewBrowserWindow(); + + // Disable suggestions for this test, so that we are not attempting to hit + // the network for suggestions when we don't need them. + SpecialPowers.pushPrefEnv({ + set: [["browser.search.suggest.enabled", false]], + }); + + registerCleanupFunction(async function () { + await BrowserTestUtils.closeWindow(win); + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function test_emptybar() { + const searchbar = win.BrowserSearch.searchBar; + searchbar.focus(); + + let contextMenu = searchbar.querySelector(".textbox-contextmenu"); + let contextMenuPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + + await EventUtils.synthesizeMouseAtCenter( + searchbar, + { type: "contextmenu", button: 2 }, + win + ); + await contextMenuPromise; + + Assert.ok( + contextMenu.getElementsByAttribute("cmd", "cmd_cut")[0].disabled, + "Should have disabled the cut menuitem" + ); + Assert.ok( + contextMenu.getElementsByAttribute("cmd", "cmd_copy")[0].disabled, + "Should have disabled the copy menuitem" + ); + Assert.ok( + contextMenu.getElementsByAttribute("cmd", "cmd_delete")[0].disabled, + "Should have disabled the delete menuitem" + ); + + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + contextMenu.hidePopup(); + await popupHiddenPromise; +}); + +add_task(async function test_text_in_bar() { + const searchbar = win.BrowserSearch.searchBar; + searchbar.focus(); + + searchbar.value = "Test"; + searchbar._textbox.editor.selectAll(); + + let contextMenu = searchbar.querySelector(".textbox-contextmenu"); + let contextMenuPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + + await EventUtils.synthesizeMouseAtCenter( + searchbar, + { type: "contextmenu", button: 2 }, + win + ); + await contextMenuPromise; + + Assert.ok( + !contextMenu.getElementsByAttribute("cmd", "cmd_cut")[0].disabled, + "Should have enabled the cut menuitem" + ); + Assert.ok( + !contextMenu.getElementsByAttribute("cmd", "cmd_copy")[0].disabled, + "Should have enabled the copy menuitem" + ); + Assert.ok( + !contextMenu.getElementsByAttribute("cmd", "cmd_delete")[0].disabled, + "Should have enabled the delete menuitem" + ); + + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + contextMenu.hidePopup(); + await popupHiddenPromise; +}); + +add_task(async function test_unfocused_emptybar() { + const searchbar = win.BrowserSearch.searchBar; + // clear searchbar value from previous test + searchbar.value = ""; + + // force focus onto another component + win.gURLBar.focus(); + + let contextMenu = searchbar.querySelector(".textbox-contextmenu"); + let contextMenuPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + + searchbar.focus(); + await EventUtils.synthesizeMouseAtCenter( + searchbar, + { type: "contextmenu", button: 2 }, + win + ); + await contextMenuPromise; + + Assert.ok( + contextMenu.getElementsByAttribute("cmd", "cmd_cut")[0].disabled, + "Should have disabled the cut menuitem" + ); + Assert.ok( + contextMenu.getElementsByAttribute("cmd", "cmd_copy")[0].disabled, + "Should have disabled the copy menuitem" + ); + Assert.ok( + contextMenu.getElementsByAttribute("cmd", "cmd_delete")[0].disabled, + "Should have disabled the delete menuitem" + ); + + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + contextMenu.hidePopup(); + await popupHiddenPromise; +}); + +add_task(async function test_text_in_unfocused_bar() { + const searchbar = win.BrowserSearch.searchBar; + + searchbar.value = "Test"; + + // force focus onto another component + win.gURLBar.focus(); + + let contextMenu = searchbar.querySelector(".textbox-contextmenu"); + let contextMenuPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + + searchbar.focus(); + await EventUtils.synthesizeMouseAtCenter( + searchbar, + { type: "contextmenu", button: 2 }, + win + ); + await contextMenuPromise; + + Assert.ok( + !contextMenu.getElementsByAttribute("cmd", "cmd_cut")[0].disabled, + "Should have enabled the cut menuitem" + ); + Assert.ok( + !contextMenu.getElementsByAttribute("cmd", "cmd_copy")[0].disabled, + "Should have enabled the copy menuitem" + ); + Assert.ok( + !contextMenu.getElementsByAttribute("cmd", "cmd_delete")[0].disabled, + "Should have enabled the delete menuitem" + ); + + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + contextMenu.hidePopup(); + await popupHiddenPromise; +}); + +add_task(async function test_paste_and_go() { + let tab = await BrowserTestUtils.openNewForegroundTab({ + gBrowser: win.gBrowser, + }); + + const searchbar = win.BrowserSearch.searchBar; + + searchbar.value = ""; + searchbar.focus(); + + const searchString = "test"; + + await SimpleTest.promiseClipboardChange(searchString, () => { + clipboardHelper.copyString(searchString); + }); + + let contextMenu = searchbar.querySelector(".textbox-contextmenu"); + let contextMenuPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + await EventUtils.synthesizeMouseAtCenter( + searchbar, + { type: "contextmenu", button: 2 }, + win + ); + await contextMenuPromise; + + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + searchbar.querySelector(".searchbar-paste-and-search").click(); + await p; + contextMenu.hidePopup(); + await popupHiddenPromise; + + Assert.equal( + tab.linkedBrowser.currentURI.spec, + `https://example.com/?q=${searchString}`, + "Should have loaded the expected search page." + ); +}); diff --git a/browser/components/search/test/browser/browser_searchbar_default.js b/browser/components/search/test/browser/browser_searchbar_default.js new file mode 100644 index 0000000000..c1e9280932 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_default.js @@ -0,0 +1,221 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Tests the correct default engines in the search bar. + */ + +"use strict"; + +const { SearchSuggestionController } = ChromeUtils.importESModule( + "resource://gre/modules/SearchSuggestionController.sys.mjs" +); + +const templateNormal = "https://example.com/?q="; +const templatePrivate = "https://example.com/?query="; + +const searchPopup = document.getElementById("PopupSearchAutoComplete"); + +add_setup(async function () { + await gCUITestUtils.addSearchBar(); + + await SpecialPowers.pushPrefEnv({ + set: [["browser.search.separatePrivateDefault", false]], + }); + + // Create two new search engines. Mark one as the default engine, so + // the test don't crash. We need to engines for this test as the searchbar + // doesn't display the default search engine among the one-off engines. + await SearchTestUtils.installSearchExtension({ + name: "MozSearch1", + keyword: "mozalias", + }); + await SearchTestUtils.installSearchExtension({ + name: "MozSearch2", + keyword: "mozalias2", + search_url_get_params: "query={searchTerms}", + }); + + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.search.separatePrivateDefault.ui.enabled", true], + ["browser.search.separatePrivateDefault", false], + ], + }); + + let originalEngine = await Services.search.getDefault(); + let originalPrivateEngine = await Services.search.getDefaultPrivate(); + + let engineDefault = Services.search.getEngineByName("MozSearch1"); + await Services.search.setDefault( + engineDefault, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + registerCleanupFunction(async function () { + gCUITestUtils.removeSearchBar(); + await Services.search.setDefault( + originalEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + await Services.search.setDefaultPrivate( + originalPrivateEngine, + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + }); +}); + +async function doSearch( + win, + tab, + engineName, + templateUrl, + inputText = "query" +) { + await searchInSearchbar(inputText, win); + + Assert.ok( + win.BrowserSearch.searchBar.textbox.popup.searchbarEngineName + .getAttribute("value") + .includes(engineName), + "Should have the correct engine name displayed in the bar" + ); + + let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + EventUtils.synthesizeKey("KEY_Enter", {}, win); + await p; + + Assert.equal( + tab.linkedBrowser.currentURI.spec, + templateUrl + inputText, + "Should have loaded the expected search page." + ); +} + +add_task(async function test_default_search() { + const tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + + await doSearch(window, tab, "MozSearch1", templateNormal); + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_default_search_private_no_separate() { + const win = await BrowserTestUtils.openNewBrowserWindow({ private: true }); + + await doSearch(win, win.gBrowser.selectedTab, "MozSearch1", templateNormal); + + await BrowserTestUtils.closeWindow(win); +}); + +add_task(async function test_default_search_private_no_separate() { + await SpecialPowers.pushPrefEnv({ + set: [["browser.search.separatePrivateDefault", true]], + }); + + await Services.search.setDefaultPrivate( + Services.search.getEngineByName("MozSearch2"), + Ci.nsISearchService.CHANGE_REASON_UNKNOWN + ); + + const win = await BrowserTestUtils.openNewBrowserWindow({ private: true }); + + await doSearch(win, win.gBrowser.selectedTab, "MozSearch2", templatePrivate); + + await BrowserTestUtils.closeWindow(win); +}); + +add_task(async function test_form_history() { + const tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + await FormHistoryTestUtils.clear("searchbar-history"); + const gShortString = new Array( + SearchSuggestionController.SEARCH_HISTORY_MAX_VALUE_LENGTH + ) + .fill("a") + .join(""); + let promiseAdd = TestUtils.topicObserved("satchel-storage-changed"); + await doSearch(window, tab, "MozSearch1", templateNormal, gShortString); + await promiseAdd; + let entries = (await FormHistoryTestUtils.search("searchbar-history")).map( + entry => entry.value + ); + Assert.deepEqual( + entries, + [gShortString], + "Should have stored search history" + ); + + await FormHistoryTestUtils.clear("searchbar-history"); + const gLongString = new Array( + SearchSuggestionController.SEARCH_HISTORY_MAX_VALUE_LENGTH + 1 + ) + .fill("a") + .join(""); + await doSearch(window, tab, "MozSearch1", templateNormal, gLongString); + // There's nothing we can wait for, since addition should not be happening. + /* eslint-disable mozilla/no-arbitrary-setTimeout */ + await new Promise(resolve => setTimeout(resolve, 500)); + entries = (await FormHistoryTestUtils.search("searchbar-history")).map( + entry => entry.value + ); + Assert.deepEqual(entries, [], "Should not find form history"); + + await FormHistoryTestUtils.clear("searchbar-history"); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_searchbar_revert() { + const tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "about:blank" + ); + + await doSearch(window, tab, "MozSearch1", templateNormal, "testQuery"); + + let searchbar = window.BrowserSearch.searchBar; + is( + searchbar.value, + "testQuery", + "Search value should be the the last search" + ); + + // focus search bar + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + searchbar.focus(); + await promise; + + searchbar.value = "aQuery"; + searchbar.value = "anotherQuery"; + + // close the panel using the escape key. + promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Escape"); + await promise; + + is(searchbar.value, "anotherQuery", "The search value should be the same"); + // revert the search bar value + EventUtils.synthesizeKey("KEY_Escape"); + is( + searchbar.value, + "testQuery", + "The search value should have been reverted" + ); + + EventUtils.synthesizeKey("KEY_Escape"); + is(searchbar.value, "testQuery", "The search value should be the same"); + + await doSearch(window, tab, "MozSearch1", templateNormal, "query"); + + is(searchbar.value, "query", "The search value should be query"); + EventUtils.synthesizeKey("KEY_Escape"); + is(searchbar.value, "query", "The search value should be the same"); + + BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/search/test/browser/browser_searchbar_enter.js b/browser/components/search/test/browser/browser_searchbar_enter.js new file mode 100644 index 0000000000..030cf26fb2 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_enter.js @@ -0,0 +1,152 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +// Test the behavior for enter key. + +add_setup(async function () { + await gCUITestUtils.addSearchBar(); + + await SearchTestUtils.installSearchExtension({}, { setAsDefault: true }); + + registerCleanupFunction(async function () { + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function searchOnEnterSoon() { + info("Search on Enter as soon as typing a char"); + const win = await BrowserTestUtils.openNewBrowserWindow(); + const browser = win.gBrowser.selectedBrowser; + const browserSearch = win.BrowserSearch; + + const onPageHide = SpecialPowers.spawn(browser, [], () => { + return new Promise(resolve => { + content.addEventListener("pagehide", () => { + resolve(); + }); + }); + }); + const onResult = SpecialPowers.spawn(browser, [], () => { + return new Promise(resolve => { + content.addEventListener("keyup", () => { + resolve("keyup"); + }); + content.addEventListener("unload", () => { + resolve("unload"); + }); + }); + }); + + info("Focus on the search bar"); + const searchBarTextBox = browserSearch.searchBar.textbox; + EventUtils.synthesizeMouseAtCenter(searchBarTextBox, {}, win); + const ownerDocument = browser.ownerDocument; + is(ownerDocument.activeElement, searchBarTextBox, "The search bar has focus"); + + info("Keydown a char and Enter"); + EventUtils.synthesizeKey("x", { type: "keydown" }, win); + EventUtils.synthesizeKey("KEY_Enter", { type: "keydown" }, win); + + info("Wait for pagehide event in the content"); + await onPageHide; + is( + ownerDocument.activeElement, + searchBarTextBox, + "The search bar still has focus" + ); + + // Keyup both key as soon as pagehide event happens. + EventUtils.synthesizeKey("x", { type: "keyup" }, win); + EventUtils.synthesizeKey("KEY_Enter", { type: "keyup" }, win); + + await TestUtils.waitForCondition( + () => ownerDocument.activeElement === browser, + "Wait for focus to be moved to the browser" + ); + info("The focus is moved to the browser"); + + // Check whether keyup event is not captured before unload event happens. + const result = await onResult; + is(result, "unload", "Keyup event is not captured"); + + await BrowserTestUtils.closeWindow(win); +}); + +add_task(async function typeCharWhileProcessingEnter() { + info("Typing a char while processing enter key"); + const win = await BrowserTestUtils.openNewBrowserWindow(); + const browser = win.gBrowser.selectedBrowser; + const searchBar = win.BrowserSearch.searchBar; + + const SEARCH_WORD = "test"; + const onLoad = BrowserTestUtils.browserLoaded( + browser, + false, + `https://example.com/?q=${SEARCH_WORD}` + ); + searchBar.textbox.focus(); + searchBar.textbox.value = SEARCH_WORD; + + info("Keydown Enter"); + EventUtils.synthesizeKey("KEY_Enter", { type: "keydown" }, win); + await TestUtils.waitForCondition( + () => searchBar._needBrowserFocusAtEnterKeyUp, + "Wait for starting process for the enter key" + ); + + info("Keydown a char"); + EventUtils.synthesizeKey("x", { type: "keydown" }, win); + + info("Keyup both"); + EventUtils.synthesizeKey("x", { type: "keyup" }, win); + EventUtils.synthesizeKey("KEY_Enter", { type: "keyup" }, win); + + Assert.equal( + searchBar.textbox.value, + SEARCH_WORD, + "The value of searchbar is correct" + ); + + await onLoad; + Assert.ok("Browser loaded the correct url"); + + // Cleanup. + await BrowserTestUtils.closeWindow(win); +}); + +add_task(async function keyupEnterWhilePressingMeta() { + const win = await BrowserTestUtils.openNewBrowserWindow(); + const browser = win.gBrowser.selectedBrowser; + const searchBar = win.BrowserSearch.searchBar; + + info("Keydown Meta+Enter"); + searchBar.textbox.focus(); + searchBar.textbox.value = ""; + EventUtils.synthesizeKey( + "KEY_Enter", + { type: "keydown", metaKey: true }, + win + ); + + // Pressing Enter key while pressing Meta key, and next, even when releasing + // Enter key before releasing Meta key, the keyup event is not fired. + // Therefor, we fire Meta keyup event only. + info("Keyup Meta"); + EventUtils.synthesizeKey("KEY_Meta", { type: "keyup" }, win); + + await TestUtils.waitForCondition( + () => browser.ownerDocument.activeElement === browser, + "Wait for focus to be moved to the browser" + ); + info("The focus is moved to the browser"); + + info("Check whether we can input on the search bar"); + searchBar.textbox.focus(); + EventUtils.synthesizeKey("a", {}, win); + is(searchBar.textbox.value, "a", "Can input a char"); + + // Cleanup. + await BrowserTestUtils.closeWindow(win); +}); diff --git a/browser/components/search/test/browser/browser_searchbar_keyboard_navigation.js b/browser/components/search/test/browser/browser_searchbar_keyboard_navigation.js new file mode 100644 index 0000000000..de78beabd6 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_keyboard_navigation.js @@ -0,0 +1,644 @@ +// Tests that keyboard navigation in the search panel works as designed. + +const searchPopup = document.getElementById("PopupSearchAutoComplete"); + +const kValues = ["foo1", "foo2", "foo3"]; +const kUserValue = "foo"; + +function getOpenSearchItems() { + let os = []; + + let addEngineList = searchPopup.searchOneOffsContainer.querySelector( + ".search-add-engines" + ); + for ( + let item = addEngineList.firstElementChild; + item; + item = item.nextElementSibling + ) { + os.push(item); + } + + return os; +} + +let searchbar; +let textbox; + +async function checkHeader(engine) { + // The header can be updated after getting the engine, so we may have to + // wait for it. + let header = searchPopup.searchbarEngineName; + if (!header.getAttribute("value").includes(engine.name)) { + await new Promise(resolve => { + let observer = new MutationObserver(() => { + observer.disconnect(); + resolve(); + }); + observer.observe(searchPopup.searchbarEngineName, { + attributes: true, + attributeFilter: ["value"], + }); + }); + } + Assert.ok( + header.getAttribute("value").includes(engine.name), + "Should have the correct engine name displayed in the header" + ); +} + +add_setup(async function () { + searchbar = await gCUITestUtils.addSearchBar(); + textbox = searchbar.textbox; + + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine.xml", + setAsDefault: true, + }); + // First cleanup the form history in case other tests left things there. + info("cleanup the search history"); + await FormHistory.update({ op: "remove", fieldname: "searchbar-history" }); + + info("adding search history values: " + kValues); + let addOps = kValues.map(value => { + return { op: "add", fieldname: "searchbar-history", value }; + }); + await FormHistory.update(addOps); + + textbox.value = kUserValue; + + registerCleanupFunction(async () => { + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function test_arrows() { + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + searchbar.focus(); + await promise; + is( + textbox.mController.searchString, + kUserValue, + "The search string should be 'foo'" + ); + + // Check the initial state of the panel before sending keyboard events. + is(searchPopup.matchCount, kValues.length, "There should be 3 suggestions"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // The tests will be less meaningful if the first, second, last, and + // before-last one-off buttons aren't different. We should always have more + // than 4 default engines, but it's safer to check this assumption. + let oneOffs = getOneOffs(); + ok(oneOffs.length >= 4, "we have at least 4 one-off buttons displayed"); + + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // The down arrow should first go through the suggestions. + for (let i = 0; i < kValues.length; ++i) { + EventUtils.synthesizeKey("KEY_ArrowDown"); + is( + searchPopup.selectedIndex, + i, + "the suggestion at index " + i + " should be selected" + ); + is( + textbox.value, + kValues[i], + "the textfield value should be " + kValues[i] + ); + await checkHeader(Services.search.defaultEngine); + } + + // Pressing down again should remove suggestion selection and change the text + // field value back to what the user typed, and select the first one-off. + EventUtils.synthesizeKey("KEY_ArrowDown"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is( + textbox.value, + kUserValue, + "the textfield value should be back to initial value" + ); + + // now cycle through the one-off items, the first one is already selected. + for (let i = 0; i < oneOffs.length; ++i) { + let oneOffButton = oneOffs[i]; + is( + textbox.selectedButton, + oneOffButton, + "the one-off button #" + (i + 1) + " should be selected" + ); + await checkHeader(oneOffButton.engine); + EventUtils.synthesizeKey("KEY_ArrowDown"); + } + + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + await checkHeader(Services.search.defaultEngine); + EventUtils.synthesizeKey("KEY_ArrowDown"); + + // We should now be back to the initial situation. + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + ok(!textbox.selectedButton, "no one-off button should be selected"); + await checkHeader(Services.search.defaultEngine); + + info("now test the up arrow key"); + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + await checkHeader(Services.search.defaultEngine); + + // cycle through the one-off items, the first one is already selected. + for (let i = oneOffs.length; i; --i) { + EventUtils.synthesizeKey("KEY_ArrowUp"); + let oneOffButton = oneOffs[i - 1]; + is( + textbox.selectedButton, + oneOffButton, + "the one-off button #" + i + " should be selected" + ); + await checkHeader(oneOffButton.engine); + } + + // Another press on up should clear the one-off selection and select the + // last suggestion. + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + for (let i = kValues.length - 1; i >= 0; --i) { + is( + searchPopup.selectedIndex, + i, + "the suggestion at index " + i + " should be selected" + ); + is( + textbox.value, + kValues[i], + "the textfield value should be " + kValues[i] + ); + await checkHeader(Services.search.defaultEngine); + EventUtils.synthesizeKey("KEY_ArrowUp"); + } + + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is( + textbox.value, + kUserValue, + "the textfield value should be back to initial value" + ); +}); + +add_task(async function test_typing_clears_button_selection() { + is( + Services.focus.focusedElement, + textbox, + "the search bar should be focused" + ); // from the previous test. + ok(!textbox.selectedButton, "no button should be selected"); + + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + // Type a character. + EventUtils.sendString("a"); + ok(!textbox.selectedButton, "the settings item should be de-selected"); + + // Remove the character. + EventUtils.synthesizeKey("KEY_Backspace"); +}); + +add_task(async function test_tab() { + is( + Services.focus.focusedElement, + textbox, + "the search bar should be focused" + ); // from the previous test. + + let oneOffs = getOneOffs(); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // Pressing tab should select the first one-off without selecting suggestions. + // now cycle through the one-off items, the first one is already selected. + for (let i = 0; i < oneOffs.length; ++i) { + EventUtils.synthesizeKey("KEY_Tab"); + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + } + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, kUserValue, "the textfield value should be unmodified"); + + // One more <tab> selects the settings button. + EventUtils.synthesizeKey("KEY_Tab"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + // Pressing tab again should close the panel... + let promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Tab"); + await promise; + + // ... and move the focus out of the searchbox. + isnot( + Services.focus.focusedElement, + textbox.inputField, + "the search bar no longer be focused" + ); +}); + +add_task(async function test_shift_tab() { + // First reopen the panel. + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + searchbar.focus(); + await promise; + + let oneOffs = getOneOffs(); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // Press up once to select the last button. + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + // Press up again to select the last one-off button. + EventUtils.synthesizeKey("KEY_ArrowUp"); + + // Pressing shift+tab should cycle through the one-off items. + for (let i = oneOffs.length - 1; i >= 0; --i) { + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + if (i) { + EventUtils.synthesizeKey("KEY_Tab", { shiftKey: true }); + } + } + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, kUserValue, "the textfield value should be unmodified"); + + // Pressing shift+tab again should close the panel... + promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Tab", { shiftKey: true }); + await promise; + + // ... and move the focus out of the searchbox. + isnot( + Services.focus.focusedElement, + textbox.inputField, + "the search bar no longer be focused" + ); +}); + +add_task(async function test_alt_down() { + // First refocus the panel. + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + searchbar.focus(); + await promise; + + // close the panel using the escape key. + promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Escape"); + await promise; + + // check that alt+down opens the panel... + promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + await promise; + + // ... and does nothing else. + ok(!textbox.selectedButton, "no one-off button should be selected"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, kUserValue, "the textfield value should be unmodified"); + + // Pressing alt+down should select the first one-off without selecting suggestions + // and cycle through the one-off items. + let oneOffs = getOneOffs(); + for (let i = 0; i < oneOffs.length; ++i) { + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + } + + // One more alt+down keypress and nothing should be selected. + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // another one and the first one-off should be selected. + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + is( + textbox.selectedButton, + oneOffs[0], + "the first one-off button should be selected" + ); +}); + +add_task(async function test_alt_up() { + // close the panel using the escape key. + let promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Escape"); + await promise; + ok( + !textbox.selectedButton, + "no one-off button should be selected after closing the panel" + ); + + // check that alt+up opens the panel... + promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeKey("KEY_ArrowUp", { altKey: true }); + await promise; + + // ... and does nothing else. + ok(!textbox.selectedButton, "no one-off button should be selected"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, kUserValue, "the textfield value should be unmodified"); + + // Pressing alt+up should select the last one-off without selecting suggestions + // and cycle up through the one-off items. + let oneOffs = getOneOffs(); + for (let i = oneOffs.length - 1; i >= 0; --i) { + EventUtils.synthesizeKey("KEY_ArrowUp", { altKey: true }); + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + } + + // One more alt+down keypress and nothing should be selected. + EventUtils.synthesizeKey("KEY_ArrowUp", { altKey: true }); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // another one and the last one-off should be selected. + EventUtils.synthesizeKey("KEY_ArrowUp", { altKey: true }); + is( + textbox.selectedButton, + oneOffs[oneOffs.length - 1], + "the last one-off button should be selected" + ); + + // Cleanup for the next test. + EventUtils.synthesizeKey("KEY_ArrowDown"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + EventUtils.synthesizeKey("KEY_ArrowDown"); + ok(!textbox.selectedButton, "no one-off should be selected anymore"); +}); + +add_task(async function test_accel_down() { + // Pressing accel+down should select the next visible search engine, without + // selecting suggestions. + let engines = await Services.search.getVisibleEngines(); + let current = Services.search.defaultEngine; + let currIdx = -1; + for (let i = 0, l = engines.length; i < l; ++i) { + if (engines[i].name == current.name) { + currIdx = i; + break; + } + } + for (let i = 0, l = engines.length; i < l; ++i) { + EventUtils.synthesizeKey("KEY_ArrowDown", { accelKey: true }); + await SearchTestUtils.promiseSearchNotification( + "engine-default", + "browser-search-engine-modified" + ); + let expected = engines[++currIdx % engines.length]; + is( + Services.search.defaultEngine.name, + expected.name, + "Default engine should have changed" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + } + Services.search.defaultEngine = current; +}); + +add_task(async function test_accel_up() { + // Pressing accel+down should select the previous visible search engine, without + // selecting suggestions. + let engines = await Services.search.getVisibleEngines(); + let current = Services.search.defaultEngine; + let currIdx = -1; + for (let i = 0, l = engines.length; i < l; ++i) { + if (engines[i].name == current.name) { + currIdx = i; + break; + } + } + for (let i = 0, l = engines.length; i < l; ++i) { + EventUtils.synthesizeKey("KEY_ArrowUp", { accelKey: true }); + await SearchTestUtils.promiseSearchNotification( + "engine-default", + "browser-search-engine-modified" + ); + let expected = + engines[--currIdx < 0 ? (currIdx = engines.length - 1) : currIdx]; + is( + Services.search.defaultEngine.name, + expected.name, + "Default engine should have changed" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + } + Services.search.defaultEngine = current; +}); + +add_task(async function test_tab_and_arrows() { + // Check the initial state is as expected. + ok(!textbox.selectedButton, "no one-off button should be selected"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, kUserValue, "the textfield value should be unmodified"); + + // After pressing down, the first sugggestion should be selected. + EventUtils.synthesizeKey("KEY_ArrowDown"); + is(searchPopup.selectedIndex, 0, "first suggestion should be selected"); + is(textbox.value, kValues[0], "the textfield value should have changed"); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // After pressing tab, the first one-off should be selected, + // and no suggestion should be selected. + let oneOffs = getOneOffs(); + EventUtils.synthesizeKey("KEY_Tab"); + is( + textbox.selectedButton, + oneOffs[0], + "the first one-off button should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // After pressing down, the second one-off should be selected. + EventUtils.synthesizeKey("KEY_ArrowDown"); + is( + textbox.selectedButton, + oneOffs[1], + "the second one-off button should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // After pressing right, the third one-off should be selected. + EventUtils.synthesizeKey("KEY_ArrowRight"); + is( + textbox.selectedButton, + oneOffs[2], + "the third one-off button should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // After pressing left, the second one-off should be selected again. + EventUtils.synthesizeKey("KEY_ArrowLeft"); + is( + textbox.selectedButton, + oneOffs[1], + "the second one-off button should be selected again" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // After pressing up, the first one-off should be selected again. + EventUtils.synthesizeKey("KEY_ArrowUp"); + is( + textbox.selectedButton, + oneOffs[0], + "the first one-off button should be selected again" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // After pressing up again, the last suggestion should be selected. + // the textfield value back to the user-typed value, and still the first one-off + // selected. + EventUtils.synthesizeKey("KEY_ArrowUp"); + is( + searchPopup.selectedIndex, + kValues.length - 1, + "last suggestion should be selected" + ); + is( + textbox.value, + kValues[kValues.length - 1], + "the textfield value should match the suggestion" + ); + is(textbox.selectedButton, null, "no one-off button should be selected"); + + // Now pressing down should select the first one-off. + EventUtils.synthesizeKey("KEY_ArrowDown"); + is( + textbox.selectedButton, + oneOffs[0], + "the first one-off button should be selected" + ); + is(searchPopup.selectedIndex, -1, "there should be no selected suggestion"); + + // Finally close the panel. + let promise = promiseEvent(searchPopup, "popuphidden"); + searchPopup.hidePopup(); + await promise; +}); + +add_task(async function test_open_search() { + let rootDir = getRootDirectory(gTestPath); + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + rootDir + "opensearch.html" + ); + + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + searchbar.focus(); + await promise; + + let engines = searchPopup.querySelectorAll( + ".searchbar-engine-one-off-add-engine" + ); + is(engines.length, 3, "the opensearch.html page exposes 3 engines"); + + // Check that there's initially no selection. + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + ok(!textbox.selectedButton, "no button should be selected"); + + // Pressing up once selects the setting button... + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + // ...and then pressing up selects open search engines. + for (let i = engines.length; i; --i) { + EventUtils.synthesizeKey("KEY_ArrowUp"); + let selectedButton = textbox.selectedButton; + is( + selectedButton, + engines[i - 1], + "the engine #" + i + " should be selected" + ); + ok( + selectedButton.classList.contains("searchbar-engine-one-off-add-engine"), + "the button is themed as an add engine" + ); + } + + // Pressing up again should select the last one-off button. + EventUtils.synthesizeKey("KEY_ArrowUp"); + const allOneOffs = getOneOffs(); + is( + textbox.selectedButton, + allOneOffs[allOneOffs.length - engines.length - 1], + "the last one-off button should be selected" + ); + + info("now check that the down key navigates open search items as expected"); + for (let i = 0; i < engines.length; ++i) { + EventUtils.synthesizeKey("KEY_ArrowDown"); + is( + textbox.selectedButton, + engines[i], + "the engine #" + (i + 1) + " should be selected" + ); + } + + // Pressing down on the last engine item selects the settings button. + EventUtils.synthesizeKey("KEY_ArrowDown"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + promise = promiseEvent(searchPopup, "popuphidden"); + searchPopup.hidePopup(); + await promise; + + gBrowser.removeCurrentTab(); +}); + +add_task(async function cleanup() { + info("removing search history values: " + kValues); + let removeOps = kValues.map(value => { + return { op: "remove", fieldname: "searchbar-history", value }; + }); + await FormHistory.update(removeOps); + + textbox.value = ""; +}); diff --git a/browser/components/search/test/browser/browser_searchbar_openpopup.js b/browser/components/search/test/browser/browser_searchbar_openpopup.js new file mode 100644 index 0000000000..a8fe11dbf4 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_openpopup.js @@ -0,0 +1,794 @@ +// Tests that the suggestion popup appears at the right times in response to +// focus and user events (mouse, keyboard, drop). + +const searchPopup = document.getElementById("PopupSearchAutoComplete"); +const kValues = ["long text", "long text 2", "long text 3"]; + +async function endCustomizing(aWindow = window) { + if (aWindow.document.documentElement.getAttribute("customizing") != "true") { + return true; + } + let eventPromise = BrowserTestUtils.waitForEvent( + aWindow.gNavToolbox, + "aftercustomization" + ); + aWindow.gCustomizeMode.exit(); + return eventPromise; +} + +async function startCustomizing(aWindow = window) { + if (aWindow.document.documentElement.getAttribute("customizing") == "true") { + return true; + } + let eventPromise = BrowserTestUtils.waitForEvent( + aWindow.gNavToolbox, + "customizationready" + ); + aWindow.gCustomizeMode.enter(); + return eventPromise; +} + +let searchbar; +let textbox; +let searchIcon; +let goButton; +let engine; + +add_setup(async function () { + searchbar = await gCUITestUtils.addSearchBar(); + textbox = searchbar.textbox; + searchIcon = searchbar.querySelector(".searchbar-search-button"); + goButton = searchbar.querySelector(".search-go-button"); + + engine = await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine.xml", + setAsDefault: true, + }); + + await clearSearchbarHistory(); + + let addOps = kValues.map(value => { + return { op: "add", fieldname: "searchbar-history", value }; + }); + info("adding search history values: " + kValues); + await FormHistory.update(addOps); + + registerCleanupFunction(async () => { + await clearSearchbarHistory(); + gCUITestUtils.removeSearchBar(); + }); +}); + +// Adds a task that shouldn't show the search suggestions popup. +function add_no_popup_task(task) { + add_task(async function () { + let sawPopup = false; + function listener() { + sawPopup = true; + } + + info("Entering test " + task.name); + searchPopup.addEventListener("popupshowing", listener); + await task(); + searchPopup.removeEventListener("popupshowing", listener); + ok(!sawPopup, "Shouldn't have seen the suggestions popup"); + info("Leaving test " + task.name); + }); +} + +// Simulates the full set of events for a context click +function context_click(target) { + for (let event of ["mousedown", "contextmenu", "mouseup"]) { + EventUtils.synthesizeMouseAtCenter(target, { type: event, button: 2 }); + } +} + +// Right clicking the icon should not open the popup. +add_no_popup_task(async function open_icon_context() { + gURLBar.focus(); + let toolbarPopup = document.getElementById("toolbar-context-menu"); + + let promise = promiseEvent(toolbarPopup, "popupshown"); + context_click(searchIcon); + await promise; + + promise = promiseEvent(toolbarPopup, "popuphidden"); + toolbarPopup.hidePopup(); + await promise; +}); + +// With no text in the search box left clicking the icon should open the popup. +// Clicking the icon again should hide the popup and not show it again. +add_task(async function open_empty() { + gURLBar.focus(); + + let promise = promiseEvent(searchPopup, "popupshown"); + info("Clicking icon"); + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + await promise; + is( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should only show the settings" + ); + is(textbox.mController.searchString, "", "Should be an empty search string"); + + let image = searchPopup.querySelector(".searchbar-engine-image"); + Assert.equal( + image.src, + engine.getIconURLBySize(16, 16), + "Should have the correct icon" + ); + + // By giving the textbox some text any next attempt to open the search popup + // from the click handler will try to search for this text. + textbox.value = "foo"; + + promise = promiseEvent(searchPopup, "popuphidden"); + + info("Hiding popup"); + await EventUtils.promiseNativeMouseEventAndWaitForEvent({ + type: "click", + target: searchIcon, + atCenter: true, + eventTypeToWait: "mouseup", + }); + await promise; + + is( + textbox.mController.searchString, + "", + "Should not have started to search for the new text" + ); + + // Cancel the search if it started. + if (textbox.mController.searchString != "") { + textbox.mController.stopSearch(); + } + + textbox.value = ""; +}); + +// With no text in the search box left clicking it should not open the popup. +add_no_popup_task(function click_doesnt_open_popup() { + gURLBar.focus(); + + EventUtils.synthesizeMouseAtCenter(textbox, {}); + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 0, "Should have selected all of the text"); +}); + +// Left clicking in a non-empty search box when unfocused should focus it and open the popup. +add_task(async function click_opens_popup() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter(textbox, {}); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + promise = promiseEvent(searchPopup, "popuphidden"); + searchPopup.hidePopup(); + await promise; + + textbox.value = ""; +}); + +add_task(async function open_empty_hiddenOneOffs() { + // Disable all the engines but the current one and check the oneoffs. + let defaultEngine = await Services.search.getDefault(); + let engines = (await Services.search.getVisibleEngines()).filter( + e => e.name != defaultEngine.name + ); + await SpecialPowers.pushPrefEnv({ + set: [["browser.search.hiddenOneOffs", engines.map(e => e.name).join(",")]], + }); + + textbox.value = "foo"; + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter(textbox, {}); + await promise; + + Assert.ok( + searchPopup.searchOneOffsContainer.hasAttribute("hidden"), + "The one-offs buttons container should have the hidden attribute." + ); + Assert.ok( + BrowserTestUtils.is_hidden(searchPopup.searchOneOffsContainer), + "The one-off buttons container should be hidden." + ); + + promise = promiseEvent(searchPopup, "popuphidden"); + + info("Hiding popup"); + await EventUtils.promiseNativeMouseEventAndWaitForEvent({ + type: "click", + target: searchIcon, + atCenter: true, + eventTypeToWait: "mouseup", + }); + await promise; + + await SpecialPowers.popPrefEnv(); + textbox.value = ""; +}); + +// Right clicking in a non-empty search box when unfocused should open the edit context menu. +add_no_popup_task(async function right_click_doesnt_open_popup() { + gURLBar.focus(); + textbox.value = "foo"; + + // Can't wait for an event on the actual menu since it is created + // lazily the first time it is displayed. + let promise = new Promise(resolve => { + let listener = event => { + if (searchbar._menupopup && event.target == searchbar._menupopup) { + resolve(searchbar._menupopup); + } + }; + window.addEventListener("popupshown", listener); + }); + context_click(textbox); + let contextPopup = await promise; + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + promise = promiseEvent(contextPopup, "popuphidden"); + contextPopup.hidePopup(); + await promise; + + textbox.value = ""; +}); + +// Moving focus away from the search box should close the popup +add_task(async function focus_change_closes_popup() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter(textbox, {}); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + promise = promiseEvent(searchPopup, "popuphidden"); + let promise2 = promiseEvent(searchbar.textbox, "blur"); + EventUtils.synthesizeKey("KEY_Tab", { shiftKey: true }); + await promise; + await promise2; + + textbox.value = ""; +}); + +// Moving focus away from the search box should close the small popup +add_task(async function focus_change_closes_small_popup() { + gURLBar.focus(); + + let promise = promiseEvent(searchPopup, "popupshown"); + // For some reason sending the mouse event immediately doesn't open the popup. + SimpleTest.executeSoon(() => { + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + }); + await promise; + is( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the small popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + + promise = promiseEvent(searchPopup, "popuphidden"); + let promise2 = promiseEvent(searchbar.textbox, "blur"); + EventUtils.synthesizeKey("KEY_Tab", { shiftKey: true }); + await promise; + await promise2; +}); + +// Pressing escape should close the popup. +add_task(async function escape_closes_popup() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter(textbox, {}); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Escape"); + await promise; + + textbox.value = ""; +}); + +// Pressing contextmenu should close the popup. +add_task(async function contextmenu_closes_popup() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter(textbox, {}); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + let contextPopup = searchbar._menupopup; + let contextMenuShownPromise = promiseEvent(contextPopup, "popupshown"); + let searchPopupHiddenPromise = promiseEvent(searchPopup, "popuphidden"); + context_click(textbox); + await contextMenuShownPromise; + await searchPopupHiddenPromise; + + let contextMenuHiddenPromise = promiseEvent(contextPopup, "popuphidden"); + contextPopup.hidePopup(); + await contextMenuHiddenPromise; + + textbox.value = ""; +}); + +// Tabbing to the search box should open the popup if it contains text. +add_task(async function tab_opens_popup() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeKey("KEY_Tab"); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + promise = promiseEvent(searchPopup, "popuphidden"); + searchPopup.hidePopup(); + await promise; + + textbox.value = ""; +}); + +// Tabbing to the search box should not open the popup if it doesn't contain text. +add_no_popup_task(function tab_doesnt_open_popup() { + gURLBar.focus(); + textbox.value = "foo"; + + EventUtils.synthesizeKey("KEY_Tab"); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + textbox.value = ""; +}); + +// Switching back to the window when the search box has focus from mouse should not open the popup. +add_task(async function refocus_window_doesnt_open_popup_mouse() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter(searchbar, {}); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + promise = promiseEvent(searchPopup, "popuphidden"); + let newWin = OpenBrowserWindow(); + await new Promise(resolve => waitForFocus(resolve, newWin)); + await promise; + + function listener() { + ok(false, "Should not have shown the popup."); + } + searchPopup.addEventListener("popupshowing", listener); + + promise = promiseEvent(searchbar.textbox, "focus"); + newWin.close(); + await promise; + + // Wait a few ticks to allow any focus handlers to show the popup if they are going to. + await new Promise(resolve => executeSoon(resolve)); + await new Promise(resolve => executeSoon(resolve)); + await new Promise(resolve => executeSoon(resolve)); + + searchPopup.removeEventListener("popupshowing", listener); + textbox.value = ""; +}); + +// Switching back to the window when the search box has focus from keyboard should not open the popup. +add_task(async function refocus_window_doesnt_open_popup_keyboard() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeKey("KEY_Tab"); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + promise = promiseEvent(searchPopup, "popuphidden"); + let newWin = OpenBrowserWindow(); + await new Promise(resolve => waitForFocus(resolve, newWin)); + await promise; + + function listener() { + ok(false, "Should not have shown the popup."); + } + searchPopup.addEventListener("popupshowing", listener); + + promise = promiseEvent(searchbar.textbox, "focus"); + newWin.close(); + await promise; + + // Wait a few ticks to allow any focus handlers to show the popup if they are going to. + await new Promise(resolve => executeSoon(resolve)); + await new Promise(resolve => executeSoon(resolve)); + await new Promise(resolve => executeSoon(resolve)); + + searchPopup.removeEventListener("popupshowing", listener); + textbox.value = ""; +}); + +// Clicking the search go button shouldn't open the popup +add_no_popup_task(async function search_go_doesnt_open_popup() { + gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser); + + gURLBar.focus(); + textbox.value = "foo"; + searchbar.updateGoButtonVisibility(); + + let promise = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + EventUtils.synthesizeMouseAtCenter(goButton, {}); + await promise; + + textbox.value = ""; + gBrowser.removeCurrentTab(); +}); + +// Clicks outside the search popup should close the popup but not consume the click. +add_task(async function dont_consume_clicks() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter(textbox, {}); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + is(textbox.selectionStart, 0, "Should have selected all of the text"); + is(textbox.selectionEnd, 3, "Should have selected all of the text"); + + promise = promiseEvent(searchPopup, "popuphidden"); + await EventUtils.promiseNativeMouseEventAndWaitForEvent({ + type: "click", + target: gURLBar.inputField, + atCenter: true, + eventTypeToWait: "mouseup", + }); + await promise; + + is( + Services.focus.focusedElement, + gURLBar.inputField, + "Should have focused the URL bar" + ); + + textbox.value = ""; +}); + +// Dropping text to the searchbar should open the popup +add_task(async function drop_opens_popup() { + CustomizableUI.addWidgetToArea("home-button", "nav-bar"); + // The previous task leaves focus in the URL bar. However, in that case drags + // can be interpreted as being selection drags by the drag manager, which + // breaks the drag synthesis from EventUtils.js below. To avoid this, focus + // the browser content instead. + let focusEventPromise = BrowserTestUtils.waitForEvent( + gBrowser.selectedBrowser, + "focus" + ); + gBrowser.selectedBrowser.focus(); + await focusEventPromise; + + let promise = promiseEvent(searchPopup, "popupshown"); + // Use a source for the drop that is outside of the search bar area, to avoid + // it receiving a mousedown and causing the popup to sometimes open. + let homeButton = document.getElementById("home-button"); + EventUtils.synthesizeDrop( + homeButton, + textbox, + [[{ type: "text/plain", data: "foo" }]], + "move", + window + ); + await promise; + + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + is( + Services.focus.focusedElement, + textbox, + "Should have focused the search bar" + ); + promise = promiseEvent(searchPopup, "popuphidden"); + searchPopup.hidePopup(); + await promise; + + textbox.value = ""; + CustomizableUI.removeWidgetFromArea("home-button"); +}); + +// Moving the caret using the cursor keys should not close the popup. +add_task(async function dont_rollup_oncaretmove() { + gURLBar.focus(); + textbox.value = "long text"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeMouseAtCenter(textbox, {}); + await promise; + + // Deselect the text + EventUtils.synthesizeKey("KEY_ArrowRight"); + is( + textbox.selectionStart, + 9, + "Should have moved the caret (selectionStart after deselect right)" + ); + is( + textbox.selectionEnd, + 9, + "Should have moved the caret (selectionEnd after deselect right)" + ); + is(searchPopup.state, "open", "Popup should still be open"); + + EventUtils.synthesizeKey("KEY_ArrowLeft"); + is( + textbox.selectionStart, + 8, + "Should have moved the caret (selectionStart after left)" + ); + is( + textbox.selectionEnd, + 8, + "Should have moved the caret (selectionEnd after left)" + ); + is(searchPopup.state, "open", "Popup should still be open"); + + EventUtils.synthesizeKey("KEY_ArrowRight"); + is( + textbox.selectionStart, + 9, + "Should have moved the caret (selectionStart after right)" + ); + is( + textbox.selectionEnd, + 9, + "Should have moved the caret (selectionEnd after right)" + ); + is(searchPopup.state, "open", "Popup should still be open"); + + // Ensure caret movement works while a suggestion is selected. + is(textbox.popup.selectedIndex, -1, "No selected item in list"); + EventUtils.synthesizeKey("KEY_ArrowDown"); + is(textbox.popup.selectedIndex, 0, "Selected item in list"); + is( + textbox.selectionStart, + 9, + "Should have moved the caret to the end (selectionStart after selection)" + ); + is( + textbox.selectionEnd, + 9, + "Should have moved the caret to the end (selectionEnd after selection)" + ); + + EventUtils.synthesizeKey("KEY_ArrowLeft"); + is( + textbox.selectionStart, + 8, + "Should have moved the caret again (selectionStart after left)" + ); + is( + textbox.selectionEnd, + 8, + "Should have moved the caret again (selectionEnd after left)" + ); + is(searchPopup.state, "open", "Popup should still be open"); + + EventUtils.synthesizeKey("KEY_ArrowLeft"); + is( + textbox.selectionStart, + 7, + "Should have moved the caret (selectionStart after left)" + ); + is( + textbox.selectionEnd, + 7, + "Should have moved the caret (selectionEnd after left)" + ); + is(searchPopup.state, "open", "Popup should still be open"); + + EventUtils.synthesizeKey("KEY_ArrowRight"); + is( + textbox.selectionStart, + 8, + "Should have moved the caret (selectionStart after right)" + ); + is( + textbox.selectionEnd, + 8, + "Should have moved the caret (selectionEnd after right)" + ); + is(searchPopup.state, "open", "Popup should still be open"); + + if (!navigator.platform.includes("Mac")) { + EventUtils.synthesizeKey("KEY_Home"); + is( + textbox.selectionStart, + 0, + "Should have moved the caret (selectionStart after home)" + ); + is( + textbox.selectionEnd, + 0, + "Should have moved the caret (selectionEnd after home)" + ); + is(searchPopup.state, "open", "Popup should still be open"); + } + + // Close the popup again + promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Escape"); + await promise; + + textbox.value = ""; +}); + +// Entering customization mode shouldn't open the popup. +add_task(async function dont_open_in_customization() { + gURLBar.focus(); + textbox.value = "foo"; + + let promise = promiseEvent(searchPopup, "popupshown"); + EventUtils.synthesizeKey("KEY_Tab"); + await promise; + isnot( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the full popup" + ); + + info("Entering customization mode"); + let sawPopup = false; + function listener() { + sawPopup = true; + } + searchPopup.addEventListener("popupshowing", listener); + await gCUITestUtils.openMainMenu(); + promise = promiseEvent(searchPopup, "popuphidden"); + await startCustomizing(); + await promise; + + searchPopup.removeEventListener("popupshowing", listener); + ok(!sawPopup, "Shouldn't have seen the suggestions popup"); + + await endCustomizing(); + textbox.value = ""; +}); + +add_task(async function cleanup() { + info("removing search history values: " + kValues); + let removeOps = kValues.map(value => { + return { op: "remove", fieldname: "searchbar-history", value }; + }); + FormHistory.update(removeOps); +}); diff --git a/browser/components/search/test/browser/browser_searchbar_results.js b/browser/components/search/test/browser/browser_searchbar_results.js new file mode 100644 index 0000000000..95bb5674c7 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_results.js @@ -0,0 +1,60 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +add_setup(async function () { + await gCUITestUtils.addSearchBar(); + await clearSearchbarHistory(); + + await SearchTestUtils.installSearchExtension( + { + id: "test", + name: "test", + suggest_url: + "https://example.com/browser/browser/components/search/test/browser/searchSuggestionEngine.sjs", + suggest_url_get_params: "query={searchTerms}", + }, + { setAsDefault: true } + ); + + registerCleanupFunction(async () => { + await clearSearchbarHistory(); + gCUITestUtils.removeSearchBar(); + }); +}); + +async function check_results(input, expected) { + await BrowserTestUtils.withNewTab( + { + gBrowser, + url: "about:blank", + }, + async browser => { + let popup = await searchInSearchbar(input); + + const listItemElems = popup.richlistbox.querySelectorAll( + ".autocomplete-richlistitem" + ); + + Assert.deepEqual( + Array.from(listItemElems) + .filter(e => !e.collapsed) + .map(e => e.getAttribute("title")), + expected, + "Should have received the expected suggestions" + ); + + // Now visit the search to put an item in form history. + let p = BrowserTestUtils.browserLoaded(browser); + EventUtils.synthesizeKey("KEY_Enter"); + await p; + } + ); +} + +add_task(async function test_utf8_results() { + await check_results("。", ["。foo", "。bar"]); + + // The first run added the entry into form history, check that is correct + // as well. + await check_results("。", ["。", "。foo", "。bar"]); +}); diff --git a/browser/components/search/test/browser/browser_searchbar_smallpanel_keyboard_navigation.js b/browser/components/search/test/browser/browser_searchbar_smallpanel_keyboard_navigation.js new file mode 100644 index 0000000000..e2ddadabd9 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_smallpanel_keyboard_navigation.js @@ -0,0 +1,449 @@ +// Tests that keyboard navigation in the search panel works as designed. + +const searchPopup = document.getElementById("PopupSearchAutoComplete"); + +const kValues = ["foo1", "foo2", "foo3"]; + +function getOpenSearchItems() { + let os = []; + + let addEngineList = searchPopup.querySelector(".search-add-engines"); + for ( + let item = addEngineList.firstElementChild; + item; + item = item.nextElementSibling + ) { + os.push(item); + } + + return os; +} + +let searchbar; +let textbox; +let searchIcon; + +add_setup(async function () { + searchbar = await gCUITestUtils.addSearchBar(); + registerCleanupFunction(() => { + gCUITestUtils.removeSearchBar(); + }); + textbox = searchbar.textbox; + searchIcon = searchbar.querySelector(".searchbar-search-button"); + + await SearchTestUtils.promiseNewSearchEngine({ + url: getRootDirectory(gTestPath) + "testEngine.xml", + setAsDefault: true, + }); + + // First cleanup the form history in case other tests left things there. + info("cleanup the search history"); + await FormHistory.update({ op: "remove", fieldname: "searchbar-history" }); + + info("adding search history values: " + kValues); + let addOps = kValues.map(value => { + return { op: "add", fieldname: "searchbar-history", value }; + }); + await FormHistory.update(addOps); + + registerCleanupFunction(async () => { + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function test_arrows() { + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + await promise; + info( + "textbox.mController.searchString = " + textbox.mController.searchString + ); + is(textbox.mController.searchString, "", "The search string should be empty"); + + // Check the initial state of the panel before sending keyboard events. + is( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the small popup" + ); + // Having suggestions populated (but hidden) is important, because if there + // are none we can't ensure the keyboard events don't reach them. + is(searchPopup.matchCount, kValues.length, "There should be 3 suggestions"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // The tests will be less meaningful if the first, second, last, and + // before-last one-off buttons aren't different. We should always have more + // than 4 default engines, but it's safer to check this assumption. + let oneOffs = getOneOffs(); + ok(oneOffs.length >= 4, "we have at least 4 one-off buttons displayed"); + + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // Pressing should select the first one-off. + EventUtils.synthesizeKey("KEY_ArrowDown"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, "", "the textfield value should be unmodified"); + + // now cycle through the one-off items, the first one is already selected. + for (let i = 0; i < oneOffs.length; ++i) { + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + EventUtils.synthesizeKey("KEY_ArrowDown"); + } + + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + EventUtils.synthesizeKey("KEY_ArrowDown"); + + // We should now be back to the initial situation. + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + info("now test the up arrow key"); + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + // cycle through the one-off items, the first one is already selected. + for (let i = oneOffs.length; i; --i) { + EventUtils.synthesizeKey("KEY_ArrowUp"); + is( + textbox.selectedButton, + oneOffs[i - 1], + "the one-off button #" + i + " should be selected" + ); + } + + // Another press on up should clear the one-off selection. + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok(!textbox.selectedButton, "no one-off button should be selected"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, "", "the textfield value should be unmodified"); +}); + +add_task(async function test_tab() { + is( + Services.focus.focusedElement, + textbox, + "the search bar should be focused" + ); // from the previous test. + + let oneOffs = getOneOffs(); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // Pressing tab should select the first one-off without selecting suggestions. + // now cycle through the one-off items, the first one is already selected. + for (let i = 0; i < oneOffs.length; ++i) { + EventUtils.synthesizeKey("KEY_Tab"); + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + } + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, "", "the textfield value should be unmodified"); + + // One more <tab> selects the settings button. + EventUtils.synthesizeKey("KEY_Tab"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + // Pressing tab again should close the panel... + let promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Tab"); + await promise; + + // ... and move the focus out of the searchbox. + isnot( + Services.focus.focusedElement, + textbox, + "the search bar no longer be focused" + ); +}); + +add_task(async function test_shift_tab() { + // First reopen the panel. + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + SimpleTest.executeSoon(() => { + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + }); + await promise; + + let oneOffs = getOneOffs(); + ok(!textbox.selectedButton, "no one-off button should be selected"); + is( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the small popup" + ); + + // Press up once to select the last button. + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + // Press up again to select the last one-off button. + EventUtils.synthesizeKey("KEY_ArrowUp"); + + // Pressing shift+tab should cycle through the one-off items. + for (let i = oneOffs.length - 1; i >= 0; --i) { + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + if (i) { + EventUtils.synthesizeKey("KEY_Tab", { shiftKey: true }); + } + } + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, "", "the textfield value should be unmodified"); + + // Pressing shift+tab again should close the panel... + promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Tab", { shiftKey: true }); + await promise; + + // ... and move the focus out of the searchbox. + isnot( + Services.focus.focusedElement, + textbox, + "the search bar no longer be focused" + ); +}); + +add_task(async function test_alt_down() { + // First reopen the panel. + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + SimpleTest.executeSoon(() => { + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + }); + await promise; + + // and check it's in a correct initial state. + is( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the small popup" + ); + ok(!textbox.selectedButton, "no one-off button should be selected"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, "", "the textfield value should be unmodified"); + + // Pressing alt+down should select the first one-off without selecting suggestions + // and cycle through the one-off items. + let oneOffs = getOneOffs(); + for (let i = 0; i < oneOffs.length; ++i) { + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + } + + // One more alt+down keypress and nothing should be selected. + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // another one and the first one-off should be selected. + EventUtils.synthesizeKey("KEY_ArrowDown", { altKey: true }); + is( + textbox.selectedButton, + oneOffs[0], + "the first one-off button should be selected" + ); + + // Clear the selection with an alt+up keypress + EventUtils.synthesizeKey("KEY_ArrowUp", { altKey: true }); + ok(!textbox.selectedButton, "no one-off button should be selected"); +}); + +add_task(async function test_alt_up() { + // Check the initial state of the panel + ok(!textbox.selectedButton, "no one-off button should be selected"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, "", "the textfield value should be unmodified"); + + // Pressing alt+up should select the last one-off without selecting suggestions + // and cycle up through the one-off items. + let oneOffs = getOneOffs(); + for (let i = oneOffs.length - 1; i >= 0; --i) { + EventUtils.synthesizeKey("KEY_ArrowUp", { altKey: true }); + is( + textbox.selectedButton, + oneOffs[i], + "the one-off button #" + (i + 1) + " should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + } + + // One more alt+down keypress and nothing should be selected. + EventUtils.synthesizeKey("KEY_ArrowUp", { altKey: true }); + ok(!textbox.selectedButton, "no one-off button should be selected"); + + // another one and the last one-off should be selected. + EventUtils.synthesizeKey("KEY_ArrowUp", { altKey: true }); + is( + textbox.selectedButton, + oneOffs[oneOffs.length - 1], + "the last one-off button should be selected" + ); + + // Cleanup for the next test. + EventUtils.synthesizeKey("KEY_ArrowDown"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + EventUtils.synthesizeKey("KEY_ArrowDown"); + ok(!textbox.selectedButton, "no one-off should be selected anymore"); +}); + +add_task(async function test_tab_and_arrows() { + // Check the initial state is as expected. + ok(!textbox.selectedButton, "no one-off button should be selected"); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + is(textbox.value, "", "the textfield value should be unmodified"); + + // After pressing down, the first one-off should be selected. + let oneOffs = getOneOffs(); + EventUtils.synthesizeKey("KEY_ArrowDown"); + is( + textbox.selectedButton, + oneOffs[0], + "the first one-off button should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // After pressing tab, the second one-off should be selected. + EventUtils.synthesizeKey("KEY_Tab"); + is( + textbox.selectedButton, + oneOffs[1], + "the second one-off button should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // After pressing up, the first one-off should be selected again. + EventUtils.synthesizeKey("KEY_ArrowUp"); + is( + textbox.selectedButton, + oneOffs[0], + "the first one-off button should be selected" + ); + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + + // Finally close the panel. + let promise = promiseEvent(searchPopup, "popuphidden"); + searchPopup.hidePopup(); + await promise; +}); + +add_task(async function test_open_search() { + let rootDir = getRootDirectory(gTestPath); + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + rootDir + "opensearch.html" + ); + + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + EventUtils.synthesizeMouseAtCenter(searchIcon, {}); + await promise; + is( + searchPopup.getAttribute("showonlysettings"), + "true", + "Should show the small popup" + ); + + let engines; + await TestUtils.waitForCondition(() => { + engines = searchPopup.querySelectorAll( + ".searchbar-engine-one-off-add-engine" + ); + return engines.length == 3; + }, "Should expose three engines"); + + // Check that there's initially no selection. + is(searchPopup.selectedIndex, -1, "no suggestion should be selected"); + ok(!textbox.selectedButton, "no button should be selected"); + + // Pressing up once selects the setting button... + EventUtils.synthesizeKey("KEY_ArrowUp"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + // ...and then pressing up selects open search engines. + for (let i = engines.length; i; --i) { + EventUtils.synthesizeKey("KEY_ArrowUp"); + let selectedButton = textbox.selectedButton; + is( + selectedButton, + engines[i - 1], + "the engine #" + i + " should be selected" + ); + ok( + selectedButton.classList.contains("searchbar-engine-one-off-add-engine"), + "the button is themed as an add engine" + ); + } + + // Pressing up again should select the last one-off button. + EventUtils.synthesizeKey("KEY_ArrowUp"); + const allOneOffs = getOneOffs(); + is( + textbox.selectedButton, + allOneOffs[allOneOffs.length - engines.length - 1], + "the last one-off button should be selected" + ); + + info("now check that the down key navigates open search items as expected"); + for (let i = 0; i < engines.length; ++i) { + EventUtils.synthesizeKey("KEY_ArrowDown"); + is( + textbox.selectedButton, + engines[i], + "the engine #" + (i + 1) + " should be selected" + ); + } + + // Pressing down on the last engine item selects the settings button. + EventUtils.synthesizeKey("KEY_ArrowDown"); + ok( + textbox.selectedButton.classList.contains("search-setting-button"), + "the settings item should be selected" + ); + + promise = promiseEvent(searchPopup, "popuphidden"); + searchPopup.hidePopup(); + await promise; + + gBrowser.removeCurrentTab(); +}); + +add_task(async function cleanup() { + info("removing search history values: " + kValues); + let removeOps = kValues.map(value => { + return { op: "remove", fieldname: "searchbar-history", value }; + }); + FormHistory.update(removeOps); +}); diff --git a/browser/components/search/test/browser/browser_searchbar_widths.js b/browser/components/search/test/browser/browser_searchbar_widths.js new file mode 100644 index 0000000000..3e17ebf833 --- /dev/null +++ b/browser/components/search/test/browser/browser_searchbar_widths.js @@ -0,0 +1,33 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +// Check that when the searchbar has a specific width, opening a new window +// honours that specific width. +add_task(async function test_searchbar_width_persistence() { + await gCUITestUtils.addSearchBar(); + registerCleanupFunction(async function () { + gCUITestUtils.removeSearchBar(); + }); + + // Really, we should use the splitter, but drag/drop is hard and fragile in + // tests, so let's just fake it real quick: + let container = BrowserSearch.searchBar.parentNode; + // There's no width attribute set initially, just grab the info from layout: + let oldWidth = container.getBoundingClientRect().width; + let newWidth = "" + Math.round(oldWidth * 2); + container.setAttribute("width", newWidth); + + let win = await BrowserTestUtils.openNewBrowserWindow(); + let otherBar = win.BrowserSearch.searchBar; + ok(otherBar, "Should have a search bar in the other window"); + if (otherBar) { + is( + otherBar.parentNode.getAttribute("width"), + newWidth, + "Should have matching width" + ); + } + await BrowserTestUtils.closeWindow(win); +}); diff --git a/browser/components/search/test/browser/browser_tooManyEnginesOffered.js b/browser/components/search/test/browser/browser_tooManyEnginesOffered.js new file mode 100644 index 0000000000..89647f9854 --- /dev/null +++ b/browser/components/search/test/browser/browser_tooManyEnginesOffered.js @@ -0,0 +1,68 @@ +"use strict"; + +// This test makes sure that when a page offers many search engines, +// a limited number of add-engine items will be shown in the searchbar. + +const searchPopup = document.getElementById("PopupSearchAutoComplete"); + +add_task(async function test_setup() { + await gCUITestUtils.addSearchBar(); + + await Services.search.init(); + registerCleanupFunction(() => { + gCUITestUtils.removeSearchBar(); + }); +}); + +add_task(async function test() { + let searchbar = BrowserSearch.searchBar; + + let rootDir = getRootDirectory(gTestPath); + let url = rootDir + "tooManyEnginesOffered.html"; + await BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + // Open the search popup. + let promise = promiseEvent(searchPopup, "popupshown"); + info("Opening search panel"); + searchbar.focus(); + // In TV we may try opening too early, when the searchbar is not ready yet. + await TestUtils.waitForCondition( + () => BrowserSearch.searchBar.textbox.controller.input, + "Wait for the searchbar controller to connect" + ); + EventUtils.synthesizeKey("KEY_ArrowDown"); + await promise; + + const addEngineList = searchPopup.oneOffButtons._getAddEngines(); + Assert.equal( + addEngineList.length, + 6, + "Expected number of engines retrieved from web page" + ); + + const displayedAddEngineList = + searchPopup.oneOffButtons.buttons.querySelectorAll( + ".searchbar-engine-one-off-add-engine" + ); + Assert.equal( + displayedAddEngineList.length, + searchPopup.oneOffButtons._maxInlineAddEngines, + "Expected number of engines displayed on popup" + ); + + for (let i = 0; i < displayedAddEngineList.length; i++) { + const engine = addEngineList[i]; + const item = displayedAddEngineList[i]; + Assert.equal( + item.getAttribute("engine-name"), + engine.title, + "Expected engine is displaying" + ); + } + + promise = promiseEvent(searchPopup, "popuphidden"); + EventUtils.synthesizeKey("KEY_Escape", {}, searchPopup.ownerGlobal); + await promise; + + gBrowser.removeCurrentTab(); +}); diff --git a/browser/components/search/test/browser/browser_trending_suggestions.js b/browser/components/search/test/browser/browser_trending_suggestions.js new file mode 100644 index 0000000000..5db741e816 --- /dev/null +++ b/browser/components/search/test/browser/browser_trending_suggestions.js @@ -0,0 +1,189 @@ +/* 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 CONFIG_DEFAULT = [ + { + webExtension: { id: "basic@search.mozilla.org" }, + urls: { + trending: { + fullPath: + "https://example.com/browser/browser/components/search/test/browser/trendingSuggestionEngine.sjs", + query: "", + }, + }, + appliesTo: [{ included: { everywhere: true } }], + default: "yes", + }, + { + webExtension: { id: "private@search.mozilla.org" }, + appliesTo: [{ included: { everywhere: true } }], + default: "yes", + }, +]; + +SearchTestUtils.init(this); + +add_setup(async () => { + // Use engines in test directory + let searchExtensions = getChromeDir(getResolvedURI(gTestPath)); + searchExtensions.append("search-engines"); + await SearchTestUtils.useMochitestEngines(searchExtensions); + + await SpecialPowers.pushPrefEnv({ + set: [["browser.urlbar.suggest.searches", true]], + }); + + SearchTestUtils.useMockIdleService(); + await SearchTestUtils.updateRemoteSettingsConfig(CONFIG_DEFAULT); + + registerCleanupFunction(async () => { + let settingsWritten = SearchTestUtils.promiseSearchNotification( + "write-settings-to-disk-complete" + ); + await SearchTestUtils.updateRemoteSettingsConfig(); + await settingsWritten; + }); +}); + +add_task(async function test_trending_results() { + await check_results({ + featureEnabled: true, + searchMode: "@basic ", + expectedResults: 2, + }); + await check_results({ + featureEnabled: true, + requireSearchModeEnabled: false, + expectedResults: 2, + }); + await check_results({ + featureEnabled: true, + requireSearchModeEnabled: false, + searchMode: "@basic ", + expectedResults: 2, + }); + await check_results({ + featureEnabled: false, + searchMode: "@basic ", + expectedResults: 0, + }); + await check_results({ + featureEnabled: false, + expectedResults: 0, + }); + await check_results({ + featureEnabled: false, + requireSearchModeEnabled: false, + expectedResults: 0, + }); + await check_results({ + featureEnabled: false, + requireSearchModeEnabled: false, + searchMode: "@basic ", + expectedResults: 0, + }); + + // The private engine is not configured with any trending url. + await check_results({ + featureEnabled: true, + searchMode: "@private ", + expectedResults: 0, + }); + + // Check we can configure the maximum number of results. + await check_results({ + featureEnabled: true, + searchMode: "@basic ", + maxResultsSearchMode: 5, + expectedResults: 5, + }); + await check_results({ + featureEnabled: true, + requireSearchModeEnabled: false, + maxResultsNoSearchMode: 5, + expectedResults: 5, + }); +}); + +add_task(async function test_trending_telemetry() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.urlbar.trending.featureGate", true], + ["browser.urlbar.trending.requireSearchMode", false], + ], + }); + + await UrlbarTestUtils.promiseAutocompleteResultPopup({ + window, + value: "", + waitForFocus: SimpleTest.waitForFocus, + }); + + await UrlbarTestUtils.promisePopupClose(window, () => { + EventUtils.synthesizeKey("KEY_ArrowDown"); + EventUtils.synthesizeKey("KEY_Enter"); + }); + + let scalars = TelemetryTestUtils.getProcessScalars("parent", true, true); + TelemetryTestUtils.assertKeyedScalar(scalars, "urlbar.picked.trending", 0, 1); +}); + +async function check_results({ + featureEnabled = false, + requireSearchModeEnabled = true, + searchMode = "", + expectedResults = 0, + maxResultsSearchMode = 2, + maxResultsNoSearchMode = 2, +}) { + await SpecialPowers.pushPrefEnv({ + set: [ + ["browser.urlbar.trending.maxResultsSearchMode", maxResultsSearchMode], + [ + "browser.urlbar.trending.maxResultsNoSearchMode", + maxResultsNoSearchMode, + ], + ["browser.urlbar.trending.featureGate", featureEnabled], + ["browser.urlbar.trending.requireSearchMode", requireSearchModeEnabled], + ], + }); + + // If we are not in a search mode and there are no results. The urlbar + // will not open. + if (!searchMode && !expectedResults) { + window.gURLBar.inputField.focus(); + Assert.ok(!UrlbarTestUtils.isPopupOpen(window)); + return; + } + + await UrlbarTestUtils.promiseAutocompleteResultPopup({ + window, + value: searchMode, + waitForFocus: SimpleTest.waitForFocus, + }); + + Assert.equal( + UrlbarTestUtils.getResultCount(window), + expectedResults, + "We matched the expected number of results" + ); + + if (expectedResults) { + for (let i = 0; i < expectedResults; i++) { + let { result } = await UrlbarTestUtils.getDetailsOfResultAt(window, i); + Assert.equal(result.type, UrlbarUtils.RESULT_TYPE.SEARCH); + Assert.equal(result.providerName, "SearchSuggestions"); + Assert.equal(result.payload.engine, "basic"); + Assert.equal(result.payload.trending, true); + } + } + + if (searchMode) { + await UrlbarTestUtils.exitSearchMode(window); + } + await UrlbarTestUtils.promisePopupClose(window, () => { + EventUtils.synthesizeKey("KEY_Escape"); + }); + await SpecialPowers.popPrefEnv(); +} diff --git a/browser/components/search/test/browser/cacheable.html b/browser/components/search/test/browser/cacheable.html new file mode 100644 index 0000000000..8aac4a0f16 --- /dev/null +++ b/browser/components/search/test/browser/cacheable.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="UTF-8"> + <meta http-equiv="X-UA-Compatible" content="IE=edge"> + <meta name="viewport" content="width=device-width, initial-scale=1.0"> + <title>Cacheable Page</title> +</head> +<body> + <p>This page is cacheable.</p> +</body> +</html> diff --git a/browser/components/search/test/browser/cacheable.html^headers^ b/browser/components/search/test/browser/cacheable.html^headers^ new file mode 100644 index 0000000000..6f34caa8f2 --- /dev/null +++ b/browser/components/search/test/browser/cacheable.html^headers^ @@ -0,0 +1 @@ +Cache-Control: max-age=3600 diff --git a/browser/components/search/test/browser/contentSearchUI.html b/browser/components/search/test/browser/contentSearchUI.html new file mode 100644 index 0000000000..09abe822b2 --- /dev/null +++ b/browser/components/search/test/browser/contentSearchUI.html @@ -0,0 +1,22 @@ +<!DOCTYPE html> +<!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> + +<html> +<head> +<meta charset="utf-8"> +<script type="application/javascript" + src="chrome://browser/content/contentSearchUI.js"> +</script> +<link rel="stylesheet" href="chrome://browser/content/contentSearchUI.css"/> +<meta http-equiv="Content-Security-Policy" content="default-src data: chrome:; object-src 'none'"/> +</head> +<body> + +<div id="container"><input type="text" value=""/></div> + +<script src="chrome://mochitests/content/browser/browser/components/search/test/browser/contentSearchUI.js"> +</script> + +</body> +</html> diff --git a/browser/components/search/test/browser/contentSearchUI.js b/browser/components/search/test/browser/contentSearchUI.js new file mode 100644 index 0000000000..7ccf0b6a6d --- /dev/null +++ b/browser/components/search/test/browser/contentSearchUI.js @@ -0,0 +1,13 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/* import-globals-from ../../content/contentSearchUI.js */ +var input = document.querySelector("input"); +var gController = new ContentSearchUIController( + input, + input.parentNode, + "test", + "test" +); diff --git a/browser/components/search/test/browser/discovery.html b/browser/components/search/test/browser/discovery.html new file mode 100644 index 0000000000..0c73d592fe --- /dev/null +++ b/browser/components/search/test/browser/discovery.html @@ -0,0 +1,9 @@ +<!DOCTYPE HTML> +<html> + <head id="linkparent"> + <meta charset="utf-8"> + <title>Autodiscovery Test</title> + </head> + <body> + </body> +</html> diff --git a/browser/components/search/test/browser/google_codes/browser.ini b/browser/components/search/test/browser/google_codes/browser.ini new file mode 100644 index 0000000000..5496ddb5c9 --- /dev/null +++ b/browser/components/search/test/browser/google_codes/browser.ini @@ -0,0 +1,5 @@ +[DEFAULT] +prefs = + browser.search.region='DE' + +[../browser_google_behavior.js] diff --git a/browser/components/search/test/browser/head.js b/browser/components/search/test/browser/head.js new file mode 100644 index 0000000000..730ea45c12 --- /dev/null +++ b/browser/components/search/test/browser/head.js @@ -0,0 +1,395 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +ChromeUtils.defineESModuleGetters(this, { + ADLINK_CHECK_TIMEOUT_MS: + "resource:///actors/SearchSERPTelemetryChild.sys.mjs", + AddonTestUtils: "resource://testing-common/AddonTestUtils.sys.mjs", + CustomizableUITestUtils: + "resource://testing-common/CustomizableUITestUtils.sys.mjs", + FormHistory: "resource://gre/modules/FormHistory.sys.mjs", + FormHistoryTestUtils: + "resource://testing-common/FormHistoryTestUtils.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", + SearchTestUtils: "resource://testing-common/SearchTestUtils.sys.mjs", + SearchUtils: "resource://gre/modules/SearchUtils.sys.mjs", + TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs", + UrlbarSearchUtils: "resource:///modules/UrlbarSearchUtils.sys.mjs", +}); + +ChromeUtils.defineLazyGetter(this, "UrlbarTestUtils", () => { + const { UrlbarTestUtils: module } = ChromeUtils.importESModule( + "resource://testing-common/UrlbarTestUtils.sys.mjs" + ); + module.init(this); + return module; +}); + +let gCUITestUtils = new CustomizableUITestUtils(window); + +AddonTestUtils.initMochitest(this); +SearchTestUtils.init(this); + +const UUID_REGEX = + /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; + +/** + * Recursively compare two objects and check that every property of expectedObj has the same value + * on actualObj. + * + * @param {object} expectedObj + * The expected object to find. + * @param {object} actualObj + * The object to inspect. + * @param {string} name + * The name of the engine, used for test detail logging. + */ +function isSubObjectOf(expectedObj, actualObj, name) { + for (let prop in expectedObj) { + if (typeof expectedObj[prop] == "function") { + continue; + } + if (expectedObj[prop] instanceof Object) { + is( + actualObj[prop].length, + expectedObj[prop].length, + name + "[" + prop + "]" + ); + isSubObjectOf( + expectedObj[prop], + actualObj[prop], + name + "[" + prop + "]" + ); + } else { + is(actualObj[prop], expectedObj[prop], name + "[" + prop + "]"); + } + } +} + +function getLocale() { + return Services.locale.requestedLocale || undefined; +} + +function promiseEvent(aTarget, aEventName, aPreventDefault) { + function cancelEvent(event) { + if (aPreventDefault) { + event.preventDefault(); + } + + return true; + } + + return BrowserTestUtils.waitForEvent(aTarget, aEventName, false, cancelEvent); +} + +// Get an array of the one-off buttons. +function getOneOffs() { + let oneOffs = []; + let searchPopup = document.getElementById("PopupSearchAutoComplete"); + let oneOffsContainer = searchPopup.searchOneOffsContainer; + let oneOff = oneOffsContainer.querySelector(".search-panel-one-offs"); + for (oneOff = oneOff.firstChild; oneOff; oneOff = oneOff.nextSibling) { + if (oneOff.nodeType == Node.ELEMENT_NODE) { + oneOffs.push(oneOff); + } + } + return oneOffs; +} + +async function typeInSearchField(browser, text, fieldName) { + await SpecialPowers.spawn( + browser, + [[fieldName, text]], + async function ([contentFieldName, contentText]) { + // Put the focus on the search box. + let searchInput = content.document.getElementById(contentFieldName); + searchInput.focus(); + searchInput.value = contentText; + } + ); +} + +XPCOMUtils.defineLazyGetter(this, "searchCounts", () => { + return Services.telemetry.getKeyedHistogramById("SEARCH_COUNTS"); +}); + +XPCOMUtils.defineLazyGetter(this, "SEARCH_AD_CLICK_SCALARS", () => { + const sources = [ + ...BrowserSearchTelemetry.KNOWN_SEARCH_SOURCES.values(), + "unknown", + ]; + return [ + ...sources.map(v => `browser.search.withads.${v}`), + ...sources.map(v => `browser.search.adclicks.${v}`), + ]; +}); + +// Ad links are processed after a small delay. We need to allow tests to wait +// for that before checking telemetry, otherwise the received values may be +// too small in some cases. +function promiseWaitForAdLinkCheck() { + return new Promise(resolve => + /* eslint-disable-next-line mozilla/no-arbitrary-setTimeout */ + setTimeout(resolve, ADLINK_CHECK_TIMEOUT_MS) + ); +} + +async function assertSearchSourcesTelemetry( + expectedHistograms, + expectedScalars +) { + let histSnapshot = {}; + let scalars = {}; + + // This used to rely on the implied 100ms initial timer of + // TestUtils.waitForCondition. See bug 1515466. + await new Promise(resolve => setTimeout(resolve, 100)); + + await TestUtils.waitForCondition(() => { + histSnapshot = searchCounts.snapshot(); + return ( + Object.getOwnPropertyNames(histSnapshot).length == + Object.getOwnPropertyNames(expectedHistograms).length + ); + }, "should have the correct number of histograms"); + + if (Object.entries(expectedScalars).length) { + await TestUtils.waitForCondition(() => { + scalars = + Services.telemetry.getSnapshotForKeyedScalars("main", false).parent || + {}; + return Object.getOwnPropertyNames(expectedScalars).every( + scalar => scalar in scalars + ); + }, "should have the expected keyed scalars"); + } + + Assert.equal( + Object.getOwnPropertyNames(histSnapshot).length, + Object.getOwnPropertyNames(expectedHistograms).length, + "Should only have one key" + ); + + for (let [key, value] of Object.entries(expectedHistograms)) { + Assert.ok( + key in histSnapshot, + `Histogram should have the expected key: ${key}` + ); + Assert.equal( + histSnapshot[key].sum, + value, + `Should have counted the correct number of visits for ${key}` + ); + } + + for (let [name, value] of Object.entries(expectedScalars)) { + Assert.ok(name in scalars, `Scalar ${name} should have been added.`); + Assert.deepEqual( + scalars[name], + value, + `Should have counted the correct number of visits for ${name}` + ); + } + + for (let name of SEARCH_AD_CLICK_SCALARS) { + Assert.equal( + name in scalars, + name in expectedScalars, + `Should have matched ${name} in scalars and expectedScalars` + ); + } +} + +async function searchInSearchbar(inputText, win = window) { + await new Promise(r => waitForFocus(r, win)); + let sb = win.BrowserSearch.searchBar; + // Write the search query in the searchbar. + sb.focus(); + sb.value = inputText; + sb.textbox.controller.startSearch(inputText); + // Wait for the popup to show. + await BrowserTestUtils.waitForEvent(sb.textbox.popup, "popupshown"); + // And then for the search to complete. + await TestUtils.waitForCondition( + () => + sb.textbox.controller.searchStatus >= + Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH, + "The search in the searchbar must complete." + ); + return sb.textbox.popup; +} + +function clearSearchbarHistory(win = window) { + info("cleanup the search history"); + return FormHistory.update({ op: "remove", fieldname: "searchbar-history" }); +} + +function resetTelemetry() { + searchCounts.clear(); + Services.telemetry.clearScalars(); + Services.fog.testResetFOG(); +} + +/** + * First checks that we get the correct number of recorded Glean impression events + * and the recorded Glean impression events have the correct keys and values. + * + * Then it checks that there are the the correct engagement events associated with the + * impression events. + * + * @param {Array} expectedEvents The expected impression events whose keys and + * values we use to validate the recorded Glean impression events. + */ +function assertImpressionEvents(expectedEvents) { + // A single test might run assertImpressionEvents more than once + // so the Set needs to be cleared or else the impression event + // check will throw. + const impressionIdsSet = new Set(); + + let recordedImpressions = Glean.serp.impression.testGetValue() ?? []; + + Assert.equal( + recordedImpressions.length, + expectedEvents.length, + "Should have the correct number of impressions." + ); + + // Assert the impression events. + for (let [idx, expectedEvent] of expectedEvents.entries()) { + let impressionId = recordedImpressions[idx].extra.impression_id; + Assert.ok( + UUID_REGEX.test(impressionId), + "Should have an impression_id with a valid UUID." + ); + + Assert.ok( + !impressionIdsSet.has(impressionId), + "Should have a unique impression_id." + ); + + impressionIdsSet.add(impressionId); + + // If we want to use deepEqual checks, we have to add the impressionId + // to each impression since they are randomly generated at runtime. + expectedEvent.impression.impression_id = impressionId; + + Assert.deepEqual( + recordedImpressions[idx].extra, + expectedEvent.impression, + "Should have matched impression values." + ); + + // Once the impression check is sufficient, add the impression_id to + // each of the expected engagements for later deep equal checks. + if (expectedEvent.engagements) { + for (let expectedEngagment of expectedEvent.engagements) { + expectedEngagment.impression_id = impressionId; + } + } + } + + // Group engagement events into separate array fetchable by their + // impression_id. + let recordedEngagements = Glean.serp.engagement.testGetValue() ?? []; + let idToEngagements = new Map(); + let totalExpectedEngagements = 0; + + for (let recordedEngagement of recordedEngagements) { + let impressionId = recordedEngagement.extra.impression_id; + Assert.ok( + impressionId, + "Should have an engagement event with an impression_id" + ); + + let arr = idToEngagements.get(impressionId) ?? []; + arr.push(recordedEngagement.extra); + + idToEngagements.set(impressionId, arr); + } + + // Assert the engagement events. + for (let expectedEvent of expectedEvents) { + let impressionId = expectedEvent.impression.impression_id; + let expectedEngagements = expectedEvent.engagements; + if (expectedEngagements) { + let recorded = idToEngagements.get(impressionId); + Assert.deepEqual( + recorded, + expectedEngagements, + "Should have matched engagement values." + ); + totalExpectedEngagements += expectedEngagements.length; + } + } + + Assert.equal( + recordedEngagements.length, + totalExpectedEngagements, + "Should have equal number of engagements." + ); +} + +function assertAdImpressionEvents(expectedAdImpressions) { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + let impressions = Glean.serp.impression.testGetValue() ?? []; + + Assert.equal(impressions.length, 1, "Should have a SERP impression event."); + Assert.equal( + adImpressions.length, + expectedAdImpressions.length, + "Should have equal number of ad impression events." + ); + + expectedAdImpressions = expectedAdImpressions.map(expectedAdImpression => { + expectedAdImpression.impression_id = impressions[0].extra.impression_id; + return expectedAdImpression; + }); + + for (let [index, expectedAdImpression] of expectedAdImpressions.entries()) { + Assert.deepEqual( + adImpressions[index]?.extra, + expectedAdImpression, + "Should have equal values for an ad impression." + ); + } +} + +function assertAbandonmentEvent(expectedAbandonment) { + let recordedAbandonment = Glean.serp.abandonment.testGetValue() ?? []; + + Assert.equal( + recordedAbandonment[0].extra.reason, + expectedAbandonment.abandonment.reason, + "Should have the correct abandonment reason." + ); +} + +async function promiseAdImpressionReceived(num) { + if (num) { + return TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length == num; + }, `Should have received ${num} ad impressions.`); + } + return TestUtils.waitForCondition(() => { + let adImpressions = Glean.serp.adImpression.testGetValue() ?? []; + return adImpressions.length; + }, "Should have received an ad impression."); +} + +async function waitForPageWithAdImpressions() { + return new Promise(resolve => { + let listener = win => { + Services.obs.removeObserver( + listener, + "reported-page-with-ad-impressions" + ); + resolve(); + }; + Services.obs.addObserver(listener, "reported-page-with-ad-impressions"); + }); +} + +registerCleanupFunction(async () => { + await PlacesUtils.history.clear(); +}); diff --git a/browser/components/search/test/browser/mozsearch.sjs b/browser/components/search/test/browser/mozsearch.sjs new file mode 100644 index 0000000000..bde867c93e --- /dev/null +++ b/browser/components/search/test/browser/mozsearch.sjs @@ -0,0 +1,11 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function handleRequest(req, resp) { + resp.setHeader("Content-Type", "text/html", false); + if (req.hasHeader("Origin") && req.getHeader("Origin") != "null") { + resp.write("error"); + return; + } + resp.write("hello world"); +} diff --git a/browser/components/search/test/browser/opensearch.html b/browser/components/search/test/browser/opensearch.html new file mode 100644 index 0000000000..00620e3bcc --- /dev/null +++ b/browser/components/search/test/browser/opensearch.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="UTF-8"> +<link rel="search" type="application/opensearchdescription+xml" title="engine1" href="http://mochi.test:8888/browser/browser/components/search/test/browser/testEngine.xml"> +<link rel="search" type="application/opensearchdescription+xml" title="engine2" href="http://mochi.test:8888/browser/browser/components/search/test/browser/testEngine_mozsearch.xml"> +<link rel="search" type="application/opensearchdescription+xml" title="engineInvalid" href="http://mochi.test:8888/browser/browser/components/search/test/browser/testEngine_404.xml"> +</head> +<body></body> +</html> diff --git a/browser/components/search/test/browser/redirect_ad.sjs b/browser/components/search/test/browser/redirect_ad.sjs new file mode 100644 index 0000000000..36be567d3f --- /dev/null +++ b/browser/components/search/test/browser/redirect_ad.sjs @@ -0,0 +1,10 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +function handleRequest(request, response) { + response.setStatusLine("1.1", 302, "Found"); + response.setHeader("Location", "redirect_final.sjs", false); + response.setHeader("Cache-Control", "no-cache, must-revalidate", false); +} diff --git a/browser/components/search/test/browser/redirect_final.sjs b/browser/components/search/test/browser/redirect_final.sjs new file mode 100644 index 0000000000..14debde6ba --- /dev/null +++ b/browser/components/search/test/browser/redirect_final.sjs @@ -0,0 +1,9 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +function handleRequest(request, response) { + response.setStatusLine("1.1", 302, "Found"); + response.setHeader("Location", "https://example.com/hello_world", false); +} diff --git a/browser/components/search/test/browser/redirect_once.sjs b/browser/components/search/test/browser/redirect_once.sjs new file mode 100644 index 0000000000..d15f3afe6d --- /dev/null +++ b/browser/components/search/test/browser/redirect_once.sjs @@ -0,0 +1,9 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +function handleRequest(request, response) { + response.setStatusLine("1.1", 302, "Found"); + response.setHeader("Location", "redirect_final.sjs", false); +} diff --git a/browser/components/search/test/browser/redirect_thrice.sjs b/browser/components/search/test/browser/redirect_thrice.sjs new file mode 100644 index 0000000000..b7c7069162 --- /dev/null +++ b/browser/components/search/test/browser/redirect_thrice.sjs @@ -0,0 +1,9 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +function handleRequest(request, response) { + response.setStatusLine("1.1", 302, "Found"); + response.setHeader("Location", "redirect_twice.sjs", false); +} diff --git a/browser/components/search/test/browser/redirect_twice.sjs b/browser/components/search/test/browser/redirect_twice.sjs new file mode 100644 index 0000000000..099d20022e --- /dev/null +++ b/browser/components/search/test/browser/redirect_twice.sjs @@ -0,0 +1,9 @@ +/** + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +function handleRequest(request, response) { + response.setStatusLine("1.1", 302, "Found"); + response.setHeader("Location", "redirect_once.sjs", false); +} diff --git a/browser/components/search/test/browser/search-engines/basic/manifest.json b/browser/components/search/test/browser/search-engines/basic/manifest.json new file mode 100644 index 0000000000..3bdb68fea1 --- /dev/null +++ b/browser/components/search/test/browser/search-engines/basic/manifest.json @@ -0,0 +1,20 @@ +{ + "name": "basic", + "manifest_version": 2, + "version": "1.0", + "description": "basic", + "browser_specific_settings": { + "gecko": { + "id": "basic@search.mozilla.org" + } + }, + "hidden": true, + "chrome_settings_overrides": { + "search_provider": { + "name": "basic", + "keyword": "@basic", + "search_url": "https://mochi.test:8888/browser/browser/components/search/test/browser/?search={searchTerms}&foo=1", + "suggest_url": "https://mochi.test:8888/browser/browser/modules/test/browser/usageTelemetrySearchSuggestions.sjs?{searchTerms}" + } + } +} diff --git a/browser/components/search/test/browser/search-engines/private/manifest.json b/browser/components/search/test/browser/search-engines/private/manifest.json new file mode 100644 index 0000000000..69ef8b29ef --- /dev/null +++ b/browser/components/search/test/browser/search-engines/private/manifest.json @@ -0,0 +1,20 @@ +{ + "name": "private", + "manifest_version": 2, + "version": "1.0", + "description": "A test private engine", + "browser_specific_settings": { + "gecko": { + "id": "private@search.mozilla.org" + } + }, + "hidden": true, + "chrome_settings_overrides": { + "search_provider": { + "name": "private", + "keyword": "@private", + "search_url": "https://example.com", + "suggest_url": "https://example.com?search={searchTerms}" + } + } +} diff --git a/browser/components/search/test/browser/searchSuggestionEngine.sjs b/browser/components/search/test/browser/searchSuggestionEngine.sjs new file mode 100644 index 0000000000..515b56984a --- /dev/null +++ b/browser/components/search/test/browser/searchSuggestionEngine.sjs @@ -0,0 +1,55 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +Cu.importGlobalProperties(["TextEncoder"]); + +let gTimer; + +function handleRequest(req, resp) { + // Parse the query params. If the params aren't in the form "foo=bar", then + // treat the entire query string as a search string. + let params = req.queryString.split("&").reduce((memo, pair) => { + let [key, val] = pair.split("="); + if (!val) { + // This part isn't in the form "foo=bar". Treat it as the search string + // (the "query"). + val = key; + key = "query"; + } + memo[decode(key)] = decode(val); + return memo; + }, {}); + + let timeout = parseInt(params.timeout); + if (timeout) { + // Write the response after a timeout. + resp.processAsync(); + gTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + gTimer.init( + () => { + writeResponse(params, resp); + resp.finish(); + }, + timeout, + Ci.nsITimer.TYPE_ONE_SHOT + ); + return; + } + + writeResponse(params, resp); +} + +function writeResponse(params, resp) { + // Echo back the search string with "foo" and "bar" appended. + let suffixes = ["foo", "bar"]; + let data = [params.query, suffixes.map(s => params.query + s)]; + resp.setHeader("Content-Type", "application/json", false); + + let json = JSON.stringify(data); + let utf8 = String.fromCharCode(...new TextEncoder().encode(json)); + resp.write(utf8); +} + +function decode(str) { + return decodeURIComponent(str.replace(/\+/g, encodeURIComponent(" "))); +} diff --git a/browser/components/search/test/browser/searchTelemetry.html b/browser/components/search/test/browser/searchTelemetry.html new file mode 100644 index 0000000000..bd395d4a7c --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetry.html @@ -0,0 +1,11 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> +</head> +<body> + <a href="https://example.com/otherpage">Non ad link</a> + <a href="https://example1.com/ad">Matching path prefix, different server</a> + <a href="https://mochi.test:8888/otherpage">Non ad link</a> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd.html b/browser/components/search/test/browser/searchTelemetryAd.html new file mode 100644 index 0000000000..23d51d2fb5 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd.html @@ -0,0 +1,13 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> +</head> +<body> + <a id="ad1" href="https://example.com/ad">Ad link</a> + <a id="ad2" href="https://example.com/ad2">Second Ad link</a> + <!-- The iframe is used to include a sub-document load in the test, which + should not affect the recorded telemetry. --> + <iframe src="searchTelemetry.html"></iframe> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_components_carousel.html b/browser/components/search/test/browser/searchTelemetryAd_components_carousel.html new file mode 100644 index 0000000000..71049be20c --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_components_carousel.html @@ -0,0 +1,116 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section id="top"> + <!-- + Carousels can have multiple hidden links. + --> + <h5 test-label="true">ad_carousel</h5> + <div class="moz-carousel" narrow="true"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <button type="button">Next</button> + </div> + <!-- + Carousels can be used for non-ads. + --> + <h5 test-label="true">non_ad_carousel</h5> + <div class="moz-carousel" narrow="true"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/some-normal-path"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/some-normal-path"></a> + <a href="https://example.com/normal-path"> + <h3>Giraffes</h3> + </a> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/some-normal-path"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/some-normal-path"></a> + <a href="https://example.com/normal-path"> + <h3>Rhinos</h3> + </a> + </div> + </div> + </div> + </div> + </section> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_components_carousel_below_the_fold.html b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_below_the_fold.html new file mode 100644 index 0000000000..737e1e654b --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_below_the_fold.html @@ -0,0 +1,83 @@ +<!-- + This is for testing a carousel below the fold. +--> +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section id="top" style="padding-top: 1000px;"> + <h5 test-label="true">ad_carousel</h5> + <div class="moz-carousel-container"> + <div class="moz-carousel" narrow="true"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + </div> + </div> + </section> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_components_carousel_doubled.html b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_doubled.html new file mode 100644 index 0000000000..f7b7f948d9 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_doubled.html @@ -0,0 +1,182 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section id="top"> + <!-- + Carousels can have multiple hidden links. + --> + <h5 test-label="true">ad_carousel</h5> + <div class="moz-carousel" narrow="true"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + </div> + <h5 test-label="true">ad_carousel</h5> + <div class="moz-carousel" narrow="true" id="second-ad"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + </div> + <!-- + Carousels can be used for non-ads. + --> + <h5 test-label="true">non_ad_carousel</h5> + <div class="moz-carousel" narrow="true"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/some-normal-path"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/some-normal-path"></a> + <a href="https://example.com/normal-path"> + <h3>Giraffes</h3> + </a> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/some-normal-path"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/some-normal-path"></a> + <a href="https://example.com/normal-path"> + <h3>Rhinos</h3> + </a> + </div> + </div> + </div> + </div> + </section> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_components_carousel_first_element_non_visible.html b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_first_element_non_visible.html new file mode 100644 index 0000000000..b5a44b325e --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_first_element_non_visible.html @@ -0,0 +1,85 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section id="top"> + <!-- + If a user scrolls a carousel before the impression is snapped, + we shouldn't count elements that aren't fully shown in the carousel + as visible. + --> + <h5 test-label="true">ad_carousel</h5> + <div class="moz-carousel-container"> + <div class="moz-carousel" narrow="true"> + <div style="margin-left: -80px;" class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + </div> + </div> + </section> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_components_carousel_hidden.html b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_hidden.html new file mode 100644 index 0000000000..cccd714326 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_hidden.html @@ -0,0 +1,87 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" + href="./serp.css" /> +</head> +<body> + <section id="top"> + <h5 test-label="true">ad_carousel with display: none;</h5> + <div class="moz-carousel" narrow="true" style="display: none;"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + </div> + + <h5 test-label="true">ad_carousel with no width;</h5> + <div class="moz-carousel" narrow="true" style="width: 0;"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + </div> + </div> + </div> + </div> + + <h5 test-label="true">ad_carousel with no height;</h5> + <div class="moz-carousel" narrow="true" style="height: 0;"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + </div> + </div> + </div> + </div> + + <h5 test-label="true">ad_carousel that is far above the page</h5> + <div class="moz-carousel" narrow="true" style="position: absolute; top: -9999px;"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + </div> + </section> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_components_carousel_outer_container.html b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_outer_container.html new file mode 100644 index 0000000000..759bd9f0d9 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_components_carousel_outer_container.html @@ -0,0 +1,83 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section id="top"> + <!-- + Carousels can sometimes have an outer container that doesn't always show up. + --> + <h5 test-label="true">ad_carousel</h5> + <div class="moz-carousel-container"> + <div class="moz-carousel" extra="true"> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + <div class="moz-carousel-card"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/some-normal-path"> + <div class="moz-carousel-image">Image</div> + </a> + <div class="moz-carousel-card-inner"> + <div class="moz-carousel-card-inner-content"> + <a class="hidden" href="https://example.com/ad"></a> + <a href="https://example.com/normal-path"> + <h3>Name of Product</h3> + </a> + <h3>$199.99</h3> + <h3>Example.com</h3> + </div> + </div> + </div> + </div> + </div> + </section> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_components_text.html b/browser/components/search/test/browser/searchTelemetryAd_components_text.html new file mode 100644 index 0000000000..bc1219bfa9 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_components_text.html @@ -0,0 +1,112 @@ +<!-- + Text ads reuse the data-ad element in multiple components to make it + difficult to determine which component it belongs to, similar to Bing. +--> +<!DOCTYPE html> +<html lang="en"> +<head> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section id="searchresults"> + <div class="lhs"> + <div class="moz_ad"> + <h5 test-label>ad_sitelink</h5> + <a href="https://example.com/ad/1"> + <h2>Example Result</h2> + </a> + <span><a href="https://example.com/ad/2">Ad link that says there are 10 Locations nearby</a></span> + <div class="multi-col"> + <div> + <a href="https://example.com/ad/3"> + <h2>New Releases</h2> + </a> + <span>Cras ac velit sed tellus</span> + </div> + <div> + <a id="deep_ad_sitelink" href="https://example.com/ad/4"> + <h2>Men's</h2> + </a> + <span>Cras ac velit sed tellus</span> + </div> + <div> + <a href="https://example.com/ad/5"> + <h2>Women's</h2> + </a> + <span>Cras ac velit sed tellus</span> + </div> + <div> + <!-- Ensure ads encoded in data-attributes are also recorded properly --> + <a data-moz-attr="https://example.com/ad/6" href="https://example.com/normal-link"> + <h2>Sale</h2> + </a> + <span>Cras ac velit sed tellus</span> + </div> + </div> + </div> + <div class="moz_ad"> + <h5 test-label>ad_link</h5> + <a id="ad_link_redirect" href="https://example.org/browser/browser/components/search/test/browser/redirect_ad.sjs"> + <h2>Example Shop</h2> + </a> + <div class="factrow"> + <a href="https://example.com/ad/8">Home Page</a> + <a href="https://example.com/ad/9">Products</a> + <a href="https://example.com/ad/10">Sales</a> + </div> + </div> + <div class="moz_ad"> + <h5 test-label>ad_link</h5> + <a href="https://example.com/ad/11"> + <h2>Example Shop</h2> + </a> + </div> + <div> + <h5 test-label>non_ads_link</h5> + <a id="non_ads_link" href="https://example.com/browser/browser/components/search/test/browser/cacheable.html"> + Example of a cached non ad + </a><br /> + <a id="non_ads_link_redirected" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect.html"> + Example of a redirected non ad link + </a><br /> + <a id="non_ads_link_redirected_no_top_level" href="#"> + Example of a redirected non ad link that isn't initially top level loaded + </a><br /> + <a id="non_ads_link_multiple_redirects" href="https://example.com/browser/browser/components/search/test/browser/redirect_thrice.sjs"> + Example of a redirected non ad link that's redirected multiple times + </a><br /> + <a id="non_ads_link_with_special_characters_in_path" href="https://example.com/path'?hello_world&foo=bar's"> + Example of a non ad with special characters in path + </a> + </div> + </div> + <div class="rhs"> + <h5 test-label>ad_sidebar</h5> + <div class="moz_ad"> + <a href="https://example.com/ad/15"> + <div class="mock-image">Mock ad image</div> + </a> + <a href="https://example.com/ad/16"> + <h3>Buy Example Now</h3> + </a> + <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit.</p> + <a href="https://example.com/ad/17">Buy Now</a> + </div> + </div> + </section> + <iframe style="display: none;"></iframe> + <script> + window.addEventListener("message", (event) => { + if (event.origin == "https://example.org") { + window.location.href = event.data; + } + }); + document.getElementById("non_ads_link_redirected_no_top_level") + .addEventListener("click", (event) => { + event.preventDefault(); + let iframe = document.querySelector("iframe"); + iframe.src = "https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html"; + }); + </script> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_components_visibility.html b/browser/components/search/test/browser/searchTelemetryAd_components_visibility.html new file mode 100644 index 0000000000..475ada3a3c --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_components_visibility.html @@ -0,0 +1,46 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section id="top"> + <div style="display: flex; gap: 20px;"> + <div> + <h5 test-label="true">ad_link</h5> + <!-- The parent size exceeds the window height but the first ad link is above the fold. --> + <div class="moz_ad" style="padding-bottom: 2000px;"> + <a href="https://example.com/ad">Ad Link</a> + </div> + </div> + <div> + <h5 test-label="true" >ad_link</h5> + <a href="https://example.com/ad">Ad Link</a> + </div> + <!-- The ad links are below the fold but the test will scroll to it before the impression is recorded. --> + <div> + <h5 test-label="true">ad_link</h5> + <div id="second-ad" class="moz_ad" style="padding-top: 2000px;"> + <a href="https://example.com/ad">Ad Link</a> + </div> + </div> + <div> + <h5 test-label="true" style="margin-bottom: 2000px;">ad_link</h5> + <a href="https://example.com/ad">Ad Link</a> + </div> + <!-- The ad links are below the fold and shouldn't be viewed in the test. --> + <div> + <h5 test-label="true">ad_link</h5> + <div class="moz_ad" style="padding-top: 4000px;"> + <a href="https://example.com/ad">Ad Link</a> + </div> + </div> + <div> + <h5 test-label="true" style="margin-bottom: 4000px;">ad_link</h5> + <a href="https://example.com/ad">Ad Link</a> + </div> + </div> + </section> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_dataAttributes.html b/browser/components/search/test/browser/searchTelemetryAd_dataAttributes.html new file mode 100644 index 0000000000..7bc1b2745e --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_dataAttributes.html @@ -0,0 +1,10 @@ +<!-- This HTML file encodes the ad link in the data attribute --> +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> +</head> +<body> + <a data-xyz="https://example.com/ad123" href="https://example.com/otherpage">Ad link</a> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_dataAttributes_href.html b/browser/components/search/test/browser/searchTelemetryAd_dataAttributes_href.html new file mode 100644 index 0000000000..319485cfae --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_dataAttributes_href.html @@ -0,0 +1,10 @@ +<!-- This HTML file encodes the ad link in the href attribute and has irrelevant data in data attribute --> +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> +</head> +<body> + <a data-xyz="https://example.com/otherpage" href="https://example.com/ad123">Ad link</a> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_dataAttributes_none.html b/browser/components/search/test/browser/searchTelemetryAd_dataAttributes_none.html new file mode 100644 index 0000000000..a119cf71be --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_dataAttributes_none.html @@ -0,0 +1,10 @@ +<!-- This HTML file has non-ad data in both the href and data attribute --> +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> +</head> +<body> + <a data-xyz="https://example.com/otherpage" href="https://example.com/otherpage">Non-Ad Link</a> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect.html b/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect.html new file mode 100644 index 0000000000..d987356d7e --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="UTF-8"> + <meta http-equiv="X-UA-Compatible" content="IE=edge"> + <meta name="viewport" content="width=device-width, initial-scale=1.0"> + <title>Page will do a redirect</title> + <meta content="0;url=https://example.com/hello_world" http-equiv="refresh"> +</head> +<body> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect.html^headers^ b/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect.html^headers^ new file mode 100644 index 0000000000..94cde2a288 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect.html^headers^ @@ -0,0 +1 @@ +Cache-Control: no-cache, must-revalidate diff --git a/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html b/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html new file mode 100644 index 0000000000..1c5c31cb38 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html @@ -0,0 +1,17 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="UTF-8"> + <meta http-equiv="X-UA-Compatible" content="IE=edge"> + <meta name="viewport" content="width=device-width, initial-scale=1.0"> + <title>Page will do a redirect without doing it in a top load</title> + <!-- <meta content="0;url=https://example.com/hello_world" http-equiv="refresh"> --> + <script> + let parentWindow = window.parent; + let url = "https://example.com/hello_world"; + parentWindow.postMessage(url, "*"); + </script> + </head> + <body> + </body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html^headers^ b/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html^headers^ new file mode 100644 index 0000000000..419697b050 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_nonAdsLink_redirect_nonTopLoaded.html^headers^ @@ -0,0 +1,4 @@ +Cache-Control: no-cache, must-revalidate +Pragma: no-cache +Expires: Fri, 01 Jan 1990 00:00:00 GMT +Content-Type: text/html; charset=ISO-8859-1 diff --git a/browser/components/search/test/browser/searchTelemetryAd_searchbox.html b/browser/components/search/test/browser/searchTelemetryAd_searchbox.html new file mode 100644 index 0000000000..ca38c13218 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_searchbox.html @@ -0,0 +1,38 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section> + <form role="search"> + <input type="text" value="test" /> + <div> + <ul> + <li id="suggest">test</li> + </div> + </form> + </section> + <section id="searchresults"> + <div class="lhs"> + <div> + <h5 test-label>non_ads_link</h5> + <a id="non_ads_link" href="https://example.com/hello_world"> + <h2>Example of a non ad</h2> + </a> + </div> + </div> + </section> +</body> +<script type="text/javascript"> + document.querySelector("form").addEventListener("submit", event => { + event.preventDefault(); + window.location.href = "https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox.html?s=test&abc=ff"; + }) + document.getElementById("suggest").addEventListener("click", event => { + event.preventDefault(); + window.location.href = "https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox.html?s=test&abc=ff"; + }) +</script> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_searchbox.html^headers^ b/browser/components/search/test/browser/searchTelemetryAd_searchbox.html^headers^ new file mode 100644 index 0000000000..62847d0585 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_searchbox.html^headers^ @@ -0,0 +1 @@ +Cache-Control: private, max-age=0 diff --git a/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html b/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html new file mode 100644 index 0000000000..e381135561 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html @@ -0,0 +1,39 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="utf-8"> + <link rel="stylesheet" type="text/css" href="./serp.css" /> +</head> +<body> + <section> + <form role="search"> + <input type="text" value="test" /> + </form> + </section> + <nav> + <a id="images" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html?s=test&page=images">Images</a> + <a id="shopping" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html?s=test&page=shopping">Shopping</a> + <a id="extra" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox.html?s=test">Extra Page</a> + </nav> + <section class="refined-search-buttons"> + <a id="refined-search-button" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html?s=test's">Test's</a> + <a id="refined-search-button-with-partner-code" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html?s=test2&abc=ff">Test 2</a> + </section> + <section id="searchresults"> + <div class="lhs"> + <div> + <h2>Related Searches</h2> + <a id="related-new-tab" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html?s=test+one+two+three" target="_blank">test one two three</a> + <a id="related-redirect" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content_redirect.html" target="_blank">test one two three</a> + <a id="related-in-page" href="https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html?s=test+one+two+three">test one two three</a> + </div> + </div> + </section> +</body> +<script type="text/javascript"> + document.querySelector("form").addEventListener("submit", event => { + event.preventDefault(); + window.location.href = "https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html?s=test&abc=ff"; + }); +</script> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html^headers^ b/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html^headers^ new file mode 100644 index 0000000000..94cde2a288 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html^headers^ @@ -0,0 +1 @@ +Cache-Control: no-cache, must-revalidate diff --git a/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content_redirect.html b/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content_redirect.html new file mode 100644 index 0000000000..901dd54a55 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content_redirect.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="UTF-8"> + <meta http-equiv="X-UA-Compatible" content="IE=edge"> + <meta name="viewport" content="width=device-width, initial-scale=1.0"> + <title>Page will do a redirect</title> + <meta content="0;url=https://example.org/browser/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content.html?s=test+one+two+three" http-equiv="refresh"> +</head> +<body> +</body> +</html> diff --git a/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content_redirect.html^headers^ b/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content_redirect.html^headers^ new file mode 100644 index 0000000000..94cde2a288 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_searchbox_with_content_redirect.html^headers^ @@ -0,0 +1 @@ +Cache-Control: no-cache, must-revalidate diff --git a/browser/components/search/test/browser/searchTelemetryAd_shopping.html b/browser/components/search/test/browser/searchTelemetryAd_shopping.html new file mode 100644 index 0000000000..faa6c057a4 --- /dev/null +++ b/browser/components/search/test/browser/searchTelemetryAd_shopping.html @@ -0,0 +1,15 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="UTF-8"> + <meta http-equiv="X-UA-Compatible" content="IE=edge"> + <meta name="viewport" content="width=device-width, initial-scale=1.0"> + <title>Document</title> +</head> +<body> + <nav> + <a href="https://example.org/search?q=something&page=images&foo=bar">Images</a> + <a id="shopping" href="https://example.org/search?q=something&page=shopping&foo=bar">Shopping</a> + </nav> +</body> +</html> diff --git a/browser/components/search/test/browser/serp.css b/browser/components/search/test/browser/serp.css new file mode 100644 index 0000000000..5b3865da44 --- /dev/null +++ b/browser/components/search/test/browser/serp.css @@ -0,0 +1,164 @@ +:root { + --margin-left: 80px; + --subtle: whitesmoke; + --carousel-card-width: 180px; +} + +body { + margin: 0; + padding: 0 0 80px 0; +} + +a:link { + text-decoration: none; +} + +a:visited { + color: blue; +} + +h5[test-label] { + margin-top: 30px; + margin-bottom: 4px; +} + +nav { + border-bottom: 1px solid #ececec; + padding-bottom: 20px; + margin-bottom: 20px; +} + +#searchform { + padding-top: 20px; + margin-bottom: 20px; +} + +nav>div, +#searchform, +.moz-carousel, +.factrow { + display: flex; + align-items: center; +} + +nav>div, +#searchform { + gap: 40px; +} + +nav>div, +#searchform, +#searchresults, +#top { + margin-left: var(--margin-left); +} + +#searchbox { + font-size: 14px; + padding: 10px 20px; + width: 300px; + border-radius: 20px; + border: 2px solid var(--subtle); + height: 20px; +} + +.card-container { + white-space: nowrap; + overflow-x: auto; + overflow-y: hidden; +} + +.card-container>.card { + height: 160px; + border-radius: 3px; + border: 1px solid var(--subtle); + display: inline-block; + box-sizing: border-box; + padding: 10px; +} + +.card-container>.card:not(:last-child) { + margin-right: 10px; +} + +.card-container>.card>a { + display: block; + margin-bottom: 2px; +} + +#searchresults { + width: 900px; + display: grid; + grid-template-columns: 600px 300px; +} + +.moz-carousel, +.factrow { + gap: 10px; +} + +.moz-carousel { + overflow: hidden; +} + +.moz-carousel[narrow], +.moz-carousel-container { + width: calc(var(--carousel-card-width) * 3 + (3 * 10px)); + overflow-x: auto; +} + +.moz-carousel[extra] { + width: calc(var(--carousel-card-width) * 4 + (3 * 10px)); +} + +.moz-carousel>.moz-inner { + border: 1px solid var(--subtle); + border-radius: 10px; + padding: 10px; +} + +.moz-carousel>.moz-carousel-card { + flex: 1 0 var(--carousel-card-width); + border: 1px solid var(--subtle); + font-size: 14px; +} + +.moz-carousel-card .moz-carousel-image { + width: 100%; + height: 120px; + background-color: var(--subtle); + display: flex; + align-items: center; + justify-content: center; +} + +.moz-carousel-card-inner-content { + padding: 10px 20px 20px 20px; +} + +.multi-col { + display: grid; + padding: 10px 20px 20px 20px; + grid-template-columns: 1fr 1fr; + gap: 10px; +} + +.mock-image { + height: 100px; + background-color: var(--subtle); + display: flex; + align-items: center; + justify-content: center; +} + +/* Some SERPs hide anchors using CSS */ +.hidden { + display: none; +} + +/* Typography */ +h2 { + line-height: 100%; + margin-bottom: 10px; + margin-top: 10px; +} diff --git a/browser/components/search/test/browser/slow_loading_page_with_ads.html b/browser/components/search/test/browser/slow_loading_page_with_ads.html new file mode 100644 index 0000000000..35ac9878ec --- /dev/null +++ b/browser/components/search/test/browser/slow_loading_page_with_ads.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> +</head> +<body> + <a id="ad1" href="https://example.com/ad">Ad link</a> + <a id="ad2" href="https://example.com/ad2">Second Ad link</a> + <!-- The iframe is used to include a sub-document load in the test, which + should not affect the recorded telemetry. --> + <iframe src="searchTelemetry.html"></iframe> + <img src="https://example.org/browser/browser/components/search/test/browser/slow_loading_page_with_ads.sjs"> +</body> +</html> diff --git a/browser/components/search/test/browser/slow_loading_page_with_ads.sjs b/browser/components/search/test/browser/slow_loading_page_with_ads.sjs new file mode 100644 index 0000000000..7a6382d1cb --- /dev/null +++ b/browser/components/search/test/browser/slow_loading_page_with_ads.sjs @@ -0,0 +1,21 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function handleRequest(request, response) { + const DELAY_MS = 2000; + response.processAsync(); + + response.setHeader("Cache-Control", "no-cache", false); + response.setHeader("Content-Type", "image/png", false); + response.write("Start loading image"); + + let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + timer.init( + () => { + response.write("Finish loading image"); + response.finish(); + }, + DELAY_MS, + Ci.nsITimer.TYPE_ONE_SHOT + ); +} diff --git a/browser/components/search/test/browser/slow_loading_page_with_ads_on_load_event.html b/browser/components/search/test/browser/slow_loading_page_with_ads_on_load_event.html new file mode 100644 index 0000000000..307b24d4fe --- /dev/null +++ b/browser/components/search/test/browser/slow_loading_page_with_ads_on_load_event.html @@ -0,0 +1,30 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> +</head> +<body id='body'> +</body> + <img src="https://example.org/browser/browser/components/search/test/browser/slow_loading_page_with_ads.sjs"> + <script> + setTimeout(() => { + let body = document.getElementById('body'); + let ad1 = document.createElement('a'); + ad1.setAttribute('id', 'ad1'); + ad1.setAttribute('href', 'https://example.com/ad'); + ad1.innerHTML = 'Ad link' + + let ad2 = document.createElement('a'); + ad2.setAttribute('id', 'ad2'); + ad2.setAttribute('href', 'https://example.com/ad2'); + ad2.innerHTML = 'Second Ad link' + + let frame = document.createElement('iframe'); + frame.setAttribute('src', 'searchTelemetry.html'); + + body.appendChild(ad1); + body.appendChild(ad2); + body.appendChild(frame); + }, 2000); + </script> +</html> diff --git a/browser/components/search/test/browser/telemetrySearchSuggestions.sjs b/browser/components/search/test/browser/telemetrySearchSuggestions.sjs new file mode 100644 index 0000000000..1978b4f665 --- /dev/null +++ b/browser/components/search/test/browser/telemetrySearchSuggestions.sjs @@ -0,0 +1,9 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function handleRequest(req, resp) { + let suffixes = ["foo", "bar"]; + let data = [req.queryString, suffixes.map(s => req.queryString + s)]; + resp.setHeader("Content-Type", "application/json", false); + resp.write(JSON.stringify(data)); +} diff --git a/browser/components/search/test/browser/telemetrySearchSuggestions.xml b/browser/components/search/test/browser/telemetrySearchSuggestions.xml new file mode 100644 index 0000000000..057fc70bf5 --- /dev/null +++ b/browser/components/search/test/browser/telemetrySearchSuggestions.xml @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="UTF-8"?> +<SearchPlugin xmlns="http://www.mozilla.org/2006/browser/search/"> +<ShortName>browser_UsageTelemetry usageTelemetrySearchSuggestions.xml</ShortName> +<Url type="application/x-suggestions+json" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/telemetrySearchSuggestions.sjs?{searchTerms}"/> +<Url type="text/html" method="GET" template="http://example.com" rel="searchform"/> +</SearchPlugin> diff --git a/browser/components/search/test/browser/test.html b/browser/components/search/test/browser/test.html new file mode 100644 index 0000000000..a39bece4ff --- /dev/null +++ b/browser/components/search/test/browser/test.html @@ -0,0 +1,8 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8" /> + <title>Bug 426329</title> +</head> +<body></body> +</html> diff --git a/browser/components/search/test/browser/testEngine.xml b/browser/components/search/test/browser/testEngine.xml new file mode 100644 index 0000000000..9c25993232 --- /dev/null +++ b/browser/components/search/test/browser/testEngine.xml @@ -0,0 +1,12 @@ +<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" + xmlns:moz="http://www.mozilla.org/2006/browser/search/"> + <ShortName>Foo</ShortName> + <Description>Foo Search</Description> + <InputEncoding>utf-8</InputEncoding> + <Image width="16" height="16">data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGklEQVQoz2NgGB6AnZ1dUlJSXl4eSDIyMhLW4Ovr%2B%2Fr168uXL69Zs4YoG%2BLi4i5dusTExMTGxsbNzd3f37937976%2BnpmZmagbHR09J49e5YvX66kpATVEBYW9ubNm2nTphkbG7e2tp44cQLIuHfvXm5urpaWFlDKysqqu7v73LlzECMYIiIiHj58mJCQoKKicvXq1bS0NKBgW1vbjh074uPjgeqAXE1NzSdPnvDz84M0AEUvXLgAsW379u1z5swBen3jxo2zZ892cHB4%2BvQp0KlAfwI1cHJyghQFBwfv2rULokFXV%2FfixYu7d%2B8GGqGgoMDKyrpu3br9%2B%2FcDuXl5eVA%2FAEWBfoWHAdAYoNuAYQ0XAeoUERFhGDYAAPoUaT2dfWJuAAAAAElFTkSuQmCC</Image> + <Url type="text/html" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/?search"> + <Param name="test" value="{searchTerms}"/> + </Url> + <moz:SearchForm>http://mochi.test:8888/browser/browser/components/search/test/browser/</moz:SearchForm> + <moz:Alias>fooalias</moz:Alias> +</OpenSearchDescription> diff --git a/browser/components/search/test/browser/testEngine_diacritics.xml b/browser/components/search/test/browser/testEngine_diacritics.xml new file mode 100644 index 0000000000..340893348d --- /dev/null +++ b/browser/components/search/test/browser/testEngine_diacritics.xml @@ -0,0 +1,12 @@ +<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" + xmlns:moz="http://www.mozilla.org/2006/browser/search/"> + <ShortName>Foo ♡</ShortName> + <Description>Engine whose ShortName contains non-BMP Unicode characters</Description> + <InputEncoding>utf-8</InputEncoding> + <Image width="16" height="16">data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGklEQVQoz2NgGB6AnZ1dUlJSXl4eSDIyMhLW4Ovr%2B%2Fr168uXL69Zs4YoG%2BLi4i5dusTExMTGxsbNzd3f37937976%2BnpmZmagbHR09J49e5YvX66kpATVEBYW9ubNm2nTphkbG7e2tp44cQLIuHfvXm5urpaWFlDKysqqu7v73LlzECMYIiIiHj58mJCQoKKicvXq1bS0NKBgW1vbjh074uPjgeqAXE1NzSdPnvDz84M0AEUvXLgAsW379u1z5swBen3jxo2zZ892cHB4%2BvQp0KlAfwI1cHJyghQFBwfv2rULokFXV%2FfixYu7d%2B8GGqGgoMDKyrpu3br9%2B%2FcDuXl5eVA%2FAEWBfoWHAdAYoNuAYQ0XAeoUERFhGDYAAPoUaT2dfWJuAAAAAElFTkSuQmCC</Image> + <Url type="text/html" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/?search"> + <Param name="test" value="{searchTerms}"/> + </Url> + <moz:SearchForm>http://mochi.test:8888/browser/browser/components/search/test/browser/</moz:SearchForm> + <moz:Alias>diacriticalias</moz:Alias> +</OpenSearchDescription> diff --git a/browser/components/search/test/browser/testEngine_dupe.xml b/browser/components/search/test/browser/testEngine_dupe.xml new file mode 100644 index 0000000000..86c4cfadaf --- /dev/null +++ b/browser/components/search/test/browser/testEngine_dupe.xml @@ -0,0 +1,12 @@ +<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" + xmlns:moz="http://www.mozilla.org/2006/browser/search/"> + <ShortName>FooDupe</ShortName> + <Description>Second Engine Search</Description> + <InputEncoding>utf-8</InputEncoding> + <Image width="16" height="16">data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGklEQVQoz2NgGB6AnZ1dUlJSXl4eSDIyMhLW4Ovr%2B%2Fr168uXL69Zs4YoG%2BLi4i5dusTExMTGxsbNzd3f37937976%2BnpmZmagbHR09J49e5YvX66kpATVEBYW9ubNm2nTphkbG7e2tp44cQLIuHfvXm5urpaWFlDKysqqu7v73LlzECMYIiIiHj58mJCQoKKicvXq1bS0NKBgW1vbjh074uPjgeqAXE1NzSdPnvDz84M0AEUvXLgAsW379u1z5swBen3jxo2zZ892cHB4%2BvQp0KlAfwI1cHJyghQFBwfv2rULokFXV%2FfixYu7d%2B8GGqGgoMDKyrpu3br9%2B%2FcDuXl5eVA%2FAEWBfoWHAdAYoNuAYQ0XAeoUERFhGDYAAPoUaT2dfWJuAAAAAElFTkSuQmCC</Image> + <Url type="text/html" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/?search"> + <Param name="test" value="{searchTerms}"/> + </Url> + <moz:SearchForm>http://mochi.test:8888/browser/browser/components/search/test/browser/</moz:SearchForm> + <moz:Alias>secondalias</moz:Alias> +</OpenSearchDescription> diff --git a/browser/components/search/test/browser/testEngine_mozsearch.xml b/browser/components/search/test/browser/testEngine_mozsearch.xml new file mode 100644 index 0000000000..2f285feb4c --- /dev/null +++ b/browser/components/search/test/browser/testEngine_mozsearch.xml @@ -0,0 +1,14 @@ +<SearchPlugin xmlns="http://www.mozilla.org/2006/browser/search/"> + <ShortName>Foo</ShortName> + <Description>Foo Search</Description> + <InputEncoding>utf-8</InputEncoding> + <Image width="16" height="16">data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGklEQVQoz2NgGB6AnZ1dUlJSXl4eSDIyMhLW4Ovr%2B%2Fr168uXL69Zs4YoG%2BLi4i5dusTExMTGxsbNzd3f37937976%2BnpmZmagbHR09J49e5YvX66kpATVEBYW9ubNm2nTphkbG7e2tp44cQLIuHfvXm5urpaWFlDKysqqu7v73LlzECMYIiIiHj58mJCQoKKicvXq1bS0NKBgW1vbjh074uPjgeqAXE1NzSdPnvDz84M0AEUvXLgAsW379u1z5swBen3jxo2zZ892cHB4%2BvQp0KlAfwI1cHJyghQFBwfv2rULokFXV%2FfixYu7d%2B8GGqGgoMDKyrpu3br9%2B%2FcDuXl5eVA%2FAEWBfoWHAdAYoNuAYQ0XAeoUERFhGDYAAPoUaT2dfWJuAAAAAElFTkSuQmCC</Image> + <Url type="application/x-suggestions+json" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/?suggestions&locale={moz:locale}&test={searchTerms}"/> + <Url type="text/html" method="GET" template="http://mochi.test:8888/browser/browser/components/search/test/browser/"> + <Param name="test" value="{searchTerms}"/> + <Param name="ie" value="utf-8"/> + <MozParam name="channel" condition="purpose" purpose="keyword" value="keywordsearch"/> + <MozParam name="channel" condition="purpose" purpose="contextmenu" value="contextsearch"/> + </Url> + <SearchForm>http://mochi.test:8888/browser/browser/components/search/test/browser/</SearchForm> +</SearchPlugin> diff --git a/browser/components/search/test/browser/test_search.html b/browser/components/search/test/browser/test_search.html new file mode 100644 index 0000000000..010d1fdc82 --- /dev/null +++ b/browser/components/search/test/browser/test_search.html @@ -0,0 +1 @@ +test%20search diff --git a/browser/components/search/test/browser/tooManyEnginesOffered.html b/browser/components/search/test/browser/tooManyEnginesOffered.html new file mode 100644 index 0000000000..64e48d05e9 --- /dev/null +++ b/browser/components/search/test/browser/tooManyEnginesOffered.html @@ -0,0 +1,13 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="UTF-8"> +<link rel="search" type="application/opensearchdescription+xml" title="engine1" href="http://mochi.test:8888/browser/browser/components/search/test/browser/engine1.xml"> +<link rel="search" type="application/opensearchdescription+xml" title="engine2" href="http://mochi.test:8888/browser/browser/components/search/test/browser/engine2.xml"> +<link rel="search" type="application/opensearchdescription+xml" title="engine3" href="http://mochi.test:8888/browser/browser/components/search/test/browser/engine3.xml"> +<link rel="search" type="application/opensearchdescription+xml" title="engine4" href="http://mochi.test:8888/browser/browser/components/search/test/browser/engine4.xml"> +<link rel="search" type="application/opensearchdescription+xml" title="engine5" href="http://mochi.test:8888/browser/browser/components/search/test/browser/engine5.xml"> +<link rel="search" type="application/opensearchdescription+xml" title="engine6" href="http://mochi.test:8888/browser/browser/components/search/test/browser/engine6.xml"> +</head> +<body></body> +</html> diff --git a/browser/components/search/test/browser/trendingSuggestionEngine.sjs b/browser/components/search/test/browser/trendingSuggestionEngine.sjs new file mode 100644 index 0000000000..c568cc223b --- /dev/null +++ b/browser/components/search/test/browser/trendingSuggestionEngine.sjs @@ -0,0 +1,51 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +Cu.importGlobalProperties(["TextEncoder"]); + +let gTimer; + +function handleRequest(req, resp) { + // Parse the query params. If the params aren't in the form "foo=bar", then + // treat the entire query string as a search string. + let params = req.queryString.split("&").reduce((memo, pair) => { + let [key, val] = pair.split("="); + if (!val) { + // This part isn't in the form "foo=bar". Treat it as the search string + // (the "query"). + val = key; + key = "query"; + } + memo[decode(key)] = decode(val); + return memo; + }, {}); + + writeResponse(params, resp); +} + +function writeResponse(params, resp) { + // Echoes back 15 results, query0, query1, query2 etc. + let suffixes = [...Array(15).keys()]; + let query = params.query || ""; + let data = [query, suffixes.map(s => query + s)]; + if (params?.richsuggestions) { + data.push([]); + data.push({ + "google:suggestdetail": suffixes.map(s => ({ + a: "Extended title", + dc: "#FFFFFF", + i: "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==", + t: "Title", + })), + }); + } + resp.setHeader("Content-Type", "application/json", false); + + let json = JSON.stringify(data); + let utf8 = String.fromCharCode(...new TextEncoder().encode(json)); + resp.write(utf8); +} + +function decode(str) { + return decodeURIComponent(str.replace(/\+/g, encodeURIComponent(" "))); +} diff --git a/browser/components/search/test/marionette/manifest.ini b/browser/components/search/test/marionette/manifest.ini new file mode 100644 index 0000000000..3ca0ae0eb5 --- /dev/null +++ b/browser/components/search/test/marionette/manifest.ini @@ -0,0 +1,4 @@ +[DEFAULT] +run-if = buildapp == 'browser' + +[test_engines_on_restart.py] diff --git a/browser/components/search/test/marionette/test_engines_on_restart.py b/browser/components/search/test/marionette/test_engines_on_restart.py new file mode 100644 index 0000000000..d7a0634e75 --- /dev/null +++ b/browser/components/search/test/marionette/test_engines_on_restart.py @@ -0,0 +1,40 @@ +# -*- coding: utf-8 -*- +# 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/. + +import textwrap + +from marionette_harness.marionette_test import MarionetteTestCase + + +class TestEnginesOnRestart(MarionetteTestCase): + def setUp(self): + super(TestEnginesOnRestart, self).setUp() + self.marionette.enforce_gecko_prefs( + { + "browser.search.log": True, + } + ) + + def get_default_search_engine(self): + """Retrieve the identifier of the default search engine.""" + + script = """\ + let [resolve] = arguments; + let searchService = Components.classes[ + "@mozilla.org/browser/search-service;1"] + .getService(Components.interfaces.nsISearchService); + return searchService.init().then(function () { + resolve(searchService.defaultEngine.identifier); + }); + """ + + with self.marionette.using_context(self.marionette.CONTEXT_CHROME): + return self.marionette.execute_async_script(textwrap.dedent(script)) + + def test_engines(self): + self.assertTrue(self.get_default_search_engine().startswith("google")) + self.marionette.set_pref("intl.locale.requested", "kk_KZ") + self.marionette.restart(clean=False, in_app=True) + self.assertTrue(self.get_default_search_engine().startswith("google")) diff --git a/browser/components/search/test/unit/test_search_telemetry_config_validation.js b/browser/components/search/test/unit/test_search_telemetry_config_validation.js new file mode 100644 index 0000000000..1c243cfc82 --- /dev/null +++ b/browser/components/search/test/unit/test_search_telemetry_config_validation.js @@ -0,0 +1,82 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +ChromeUtils.defineESModuleGetters(this, { + AppConstants: "resource://gre/modules/AppConstants.sys.mjs", + RemoteSettings: "resource://services-settings/remote-settings.sys.mjs", + TELEMETRY_SETTINGS_KEY: "resource:///modules/SearchSERPTelemetry.sys.mjs", + JsonSchema: "resource://gre/modules/JsonSchema.sys.mjs", +}); + +/** + * Checks to see if a value is an object or not. + * + * @param {*} value + * The value to check. + * @returns {boolean} + */ +function isObject(value) { + return value != null && typeof value == "object" && !Array.isArray(value); +} + +/** + * This function modifies the schema to prevent allowing additional properties + * on objects. This is used to enforce that the schema contains everything that + * we deliver via the search configuration. + * + * These checks are not enabled in-product, as we want to allow older versions + * to keep working if we add new properties for whatever reason. + * + * @param {object} section + * The section to check to see if an additionalProperties flag should be added. + */ +function disallowAdditionalProperties(section) { + // It is generally acceptable for new properties to be added to the + // configuration as older builds will ignore them. + // + // As a result, we only check for new properties on nightly builds, and this + // avoids us having to uplift schema changes. This also helps preserve the + // schemas as documentation of "what was supported in this version". + if (!AppConstants.NIGHTLY_BUILD) { + info("Skipping additional properties validation."); + return; + } + + if (section.type == "object") { + section.additionalProperties = false; + } + for (let value of Object.values(section)) { + if (isObject(value)) { + disallowAdditionalProperties(value); + } + } +} + +add_task(async function test_search_config_validates_to_schema() { + let schema = await IOUtils.readJSON( + PathUtils.join(do_get_cwd().path, "search-telemetry-schema.json") + ); + disallowAdditionalProperties(schema); + + let data = await RemoteSettings(TELEMETRY_SETTINGS_KEY).get(); + + let validator = new JsonSchema.Validator(schema); + + for (let entry of data) { + // Records in Remote Settings contain additional properties independent of + // the schema. Hence, we don't want to validate their presence. + delete entry.schema; + delete entry.id; + delete entry.last_modified; + delete entry.filter_expression; + + let result = validator.validate(entry); + let message = `Should validate ${entry.telemetryId}`; + if (!result.valid) { + message += `:\n${JSON.stringify(result.errors, null, 2)}`; + } + Assert.ok(result.valid, message); + } +}); diff --git a/browser/components/search/test/unit/test_urlTelemetry.js b/browser/components/search/test/unit/test_urlTelemetry.js new file mode 100644 index 0000000000..bd46f39e5b --- /dev/null +++ b/browser/components/search/test/unit/test_urlTelemetry.js @@ -0,0 +1,310 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const { XPCOMUtils } = ChromeUtils.importESModule( + "resource://gre/modules/XPCOMUtils.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + BrowserSearchTelemetry: "resource:///modules/BrowserSearchTelemetry.sys.mjs", + SearchSERPTelemetry: "resource:///modules/SearchSERPTelemetry.sys.mjs", + SearchUtils: "resource://gre/modules/SearchUtils.sys.mjs", + TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs", + sinon: "resource://testing-common/Sinon.sys.mjs", +}); + +XPCOMUtils.defineLazyModuleGetters(this, { + NetUtil: "resource://gre/modules/NetUtil.jsm", +}); + +const TESTS = [ + { + title: "Google search access point", + trackingUrl: + "https://www.google.com/search?q=test&ie=utf-8&oe=utf-8&client=firefox-b-1-ab", + expectedSearchCountEntry: "google:tagged:firefox-b-1-ab", + expectedAdKey: "google:tagged", + adUrls: [ + "https://www.googleadservices.com/aclk=foobar", + "https://www.googleadservices.com/pagead/aclk=foobar", + "https://www.google.com/aclk=foobar", + "https://www.google.com/pagead/aclk=foobar", + ], + nonAdUrls: [ + "https://www.googleadservices.com/?aclk=foobar", + "https://www.googleadservices.com/bar", + "https://www.google.com/image", + ], + }, + { + title: "Google search access point follow-on", + trackingUrl: + "https://www.google.com/search?client=firefox-b-1-ab&ei=EI_VALUE&q=test2&oq=test2&gs_l=GS_L_VALUE", + expectedSearchCountEntry: "google:tagged-follow-on:firefox-b-1-ab", + }, + { + title: "Google organic", + trackingUrl: + "https://www.google.com/search?client=firefox-b-d-invalid&source=hp&ei=EI_VALUE&q=test&oq=test&gs_l=GS_L_VALUE", + expectedSearchCountEntry: "google:organic:other", + expectedAdKey: "google:organic", + adUrls: ["https://www.googleadservices.com/aclk=foobar"], + nonAdUrls: ["https://www.googleadservices.com/?aclk=foobar"], + }, + { + title: "Google organic no code", + trackingUrl: + "https://www.google.com/search?source=hp&ei=EI_VALUE&q=test&oq=test&gs_l=GS_L_VALUE", + expectedSearchCountEntry: "google:organic:none", + expectedAdKey: "google:organic", + adUrls: ["https://www.googleadservices.com/aclk=foobar"], + nonAdUrls: ["https://www.googleadservices.com/?aclk=foobar"], + }, + { + title: "Google organic UK", + trackingUrl: + "https://www.google.co.uk/search?source=hp&ei=EI_VALUE&q=test&oq=test&gs_l=GS_L_VALUE", + expectedSearchCountEntry: "google:organic:none", + }, + { + title: "Bing search access point", + trackingUrl: "https://www.bing.com/search?q=test&pc=MOZI&form=MOZLBR", + expectedSearchCountEntry: "bing:tagged:MOZI", + expectedAdKey: "bing:tagged", + adUrls: [ + "https://www.bing.com/aclick?ld=foo", + "https://www.bing.com/aclk?ld=foo", + ], + nonAdUrls: [ + "https://www.bing.com/fd/ls/ls.gif?IG=foo", + "https://www.bing.com/fd/ls/l?IG=bar", + "https://www.bing.com/aclook?", + "https://www.bing.com/fd/ls/GLinkPingPost.aspx?IG=baz&url=%2Fvideos%2Fsearch%3Fq%3Dfoo", + "https://www.bing.com/fd/ls/GLinkPingPost.aspx?IG=bar&url=https%3A%2F%2Fwww.bing.com%2Faclick", + "https://www.bing.com/fd/ls/GLinkPingPost.aspx?IG=bar&url=https%3A%2F%2Fwww.bing.com%2Faclk", + ], + }, + { + setUp() { + Services.cookies.removeAll(); + Services.cookies.add( + "www.bing.com", + "/", + "SRCHS", + "PC=MOZI", + false, + false, + false, + Date.now() + 1000 * 60 * 60, + {}, + Ci.nsICookie.SAMESITE_NONE, + Ci.nsICookie.SCHEME_HTTPS + ); + }, + tearDown() { + Services.cookies.removeAll(); + }, + title: "Bing search access point follow-on", + trackingUrl: + "https://www.bing.com/search?q=test&qs=n&form=QBRE&sp=-1&pq=&sc=0-0&sk=&cvid=CVID_VALUE", + expectedSearchCountEntry: "bing:tagged-follow-on:MOZI", + }, + { + title: "Bing organic", + trackingUrl: "https://www.bing.com/search?q=test&pc=MOZIfoo&form=MOZLBR", + expectedSearchCountEntry: "bing:organic:other", + expectedAdKey: "bing:organic", + adUrls: ["https://www.bing.com/aclick?ld=foo"], + nonAdUrls: ["https://www.bing.com/fd/ls/ls.gif?IG=foo"], + }, + { + title: "Bing organic no code", + trackingUrl: + "https://www.bing.com/search?q=test&qs=n&form=QBLH&sp=-1&pq=&sc=0-0&sk=&cvid=CVID_VALUE", + expectedSearchCountEntry: "bing:organic:none", + expectedAdKey: "bing:organic", + adUrls: ["https://www.bing.com/aclick?ld=foo"], + nonAdUrls: ["https://www.bing.com/fd/ls/ls.gif?IG=foo"], + }, + { + title: "DuckDuckGo search access point", + trackingUrl: "https://duckduckgo.com/?q=test&t=ffab", + expectedSearchCountEntry: "duckduckgo:tagged:ffab", + expectedAdKey: "duckduckgo:tagged", + adUrls: [ + "https://duckduckgo.com/y.js?ad_provider=foo", + "https://duckduckgo.com/y.js?f=bar&ad_provider=foo", + "https://www.amazon.co.uk/foo?tag=duckduckgo-ffab-uk-32-xk", + ], + nonAdUrls: [ + "https://duckduckgo.com/?q=foo&t=ffab&ia=images&iax=images", + "https://duckduckgo.com/y.js?ifu=foo", + "https://improving.duckduckgo.com/t/bar", + ], + }, + { + title: "DuckDuckGo organic", + trackingUrl: "https://duckduckgo.com/?q=test&t=other&ia=news", + expectedSearchCountEntry: "duckduckgo:organic:other", + expectedAdKey: "duckduckgo:organic", + adUrls: ["https://duckduckgo.com/y.js?ad_provider=foo"], + nonAdUrls: ["https://duckduckgo.com/?q=foo&t=ffab&ia=images&iax=images"], + }, + { + title: "DuckDuckGo expected organic code", + trackingUrl: "https://duckduckgo.com/?q=test&t=h_&ia=news", + expectedSearchCountEntry: "duckduckgo:organic:none", + expectedAdKey: "duckduckgo:organic", + adUrls: ["https://duckduckgo.com/y.js?ad_provider=foo"], + nonAdUrls: ["https://duckduckgo.com/?q=foo&t=ffab&ia=images&iax=images"], + }, + { + title: "DuckDuckGo expected organic code 2", + trackingUrl: "https://duckduckgo.com/?q=test&t=hz&ia=news", + expectedSearchCountEntry: "duckduckgo:organic:none", + expectedAdKey: "duckduckgo:organic", + adUrls: ["https://duckduckgo.com/y.js?ad_provider=foo"], + nonAdUrls: ["https://duckduckgo.com/?q=foo&t=ffab&ia=images&iax=images"], + }, + { + title: "DuckDuckGo organic no code", + trackingUrl: "https://duckduckgo.com/?q=test&ia=news", + expectedSearchCountEntry: "duckduckgo:organic:none", + expectedAdKey: "duckduckgo:organic", + adUrls: ["https://duckduckgo.com/y.js?ad_provider=foo"], + nonAdUrls: ["https://duckduckgo.com/?q=foo&t=ffab&ia=images&iax=images"], + }, + { + title: "Baidu search access point", + trackingUrl: "https://www.baidu.com/baidu?wd=test&tn=monline_7_dg&ie=utf-8", + expectedSearchCountEntry: "baidu:tagged:monline_7_dg", + expectedAdKey: "baidu:tagged", + adUrls: ["https://www.baidu.com/baidu.php?url=encoded"], + nonAdUrls: ["https://www.baidu.com/link?url=encoded"], + }, + { + title: "Baidu search access point follow-on", + trackingUrl: + "https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&tn=monline_7_dg&wd=test2&oq=test&rsv_pq=RSV_PQ_VALUE&rsv_t=RSV_T_VALUE&rqlang=cn&rsv_enter=1&rsv_sug3=2&rsv_sug2=0&inputT=227&rsv_sug4=397", + expectedSearchCountEntry: "baidu:tagged-follow-on:monline_7_dg", + }, + { + title: "Baidu organic", + trackingUrl: + "https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&ch=&tn=baidu&bar=&wd=test&rn=&oq&rsv_pq=RSV_PQ_VALUE&rsv_t=RSV_T_VALUE&rqlang=cn", + expectedSearchCountEntry: "baidu:organic:other", + }, + { + title: "Baidu organic no code", + trackingUrl: + "https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&ch=&bar=&wd=test&rn=&oq&rsv_pq=RSV_PQ_VALUE&rsv_t=RSV_T_VALUE&rqlang=cn", + expectedSearchCountEntry: "baidu:organic:none", + }, + { + title: "Ecosia search access point", + trackingUrl: "https://www.ecosia.org/search?tt=mzl&q=foo", + expectedSearchCountEntry: "ecosia:tagged:mzl", + expectedAdKey: "ecosia:tagged", + adUrls: ["https://www.bing.com/aclick?ld=foo"], + nonAdUrls: [], + }, + { + title: "Ecosia organic", + trackingUrl: "https://www.ecosia.org/search?method=index&q=foo", + expectedSearchCountEntry: "ecosia:organic:none", + expectedAdKey: "ecosia:organic", + adUrls: ["https://www.bing.com/aclick?ld=foo"], + nonAdUrls: [], + }, +]; + +/** + * This function is primarily for testing the Ad URL regexps that are triggered + * when a URL is clicked on. These regexps are also used for the `with_ads` + * probe. However, we test the ad_clicks route as that is easier to hit. + * + * @param {string} serpUrl + * The url to simulate where the page the click came from. + * @param {string} adUrl + * The ad url to simulate being clicked. + * @param {string} [expectedAdKey] + * The expected key to be logged for the scalar. Omit if no scalar should be + * logged. + */ +async function testAdUrlClicked(serpUrl, adUrl, expectedAdKey) { + info(`Testing Ad URL: ${adUrl}`); + let channel = NetUtil.newChannel({ + uri: NetUtil.newURI(adUrl), + triggeringPrincipal: Services.scriptSecurityManager.createContentPrincipal( + NetUtil.newURI(serpUrl), + {} + ), + loadUsingSystemPrincipal: true, + }); + SearchSERPTelemetry._contentHandler.observeActivity( + channel, + Ci.nsIHttpActivityObserver.ACTIVITY_TYPE_HTTP_TRANSACTION, + Ci.nsIHttpActivityObserver.ACTIVITY_SUBTYPE_TRANSACTION_CLOSE + ); + // Since the content handler takes a moment to allow the channel information + // to settle down, wait the same amount of time here. + await new Promise(resolve => Services.tm.dispatchToMainThread(resolve)); + + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true); + if (!expectedAdKey) { + Assert.ok( + !("browser.search.adclicks.unknown" in scalars), + "Should not have recorded an ad click" + ); + } else { + TelemetryTestUtils.assertKeyedScalar( + scalars, + "browser.search.adclicks.unknown", + expectedAdKey, + 1 + ); + } +} + +do_get_profile(); + +add_task(async function setup() { + Services.prefs.setBoolPref(SearchUtils.BROWSER_SEARCH_PREF + "log", true); + await SearchSERPTelemetry.init(); + sinon.stub(BrowserSearchTelemetry, "shouldRecordSearchCount").returns(true); +}); + +add_task(async function test_parsing_search_urls() { + for (const test of TESTS) { + info(`Running ${test.title}`); + if (test.setUp) { + test.setUp(); + } + SearchSERPTelemetry.updateTrackingStatus( + { + getTabBrowser: () => {}, + }, + test.trackingUrl + ); + let scalars = TelemetryTestUtils.getProcessScalars("parent", true, true); + TelemetryTestUtils.assertKeyedScalar( + scalars, + "browser.search.content.unknown", + test.expectedSearchCountEntry, + 1 + ); + + if ("adUrls" in test) { + for (const adUrl of test.adUrls) { + await testAdUrlClicked(test.trackingUrl, adUrl, test.expectedAdKey); + } + for (const nonAdUrls of test.nonAdUrls) { + await testAdUrlClicked(test.trackingUrl, nonAdUrls); + } + } + + if (test.tearDown) { + test.tearDown(); + } + } +}); diff --git a/browser/components/search/test/unit/test_urlTelemetry_generic.js b/browser/components/search/test/unit/test_urlTelemetry_generic.js new file mode 100644 index 0000000000..610dd56e3a --- /dev/null +++ b/browser/components/search/test/unit/test_urlTelemetry_generic.js @@ -0,0 +1,323 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const { XPCOMUtils } = ChromeUtils.importESModule( + "resource://gre/modules/XPCOMUtils.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + BrowserSearchTelemetry: "resource:///modules/BrowserSearchTelemetry.sys.mjs", + SearchSERPTelemetry: "resource:///modules/SearchSERPTelemetry.sys.mjs", + SearchSERPTelemetryUtils: "resource:///modules/SearchSERPTelemetry.sys.mjs", + SearchUtils: "resource://gre/modules/SearchUtils.sys.mjs", + TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs", + sinon: "resource://testing-common/Sinon.sys.mjs", +}); + +XPCOMUtils.defineLazyModuleGetters(this, { + NetUtil: "resource://gre/modules/NetUtil.jsm", +}); + +const TEST_PROVIDER_INFO = [ + { + telemetryId: "example", + searchPageRegexp: /^https:\/\/www\.example\.com\/search/, + queryParamName: "q", + codeParamName: "abc", + taggedCodes: ["ff", "tb"], + expectedOrganicCodes: ["baz"], + organicCodes: ["foo"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/www\.example\.com\/ad2/], + shoppingTab: { + regexp: "&site=shop", + }, + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, + { + telemetryId: "example2", + searchPageRegexp: /^https:\/\/www\.example2\.com\/search/, + queryParamName: "q", + codeParamName: "abc", + taggedCodes: ["ff", "tb"], + expectedOrganicCodes: ["baz"], + organicCodes: ["foo"], + followOnParamNames: ["a"], + extraAdServersRegexps: [/^https:\/\/www\.example\.com\/ad2/], + components: [ + { + type: SearchSERPTelemetryUtils.COMPONENTS.AD_LINK, + default: true, + }, + ], + }, +]; + +const TESTS = [ + { + title: "Tagged search", + trackingUrl: "https://www.example.com/search?q=test&abc=ff", + expectedSearchCountEntry: "example:tagged:ff", + expectedAdKey: "example:tagged", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + is_shopping_page: "false", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, + { + title: "Tagged search with shopping", + trackingUrl: "https://www.example.com/search?q=test&abc=ff&site=shop", + expectedSearchCountEntry: "example:tagged:ff", + expectedAdKey: "example:tagged", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example", + tagged: "true", + partner_code: "ff", + is_shopping_page: "true", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, + { + title: "Tagged follow-on", + trackingUrl: "https://www.example.com/search?q=test&abc=tb&a=next", + expectedSearchCountEntry: "example:tagged-follow-on:tb", + expectedAdKey: "example:tagged-follow-on", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example", + tagged: "true", + partner_code: "tb", + is_shopping_page: "false", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, + { + title: "Organic search matched code", + trackingUrl: "https://www.example.com/search?q=test&abc=foo", + expectedSearchCountEntry: "example:organic:foo", + expectedAdKey: "example:organic", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example", + tagged: "false", + partner_code: "foo", + is_shopping_page: "false", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, + { + title: "Organic search non-matched code", + trackingUrl: "https://www.example.com/search?q=test&abc=ff123", + expectedSearchCountEntry: "example:organic:other", + expectedAdKey: "example:organic", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example", + tagged: "false", + partner_code: "other", + is_shopping_page: "false", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, + { + title: "Organic search non-matched code 2", + trackingUrl: "https://www.example.com/search?q=test&abc=foo123", + expectedSearchCountEntry: "example:organic:other", + expectedAdKey: "example:organic", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example", + tagged: "false", + partner_code: "other", + is_shopping_page: "false", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, + { + title: "Organic search expected organic matched code", + trackingUrl: "https://www.example.com/search?q=test&abc=baz", + expectedSearchCountEntry: "example:organic:none", + expectedAdKey: "example:organic", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example", + tagged: "false", + partner_code: "", + is_shopping_page: "false", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, + { + title: "Organic search no codes", + trackingUrl: "https://www.example.com/search?q=test", + expectedSearchCountEntry: "example:organic:none", + expectedAdKey: "example:organic", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example", + tagged: "false", + partner_code: "", + is_shopping_page: "false", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, + { + title: "Different engines using the same adUrl", + trackingUrl: "https://www.example2.com/search?q=test", + expectedSearchCountEntry: "example2:organic:none", + expectedAdKey: "example2:organic", + adUrls: ["https://www.example.com/ad2"], + nonAdUrls: ["https://www.example.com/ad3"], + impression: { + provider: "example2", + tagged: "false", + partner_code: "", + is_shopping_page: "false", + shopping_tab_displayed: "false", + source: "unknown", + }, + }, +]; + +/** + * This function is primarily for testing the Ad URL regexps that are triggered + * when a URL is clicked on. These regexps are also used for the `withads` + * probe. However, we test the adclicks route as that is easier to hit. + * + * @param {string} serpUrl + * The url to simulate where the page the click came from. + * @param {string} adUrl + * The ad url to simulate being clicked. + * @param {string} [expectedAdKey] + * The expected key to be logged for the scalar. Omit if no scalar should be + * logged. + */ +async function testAdUrlClicked(serpUrl, adUrl, expectedAdKey) { + info(`Testing Ad URL: ${adUrl}`); + let channel = NetUtil.newChannel({ + uri: NetUtil.newURI(adUrl), + triggeringPrincipal: Services.scriptSecurityManager.createContentPrincipal( + NetUtil.newURI(serpUrl), + {} + ), + loadUsingSystemPrincipal: true, + }); + SearchSERPTelemetry._contentHandler.observeActivity( + channel, + Ci.nsIHttpActivityObserver.ACTIVITY_TYPE_HTTP_TRANSACTION, + Ci.nsIHttpActivityObserver.ACTIVITY_SUBTYPE_TRANSACTION_CLOSE + ); + // Since the content handler takes a moment to allow the channel information + // to settle down, wait the same amount of time here. + await new Promise(resolve => Services.tm.dispatchToMainThread(resolve)); + + const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true); + if (!expectedAdKey) { + Assert.ok( + !("browser.search.adclicks.unknown" in scalars), + "Should not have recorded an ad click" + ); + } else { + TelemetryTestUtils.assertKeyedScalar( + scalars, + "browser.search.adclicks.unknown", + expectedAdKey, + 1 + ); + } +} + +do_get_profile(); + +add_task(async function setup() { + Services.prefs.setBoolPref(SearchUtils.BROWSER_SEARCH_PREF + "log", true); + Services.prefs.setBoolPref( + SearchUtils.BROWSER_SEARCH_PREF + "serpEventTelemetry.enabled", + true + ); + Services.fog.initializeFOG(); + await SearchSERPTelemetry.init(); + SearchSERPTelemetry.overrideSearchTelemetryForTests(TEST_PROVIDER_INFO); + sinon.stub(BrowserSearchTelemetry, "shouldRecordSearchCount").returns(true); +}); + +add_task(async function test_parsing_search_urls() { + for (const test of TESTS) { + info(`Running ${test.title}`); + if (test.setUp) { + test.setUp(); + } + let browser = { + getTabBrowser: () => {}, + }; + SearchSERPTelemetry.updateTrackingStatus(browser, test.trackingUrl); + SearchSERPTelemetry.reportPageImpression( + { + url: test.trackingUrl, + shoppingTabDisplayed: false, + }, + browser + ); + let scalars = TelemetryTestUtils.getProcessScalars("parent", true, true); + TelemetryTestUtils.assertKeyedScalar( + scalars, + "browser.search.content.unknown", + test.expectedSearchCountEntry, + 1 + ); + + if ("adUrls" in test) { + for (const adUrl of test.adUrls) { + await testAdUrlClicked(test.trackingUrl, adUrl, test.expectedAdKey); + } + for (const nonAdUrls of test.nonAdUrls) { + await testAdUrlClicked(test.trackingUrl, nonAdUrls); + } + } + + let recordedEvents = Glean.serp.impression.testGetValue(); + + Assert.equal( + recordedEvents.length, + 1, + "should only see one impression event" + ); + + // To allow deep equality. + test.impression.impression_id = recordedEvents[0].extra.impression_id; + Assert.deepEqual(recordedEvents[0].extra, test.impression); + + if (test.tearDown) { + test.tearDown(); + } + + // We need to clear Glean events so they don't accumulate for each iteration. + Services.fog.testResetFOG(); + } +}); diff --git a/browser/components/search/test/unit/xpcshell.ini b/browser/components/search/test/unit/xpcshell.ini new file mode 100644 index 0000000000..7feeb6d38c --- /dev/null +++ b/browser/components/search/test/unit/xpcshell.ini @@ -0,0 +1,9 @@ +[DEFAULT] +skip-if = toolkit == 'android' # bug 1730213 +firefox-appdir = browser + +[test_search_telemetry_config_validation.js] +support-files = + ../../schema/search-telemetry-schema.json +[test_urlTelemetry.js] +[test_urlTelemetry_generic.js] |
