diff options
Diffstat (limited to 'toolkit/components/satchel')
68 files changed, 9923 insertions, 0 deletions
diff --git a/toolkit/components/satchel/.eslintrc.js b/toolkit/components/satchel/.eslintrc.js new file mode 100644 index 0000000000..c0e875d5cb --- /dev/null +++ b/toolkit/components/satchel/.eslintrc.js @@ -0,0 +1,41 @@ +/* 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 = { + rules: { + "mozilla/balanced-listeners": "error", + "mozilla/var-only-at-top-level": "error", + + "block-scoped-var": "error", + complexity: [ + "error", + { + max: 23, + }, + ], + "max-nested-callbacks": ["error", 4], + "no-console": ["error", { allow: ["error"] }], + "no-fallthrough": "error", + "no-multi-str": "error", + "no-proto": "error", + "no-unused-expressions": "error", + "no-unused-vars": [ + "error", + { + args: "none", + vars: "all", + }, + ], + "no-use-before-define": [ + "error", + { + functions: false, + }, + ], + radix: "error", + yoda: "error", + }, +}; diff --git a/toolkit/components/satchel/FillHelpers.sys.mjs b/toolkit/components/satchel/FillHelpers.sys.mjs new file mode 100644 index 0000000000..e2aebede6c --- /dev/null +++ b/toolkit/components/satchel/FillHelpers.sys.mjs @@ -0,0 +1,22 @@ +/* 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/. */ + +// This item shows icon, title & subtitle. +// Once selected it will send fillMessageName with fillMessageData +// to the parent actor and response will be used to fill into the field. +export class GenericAutocompleteItem { + comment = ""; + style = "generic"; + value = ""; + + constructor(icon, title, subtitle, fillMessageName, fillMessageData) { + this.comment = JSON.stringify({ + icon, + title, + subtitle, + fillMessageName, + fillMessageData, + }); + } +} diff --git a/toolkit/components/satchel/FormAutoComplete.sys.mjs b/toolkit/components/satchel/FormAutoComplete.sys.mjs new file mode 100644 index 0000000000..de4a093573 --- /dev/null +++ b/toolkit/components/satchel/FormAutoComplete.sys.mjs @@ -0,0 +1,648 @@ +/* vim: set ts=4 sts=4 sw=4 et tw=80: */ +/* 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/. */ + +function isAutocompleteDisabled(aField) { + if (!aField) { + return false; + } + + if (aField.autocomplete !== "") { + return aField.autocomplete === "off"; + } + + return aField.form?.autocomplete === "off"; +} + +/** + * An abstraction to talk with the FormHistory database over + * the message layer. FormHistoryClient will take care of + * figuring out the most appropriate message manager to use, + * and what things to send. + * + * It is assumed that nsFormAutoComplete will only ever use + * one instance at a time, and will not attempt to perform more + * than one search request with the same instance at a time. + * However, nsFormAutoComplete might call remove() any number of + * times with the same instance of the client. + * + * @param {object} clientInfo + * Info required to build the FormHistoryClient + * @param {Node} clientInfo.formField + * A DOM node that we're requesting form history for. + * @param {string} clientInfo.inputName + * The name of the input to do the FormHistory look-up with. + * If this is searchbar-history, then formField needs to be null, + * otherwise constructing will throw. + */ +export class FormHistoryClient { + constructor({ formField, inputName }) { + if (formField) { + if (inputName == this.SEARCHBAR_ID) { + throw new Error( + "FormHistoryClient constructed with both a formField and an inputName. " + + "This is not supported, and only empty results will be returned." + ); + } + const window = formField.ownerGlobal; + this.windowGlobal = window.windowGlobalChild; + } + + this.inputName = inputName; + this.id = FormHistoryClient.nextRequestID++; + } + + static nextRequestID = 1; + SEARCHBAR_ID = "searchbar-history"; + cancelled = false; + inputName = ""; + + getActor() { + return this.windowGlobal?.getActor("FormHistory"); + } + + /** + * Query FormHistory for some results. + * + * @param {string} searchString + * The string to search FormHistory for. See + * FormHistory.getAutoCompleteResults. + * @param {object} params + * An Object with search properties. See + * FormHistory.getAutoCompleteResults. + * @param {Function} callback + * A callback function that will take a single + * argument (the found entries). + */ + requestAutoCompleteResults(searchString, params, callback) { + this.cancelled = false; + + // Use the actor if possible, otherwise for the searchbar, + // use the more roundabout per-process message manager which has + // no sendQuery method. + const actor = this.getActor(); + if (actor) { + actor + .sendQuery("FormHistory:AutoCompleteSearchAsync", { + searchString, + params, + }) + .then( + results => this.handleAutoCompleteResults(results, callback), + () => this.cancel() + ); + } else { + this.callback = callback; + Services.cpmm.addMessageListener( + "FormHistory:AutoCompleteSearchResults", + this + ); + Services.cpmm.sendAsyncMessage("FormHistory:AutoCompleteSearchAsync", { + id: this.id, + searchString, + params, + }); + } + } + + handleAutoCompleteResults(results, callback) { + if (this.cancelled) { + return; + } + + if (!callback) { + console.error("FormHistoryClient received response with no callback"); + return; + } + + callback(results); + this.cancel(); + } + + /** + * Cancel an in-flight results request. This ensures that the + * callback that requestAutoCompleteResults was passed is never + * called from this FormHistoryClient. + */ + cancel() { + if (this.callback) { + Services.cpmm.removeMessageListener( + "FormHistory:AutoCompleteSearchResults", + this + ); + this.callback = null; + } + this.cancelled = true; + } + + /** + * Remove an item from FormHistory. + * + * @param {string} value + * + * The value to remove for this particular + * field. + * + * @param {string} guid + * + * The guid for the item being removed. + */ + remove(value, guid) { + const actor = this.getActor() || Services.cpmm; + actor.sendAsyncMessage("FormHistory:RemoveEntry", { + inputName: this.inputName, + value, + guid, + }); + } + + receiveMessage(msg) { + const { id, results } = msg.data; + if (id == this.id) { + this.handleAutoCompleteResults(results, this.callback); + } + } +} + +// nsIAutoCompleteResult implementation +export class FormAutoCompleteResult { + constructor(client, entries, fieldName, searchString) { + this.client = client; + this.entries = entries; + this.fieldName = fieldName; + this.searchString = searchString; + } + + QueryInterface = ChromeUtils.generateQI([ + "nsIAutoCompleteResult", + "nsISupportsWeakReference", + ]); + + // private + client = null; + entries = null; + fieldName = null; + + _checkIndexBounds(index) { + if (index < 0 || index >= this.entries.length) { + throw Components.Exception( + "Index out of range.", + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + } + + // Allow autoCompleteSearch to get at the JS object so it can + // modify some readonly properties for internal use. + get wrappedJSObject() { + return this; + } + + // Interfaces from idl... + searchString = ""; + errorDescription = ""; + + get defaultIndex() { + if (!this.entries.length) { + return -1; + } + return 0; + } + + get searchResult() { + if (!this.entries.length) { + return Ci.nsIAutoCompleteResult.RESULT_NOMATCH; + } + return Ci.nsIAutoCompleteResult.RESULT_SUCCESS; + } + + get matchCount() { + return this.entries.length; + } + + getValueAt(index) { + this._checkIndexBounds(index); + return this.entries[index].text; + } + + getLabelAt(index) { + return this.getValueAt(index); + } + + getCommentAt(index) { + this._checkIndexBounds(index); + return ""; + } + + getStyleAt(index) { + this._checkIndexBounds(index); + return ""; + } + + getImageAt(index) { + this._checkIndexBounds(index); + return ""; + } + + getFinalCompleteValueAt(index) { + return this.getValueAt(index); + } + + isRemovableAt(index) { + this._checkIndexBounds(index); + return true; + } + + removeValueAt(index) { + this._checkIndexBounds(index); + + const [removedEntry] = this.entries.splice(index, 1); + this.client.remove(removedEntry.text, removedEntry.guid); + } +} + +export class FormAutoComplete { + constructor() { + // Preferences. Add observer so we get notified of changes. + this._prefBranch = Services.prefs.getBranch("browser.formfill."); + this._prefBranch.addObserver("", this.observer, true); + this.observer._self = this; + + this._debug = this._prefBranch.getBoolPref("debug"); + this._enabled = this._prefBranch.getBoolPref("enable"); + } + + classID = Components.ID("{c11c21b2-71c9-4f87-a0f8-5e13f50495fd}"); + QueryInterface = ChromeUtils.generateQI([ + "nsIFormAutoComplete", + "nsISupportsWeakReference", + ]); + + // Only one query via FormHistoryClient is performed at a time, and the + // most recent FormHistoryClient which will be stored in _pendingClient + // while the query is being performed. It will be cleared when the query + // finishes, is cancelled, or an error occurs. If a new query occurs while + // one is already pending, the existing one is cancelled. + #pendingClient = null; + + observer = { + _self: null, + + QueryInterface: ChromeUtils.generateQI([ + "nsIObserver", + "nsISupportsWeakReference", + ]), + + observe(_subject, topic, data) { + const self = this._self; + + if (topic == "nsPref:changed") { + const prefName = data; + self.log(`got change to ${prefName} preference`); + + switch (prefName) { + case "debug": + self._debug = self._prefBranch.getBoolPref(prefName); + break; + case "enable": + self._enabled = self._prefBranch.getBoolPref(prefName); + break; + } + } + }, + }; + + // AutoCompleteE10S needs to be able to call autoCompleteSearchAsync without + // going through IDL in order to pass a mock DOM object field. + get wrappedJSObject() { + return this; + } + + /* + * log + * + * Internal function for logging debug messages to the Error Console + * window + */ + log(message) { + if (!this._debug) { + return; + } + dump("FormAutoComplete: " + message + "\n"); + Services.console.logStringMessage("FormAutoComplete: " + message); + } + + /* + * autoCompleteSearchAsync + * + * aInputName -- |name| or |id| attribute value from the form input being + * autocompleted + * aUntrimmedSearchString -- current value of the input + * aField -- HTMLInputElement being autocompleted (may be null if from chrome) + * aPreviousResult -- previous search result, if any. + * aDatalistResult -- results from list=datalist for aField. + * aListener -- nsIFormAutoCompleteObserver that listens for the nsIAutoCompleteResult + * that may be returned asynchronously. + * options -- an optional nsIPropertyBag2 containing additional search + * parameters. + */ + autoCompleteSearchAsync( + aInputName, + aUntrimmedSearchString, + aField, + aPreviousResult, + aDatalistResult, + aListener, + aOptions + ) { + // Guard against void DOM strings filtering into this code. + if (typeof aInputName === "object") { + aInputName = ""; + } + if (typeof aUntrimmedSearchString === "object") { + aUntrimmedSearchString = ""; + } + const params = {}; + if (aOptions) { + try { + aOptions.QueryInterface(Ci.nsIPropertyBag2); + for (const { name, value } of aOptions.enumerator) { + params[name] = value; + } + } catch (ex) { + console.error("Invalid options object: " + ex); + } + } + + const client = new FormHistoryClient({ + formField: aField, + inputName: aInputName, + }); + + function maybeNotifyListener(result) { + aListener?.onSearchCompletion(result); + } + + // If we have datalist results, they become our "empty" result. + const emptyResult = + aDatalistResult || + new FormAutoCompleteResult( + client, + [], + aInputName, + aUntrimmedSearchString + ); + + if (!this._enabled) { + maybeNotifyListener(emptyResult); + return; + } + + // Don't allow form inputs (aField != null) to get results from + // search bar history. + if (aInputName == "searchbar-history" && aField) { + this.log(`autoCompleteSearch for input name "${aInputName}" is denied`); + maybeNotifyListener(emptyResult); + return; + } + + if (isAutocompleteDisabled(aField)) { + this.log("autoCompleteSearch not allowed due to autcomplete=off"); + maybeNotifyListener(emptyResult); + return; + } + + this.log( + "AutoCompleteSearch invoked. Search is: " + aUntrimmedSearchString + ); + const searchString = aUntrimmedSearchString.trim().toLowerCase(); + + // reuse previous results if: + // a) length greater than one character (others searches are special cases) AND + // b) the the new results will be a subset of the previous results + const prevSearchString = aPreviousResult?.searchString.trim(); + if ( + prevSearchString?.length > 1 && + searchString.includes(prevSearchString.toLowerCase()) + ) { + this.log("Using previous autocomplete result"); + const result = aPreviousResult; + const wrappedResult = result.wrappedJSObject; + wrappedResult.searchString = aUntrimmedSearchString; + + // Leaky abstraction alert: it would be great to be able to split + // this code between nsInputListAutoComplete and here but because of + // the way we abuse the formfill autocomplete API in e10s, we have + // to deal with the <datalist> results here as well (and down below + // in mergeResults). + // If there were datalist results result is a FormAutoCompleteResult + // as defined in nsFormAutoCompleteResult.jsm with the entire list + // of results in wrappedResult._items and only the results from + // form history in wrappedResult.entries. + // First, grab the entire list of old results. + const allResults = wrappedResult._items; + const datalistItems = []; + if (allResults) { + // We have datalist results, extract them from the values array. + // Both allResults and values arrays are in the form of: + // |--wR.entries--| + // <history entries><datalist entries> + for (const oldItem of allResults.slice(wrappedResult.entries.length)) { + if (oldItem.label.toLowerCase().includes(searchString)) { + datalistItems.push({ + value: oldItem.value, + label: oldItem.label, + comment: "", + removable: oldItem.removable, + }); + } + } + } + + const searchTokens = searchString.split(/\s+/); + // We have a list of results for a shorter search string, so just + // filter them further based on the new search string and add to a new array. + let filteredEntries = []; + for (const entry of wrappedResult.entries) { + // Remove results that do not contain the token + // XXX bug 394604 -- .toLowerCase can be wrong for some intl chars + if (searchTokens.some(tok => !entry.textLowerCase.includes(tok))) { + continue; + } + this._calculateScore(entry, searchString, searchTokens); + this.log( + `Reusing autocomplete entry '${entry.text}' (${entry.frecency} / ${entry.totalScore})` + ); + filteredEntries.push(entry); + } + filteredEntries.sort((a, b) => b.totalScore - a.totalScore); + wrappedResult.entries = filteredEntries; + + // If we had datalistResults, re-merge them back into the filtered + // entries. + if (datalistItems.length) { + filteredEntries = filteredEntries.map(elt => ({ + value: elt.text, + // History entries don't have labels (their labels would be read + // from their values). + label: "", + comment: "", + removable: true, + })); + + datalistItems[0].comment = "separator"; + + wrappedResult._items = filteredEntries.concat(datalistItems); + } + + maybeNotifyListener(result); + } else { + this.log("Creating new autocomplete search result."); + + // Start with an empty list. + let result = aDatalistResult + ? new FormAutoCompleteResult( + client, + [], + aInputName, + aUntrimmedSearchString + ) + : emptyResult; + + const processEntry = aEntries => { + if (aField?.maxLength > -1) { + result.entries = aEntries.filter( + el => el.text.length <= aField.maxLength + ); + } else { + result.entries = aEntries; + } + + if (aDatalistResult?.matchCount > 0) { + result = this.mergeResults(result, aDatalistResult); + } + + maybeNotifyListener(result); + }; + + this.getAutoCompleteValues( + client, + aInputName, + searchString, + params, + processEntry + ); + } + } + + mergeResults(historyResult, datalistResult) { + const items = datalistResult.wrappedJSObject._items; + + // historyResult will be null if form autocomplete is disabled. We + // still want the list values to display. + const entries = historyResult.wrappedJSObject.entries; + const historyResults = entries.map(entry => ({ + value: entry.text, + label: entry.text, + comment: "", + removable: true, + })); + + const isInArray = (value, arr, key) => + arr.find(item => item[key].toUpperCase() === value.toUpperCase()); + + // Remove items from history list that are already present in data list. + // We do this rather than the opposite ( i.e. remove items from data list) + // to reflect the order that is specified in the data list. + const dedupedHistoryResults = historyResults.filter( + historyRes => !isInArray(historyRes.value, items, "value") + ); + + // Now put the history results above the datalist suggestions. + // Note that we don't need to worry about deduplication of elements inside + // the datalist suggestions because the datalist is user-provided. + const finalItems = dedupedHistoryResults.concat(items); + + historyResult.wrappedJSObject.entries = + historyResult.wrappedJSObject.entries.filter( + entry => !isInArray(entry.text, items, "value") + ); + + // This is ugly: there are two FormAutoCompleteResult classes in the + // tree, one in a module and one in this file. Datalist results need to + // use the one defined in the module but the rest of this file assumes + // that we use the one defined here. To get around that, we explicitly + // import the module here, out of the way of the other uses of + // FormAutoCompleteResult. + const { FormAutoCompleteResult } = ChromeUtils.importESModule( + "resource://gre/modules/nsFormAutoCompleteResult.sys.mjs" + ); + return new FormAutoCompleteResult( + datalistResult.searchString, + Ci.nsIAutoCompleteResult.RESULT_SUCCESS, + 0, + "", + finalItems, + historyResult + ); + } + + stopAutoCompleteSearch() { + if (this.#pendingClient) { + this.#pendingClient.cancel(); + this.#pendingClient = null; + } + } + + /* + * Get the values for an autocomplete list given a search string. + * + * client - a FormHistoryClient instance to perform the search with + * fieldName - fieldname field within form history (the form input name) + * searchString - string to search for + * params - object containing additional properties to query autocomplete. + * callback - called when the values are available. Passed an array of objects, + * containing properties for each result. The callback is only called + * when successful. + */ + getAutoCompleteValues(client, fieldName, searchString, params, callback) { + params = Object.assign({ fieldname: fieldName }, params); + + this.stopAutoCompleteSearch(); + client.requestAutoCompleteResults(searchString, params, entries => { + this.#pendingClient = null; + callback(entries); + }); + this.#pendingClient = client; + } + + /* + * _calculateScore + * + * entry -- an nsIAutoCompleteResult entry + * aSearchString -- current value of the input (lowercase) + * searchTokens -- array of tokens of the search string + * + * Returns: an int + */ + _calculateScore(entry, aSearchString, searchTokens) { + let boundaryCalc = 0; + // for each word, calculate word boundary weights + for (const token of searchTokens) { + if (entry.textLowerCase.startsWith(token)) { + boundaryCalc++; + } + if (entry.textLowerCase.includes(" " + token)) { + boundaryCalc++; + } + } + boundaryCalc = boundaryCalc * this._boundaryWeight; + // now add more weight if we have a traditional prefix match and + // multiply boundary bonuses by boundary weight + if (entry.textLowerCase.startsWith(aSearchString)) { + boundaryCalc += this._prefixWeight; + } + entry.totalScore = Math.round(entry.frecency * Math.max(1, boundaryCalc)); + } +} diff --git a/toolkit/components/satchel/FormHistory.sys.mjs b/toolkit/components/satchel/FormHistory.sys.mjs new file mode 100644 index 0000000000..3928ea19b7 --- /dev/null +++ b/toolkit/components/satchel/FormHistory.sys.mjs @@ -0,0 +1,1303 @@ +/* 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/. */ + +/** + * FormHistory + * + * Used to store values that have been entered into forms which may later + * be used to automatically fill in the values when the form is visited again. + * + * async search(terms, queryData) + * Look up values that have been previously stored. + * terms - array of terms to return data for + * queryData - object that contains the query terms + * The query object contains properties for each search criteria to match, where the value + * of the property specifies the value that term must have. For example, + * { term1: value1, term2: value2 } + * Resolves to an array containing the found results. Each element in + * the array is an object containing a property for each search term + * specified by 'terms'. + * Rejects in case of errors. + * async count(queryData) + * Find the number of stored entries that match the given criteria. + * queryData - array of objects that indicate the query. See the search method for details. + * Resolves to the number of found entries. + * Rejects in case of errors. + * async update(changes) + * Write data to form history storage. + * changes - an array of changes to be made. If only one change is to be made, it + * may be passed as an object rather than a one-element array. + * Each change object is of the form: + * { op: operation, term1: value1, term2: value2, ... } + * Valid operations are: + * add - add a new entry + * update - update an existing entry + * remove - remove an entry + * bump - update the last accessed time on an entry + * The terms specified allow matching of one or more specific entries. If no terms + * are specified then all entries are matched. This means that { op: "remove" } is + * used to remove all entries and clear the form history. + * Resolves once the operation is complete. + * Rejects in case of errors. + * async getAutoCompeteResults(searchString, params, callback) + * Retrieve an array of form history values suitable for display in an autocomplete list. + * searchString - the string to search for, typically the entered value of a textbox + * params - zero or more filter arguments: + * fieldname - form field name + * agedWeight + * bucketSize + * expiryDate + * maxTimeGroundings + * timeGroupingSize + * prefixWeight + * boundaryWeight + * source + * callback - callback that is invoked for each result, the second argument + * is a function that can be used to cancel the operation. + * Each result is an object with four properties: + * text, textLowerCase, frecency, totalScore + * Resolves with an array of results, once the operation is complete. + * Rejects in case of errors. + * + * schemaVersion + * This property holds the version of the database schema + * + * Terms: + * guid - entry identifier. For 'add', a guid will be generated. + * fieldname - form field name + * value - form value + * timesUsed - the number of times the entry has been accessed + * firstUsed - the time the the entry was first created + * lastUsed - the time the entry was last accessed + * firstUsedStart - search for entries created after or at this time + * firstUsedEnd - search for entries created before or at this time + * lastUsedStart - search for entries last accessed after or at this time + * lastUsedEnd - search for entries last accessed before or at this time + * newGuid - a special case valid only for 'update' and allows the guid for + * an existing record to be updated. The 'guid' term is the only + * other term which can be used (ie, you can not also specify a + * fieldname, value etc) and indicates the guid of the existing + * record that should be updated. + */ + +export let FormHistory; + +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + Sqlite: "resource://gre/modules/Sqlite.sys.mjs", +}); + +const DB_SCHEMA_VERSION = 5; +const DAY_IN_MS = 86400000; // 1 day in milliseconds +const MAX_SEARCH_TOKENS = 10; +const DB_FILENAME = "formhistory.sqlite"; + +var supportsDeletedTable = AppConstants.platform == "android"; + +var Prefs = { + _initialized: false, + + get(name) { + this.ensureInitialized(); + return this[`_${name}`]; + }, + + ensureInitialized() { + if (this._initialized) { + return; + } + + this._initialized = true; + + this._prefBranch = Services.prefs.getBranch("browser.formfill."); + this._prefBranch.addObserver("", this, true); + + this._agedWeight = this._prefBranch.getIntPref("agedWeight"); + this._boundaryWeight = this._prefBranch.getIntPref("boundaryWeight"); + this._bucketSize = this._prefBranch.getIntPref("bucketSize"); + this._debug = this._prefBranch.getBoolPref("debug"); + this._enabled = this._prefBranch.getBoolPref("enable"); + this._expireDays = this._prefBranch.getIntPref("expire_days"); + this._maxTimeGroupings = this._prefBranch.getIntPref("maxTimeGroupings"); + this._prefixWeight = this._prefBranch.getIntPref("prefixWeight"); + this._timeGroupingSize = + this._prefBranch.getIntPref("timeGroupingSize") * 1000 * 1000; + }, + + observe(_subject, topic, data) { + if (topic == "nsPref:changed") { + let prefName = data; + log(`got change to ${prefName} preference`); + + switch (prefName) { + case "agedWeight": + this._agedWeight = this._prefBranch.getIntPref(prefName); + break; + case "boundaryWeight": + this._boundaryWeight = this._prefBranch.getIntPref(prefName); + break; + case "bucketSize": + this._bucketSize = this._prefBranch.getIntPref(prefName); + break; + case "debug": + this._debug = this._prefBranch.getBoolPref(prefName); + break; + case "enable": + this._enabled = this._prefBranch.getBoolPref(prefName); + break; + case "expire_days": + this._expireDays = this._prefBranch.getIntPref("expire_days"); + break; + case "maxTimeGroupings": + this._maxTimeGroupings = this._prefBranch.getIntPref(prefName); + break; + case "prefixWeight": + this._prefixWeight = this._prefBranch.getIntPref(prefName); + break; + case "timeGroupingSize": + this._timeGroupingSize = + this._prefBranch.getIntPref(prefName) * 1000 * 1000; + break; + default: + log(`Oops! Pref ${prefName} not handled, change ignored.`); + break; + } + } + }, + + QueryInterface: ChromeUtils.generateQI([ + "nsIObserver", + "nsISupportsWeakReference", + ]), +}; + +function log(aMessage) { + if (Prefs.get("debug")) { + Services.console.logStringMessage("FormHistory: " + aMessage); + } +} + +function sendNotification(aType, aData) { + if (typeof aData == "string") { + const strWrapper = Cc["@mozilla.org/supports-string;1"].createInstance( + Ci.nsISupportsString + ); + strWrapper.data = aData; + aData = strWrapper; + } else if (typeof aData == "number") { + const intWrapper = Cc["@mozilla.org/supports-PRInt64;1"].createInstance( + Ci.nsISupportsPRInt64 + ); + intWrapper.data = aData; + aData = intWrapper; + } else if (aData) { + throw Components.Exception( + `Invalid type ${typeof aType} passed to sendNotification`, + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + + Services.obs.notifyObservers(aData, "satchel-storage-changed", aType); +} + +/** + * Current database schema + */ + +const dbSchema = { + tables: { + moz_formhistory: { + id: "INTEGER PRIMARY KEY", + fieldname: "TEXT NOT NULL", + value: "TEXT NOT NULL", + timesUsed: "INTEGER", + firstUsed: "INTEGER", + lastUsed: "INTEGER", + guid: "TEXT", + }, + moz_deleted_formhistory: { + id: "INTEGER PRIMARY KEY", + timeDeleted: "INTEGER", + guid: "TEXT", + }, + moz_sources: { + id: "INTEGER PRIMARY KEY", + source: "TEXT NOT NULL", + }, + moz_history_to_sources: { + history_id: "INTEGER", + source_id: "INTEGER", + SQL: ` + PRIMARY KEY (history_id, source_id), + FOREIGN KEY (history_id) REFERENCES moz_formhistory(id) ON DELETE CASCADE, + FOREIGN KEY (source_id) REFERENCES moz_sources(id) ON DELETE CASCADE + `, + }, + }, + indices: { + moz_formhistory_index: { + table: "moz_formhistory", + columns: ["fieldname"], + }, + moz_formhistory_lastused_index: { + table: "moz_formhistory", + columns: ["lastUsed"], + }, + moz_formhistory_guid_index: { + table: "moz_formhistory", + columns: ["guid"], + }, + }, +}; + +/** + * Validating and processing API querying data + */ + +const validFields = [ + "fieldname", + "firstUsed", + "guid", + "lastUsed", + "source", + "timesUsed", + "value", +]; + +const searchFilters = [ + "firstUsedStart", + "firstUsedEnd", + "lastUsedStart", + "lastUsedEnd", + "source", +]; + +function validateOpData(aData, aDataType) { + let thisValidFields = validFields; + // A special case to update the GUID - in this case there can be a 'newGuid' + // field and of the normally valid fields, only 'guid' is accepted. + if (aDataType == "Update" && "newGuid" in aData) { + thisValidFields = ["guid", "newGuid"]; + } + for (const field in aData) { + if (field != "op" && !thisValidFields.includes(field)) { + throw Components.Exception( + `${aDataType} query contains an unrecognized field: ${field}`, + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + } + return aData; +} + +function validateSearchData(aData, aDataType) { + for (const field in aData) { + if ( + field != "op" && + !validFields.includes(field) && + !searchFilters.includes(field) + ) { + throw Components.Exception( + `${aDataType} query contains an unrecognized field: ${field}`, + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + } +} + +function makeQueryPredicates(aQueryData, delimiter = " AND ") { + const params = {}; + const queryTerms = Object.keys(aQueryData) + .filter(field => aQueryData[field] !== undefined) + .map(field => { + params[field] = aQueryData[field]; + switch (field) { + case "firstUsedStart": + return "firstUsed >= :" + field; + case "firstUsedEnd": + return "firstUsed <= :" + field; + case "lastUsedStart": + return "lastUsed >= :" + field; + case "lastUsedEnd": + return "lastUsed <= :" + field; + case "source": + return `EXISTS( + SELECT 1 FROM moz_history_to_sources + JOIN moz_sources s ON s.id = source_id + WHERE source = :${field} + AND history_id = moz_formhistory.id + )`; + } + return field + " = :" + field; + }) + .join(delimiter); + return { queryTerms, params }; +} + +function generateGUID() { + // string like: "{f60d9eac-9421-4abc-8491-8e8322b063d4}" + const uuid = Services.uuid.generateUUID().toString(); + let raw = ""; // A string with the low bytes set to random values + let bytes = 0; + for (let i = 1; bytes < 12; i += 2) { + // Skip dashes + if (uuid[i] == "-") { + i++; + } + const hexVal = parseInt(uuid[i] + uuid[i + 1], 16); + raw += String.fromCharCode(hexVal); + bytes++; + } + return btoa(raw); +} + +var Migrators = { + // Bug 506402 - Adds deleted form history table. + async dbAsyncMigrateToVersion4(conn) { + const tableName = "moz_deleted_formhistory"; + const tableExists = await conn.tableExists(tableName); + if (!tableExists) { + await createTable(conn, tableName); + } + }, + + // Bug 1654862 - Adds sources and moz_history_to_sources tables. + async dbAsyncMigrateToVersion5(conn) { + if (!(await conn.tableExists("moz_sources"))) { + for (const tableName of ["moz_history_to_sources", "moz_sources"]) { + await createTable(conn, tableName); + } + } + }, +}; + +/** + * @typedef {object} InsertQueryData + * @property {object} updatedChange + * A change requested by FormHistory. + * @property {string} query + * The insert query string. + */ + +/** + * Prepares a query and some default parameters when inserting an entry + * to the database. + * + * @param {object} change + * The change requested by FormHistory. + * @param {number} now + * The current timestamp in microseconds. + * @returns {InsertQueryData} + * The query information needed to pass along to the database. + */ +function prepareInsertQuery(change, now) { + const params = {}; + for (const key of new Set([ + ...Object.keys(change), + // These must always be NOT NULL. + "firstUsed", + "lastUsed", + "timesUsed", + ])) { + switch (key) { + case "fieldname": + case "guid": + case "value": + params[key] = change[key]; + break; + case "firstUsed": + case "lastUsed": + params[key] = change[key] || now; + break; + case "timesUsed": + params[key] = change[key] || 1; + break; + default: + // Skip unnecessary properties. + } + } + + return { + query: ` + INSERT INTO moz_formhistory + (fieldname, value, timesUsed, firstUsed, lastUsed, guid) + VALUES (:fieldname, :value, :timesUsed, :firstUsed, :lastUsed, :guid)`, + params, + }; +} + +// There is a fieldname / value uniqueness constraint that's at this time +// only enforced at this level. This Map maps fieldnames => values that +// are in the process of being inserted into the database so that we know +// not to try to insert the same ones on top. Attempts to do so will be +// ignored. +var InProgressInserts = { + _inProgress: new Map(), + + add(fieldname, value) { + const fieldnameSet = this._inProgress.get(fieldname); + if (!fieldnameSet) { + this._inProgress.set(fieldname, new Set([value])); + return true; + } + + if (!fieldnameSet.has(value)) { + fieldnameSet.add(value); + return true; + } + + return false; + }, + + clear(fieldnamesAndValues) { + for (const [fieldname, value] of fieldnamesAndValues) { + const fieldnameSet = this._inProgress.get(fieldname); + if (fieldnameSet?.delete(value) && fieldnameSet.size == 0) { + this._inProgress.delete(fieldname); + } + } + }, +}; + +function getAddSourceToGuidQueries(source, guid) { + return [ + { + query: `INSERT OR IGNORE INTO moz_sources (source) VALUES (:source)`, + params: { source }, + }, + { + query: ` + INSERT OR IGNORE INTO moz_history_to_sources (history_id, source_id) + VALUES( + (SELECT id FROM moz_formhistory WHERE guid = :guid), + (SELECT id FROM moz_sources WHERE source = :source) + ) + `, + params: { guid, source }, + }, + ]; +} + +/** + * Constructs and executes database statements from a pre-processed list of + * inputted changes. + * + * @param {Array.<object>} aChanges changes to form history + */ +// XXX This should be split up and the complexity reduced. +// eslint-disable-next-line complexity +async function updateFormHistoryWrite(aChanges) { + log("updateFormHistoryWrite " + aChanges.length); + + // pass 'now' down so that every entry in the batch has the same timestamp + const now = Date.now() * 1000; + let queries = []; + const notifications = []; + const adds = []; + const conn = await FormHistory.db; + + for (const change of aChanges) { + const operation = change.op; + delete change.op; + switch (operation) { + case "remove": { + log("Remove from form history " + change); + const { queryTerms, params } = makeQueryPredicates(change); + + // If source is defined, we only remove the source relation, if the + // consumer intends to remove the value from everywhere, then they + // should not pass source. This gives full control to the caller. + if (change.source) { + await conn.executeCached( + `DELETE FROM moz_history_to_sources + WHERE source_id = ( + SELECT id FROM moz_sources WHERE source = :source + ) + AND history_id = ( + SELECT id FROM moz_formhistory WHERE ${queryTerms} + ) + `, + params + ); + break; + } + + // Fetch the GUIDs we are going to delete. + try { + let query = "SELECT guid FROM moz_formhistory"; + if (queryTerms) { + query += " WHERE " + queryTerms; + } + + await conn.executeCached(query, params, row => { + notifications.push([ + "formhistory-remove", + row.getResultByName("guid"), + ]); + }); + } catch (e) { + log("Error getting guids from moz_formhistory: " + e); + } + + if (supportsDeletedTable) { + log("Moving to deleted table " + change); + let query = "INSERT INTO moz_deleted_formhistory (guid, timeDeleted)"; + + // TODO: Add these items to the deleted items table once we've sorted + // out the issues from bug 756701 + if (change.guid || queryTerms) { + query += change.guid + ? " VALUES (:guid, :timeDeleted)" + : " SELECT guid, :timeDeleted FROM moz_formhistory WHERE " + + queryTerms; + queries.push({ + query, + params: Object.assign({ timeDeleted: now }, params), + }); + } + } + + let query = "DELETE FROM moz_formhistory"; + if (queryTerms) { + log("removeEntries"); + query += " WHERE " + queryTerms; + } else { + log("removeAllEntries"); + // Not specifying any fields means we should remove all entries. We + // won't need to modify the query in this case. + } + + queries.push({ query, params }); + // Expire orphan sources. + queries.push({ + query: ` + DELETE FROM moz_sources WHERE id NOT IN ( + SELECT DISTINCT source_id FROM moz_history_to_sources + )`, + }); + break; + } + case "update": { + log("Update form history " + change); + const guid = change.guid; + delete change.guid; + // a special case for updating the GUID - the new value can be + // specified in newGuid. + if (change.newGuid) { + change.guid = change.newGuid; + delete change.newGuid; + } + + let query = "UPDATE moz_formhistory SET "; + let { queryTerms, params } = makeQueryPredicates(change, ", "); + if (!queryTerms) { + throw Components.Exception( + "Update query must define fields to modify.", + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + query += queryTerms + " WHERE guid = :existing_guid"; + queries.push({ + query, + params: Object.assign({ existing_guid: guid }, params), + }); + + notifications.push(["formhistory-update", guid]); + + // Source is ignored for "update" operations, since it's not really + // common to change the source of a value, and anyway currently this is + // mostly used to update guids. + break; + } + case "bump": { + log("Bump form history " + change); + if (change.guid) { + const query = + "UPDATE moz_formhistory " + + "SET timesUsed = timesUsed + 1, lastUsed = :lastUsed WHERE guid = :guid"; + const queryParams = { + lastUsed: now, + guid: change.guid, + }; + + queries.push({ query, params: queryParams }); + notifications.push(["formhistory-update", change.guid]); + } else { + if (!InProgressInserts.add(change.fieldname, change.value)) { + // This updateFormHistoryWrite call, or a previous one, is already + // going to add this fieldname / value pair, so we can ignore this. + continue; + } + adds.push([change.fieldname, change.value]); + change.guid = generateGUID(); + const { query, params } = prepareInsertQuery(change, now); + queries.push({ query, params }); + notifications.push(["formhistory-add", params.guid]); + } + + if (change.source) { + queries = queries.concat( + getAddSourceToGuidQueries(change.source, change.guid) + ); + } + break; + } + case "add": { + if (!InProgressInserts.add(change.fieldname, change.value)) { + // This updateFormHistoryWrite call, or a previous one, is already + // going to add this fieldname / value pair, so we can ignore this. + continue; + } + adds.push([change.fieldname, change.value]); + + log("Add to form history " + change); + if (!change.guid) { + change.guid = generateGUID(); + } + + const { query, params } = prepareInsertQuery(change, now); + queries.push({ query, params }); + + notifications.push(["formhistory-add", params.guid]); + + if (change.source) { + queries = queries.concat( + getAddSourceToGuidQueries(change.source, change.guid) + ); + } + break; + } + default: { + // We should've already guaranteed that change.op is one of the above + throw Components.Exception( + "Invalid operation " + operation, + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + } + } + + try { + await conn.executeTransaction(async () => { + for (const { query, params } of queries) { + await conn.executeCached(query, params); + } + }); + for (const [notification, param] of notifications) { + // We're either sending a GUID or nothing at all. + sendNotification(notification, param); + } + } finally { + InProgressInserts.clear(adds); + } +} + +/** + * Functions that expire entries in form history and shrinks database + * afterwards as necessary initiated by expireOldEntries. + */ + +/** + * Removes entries from database. + * + * @param {number} aExpireTime expiration timestamp + * @param {number} aBeginningCount numer of entries at first + * @returns {Promise} resolved once the work is complete + */ +async function expireOldEntriesDeletion(aExpireTime, aBeginningCount) { + log(`expireOldEntriesDeletion(${aExpireTime},${aBeginningCount})`); + + await FormHistory.update([ + { + op: "remove", + lastUsedEnd: aExpireTime, + }, + ]); + await expireOldEntriesVacuum(aExpireTime, aBeginningCount); +} + +/** + * Counts number of entries removed and shrinks database as necessary. + * + * @param {number} aExpireTime expiration timestamp + * @param {number} aBeginningCount number of entries at first + */ +async function expireOldEntriesVacuum(aExpireTime, aBeginningCount) { + const count = await FormHistory.count({}); + if (aBeginningCount - count > 500) { + log("expireOldEntriesVacuum"); + const conn = await FormHistory.db; + await conn.executeCached("VACUUM"); + } + sendNotification("formhistory-expireoldentries", aExpireTime); +} + +async function createTable(conn, tableName) { + const table = dbSchema.tables[tableName]; + const columns = Object.keys(table) + .filter(col => col != "SQL") + .map(col => [col, table[col]].join(" ")) + .join(", "); + const no_rowid = Object.keys(table).includes("id") ? "" : "WITHOUT ROWID"; + log(`Creating table ${tableName} with ${columns}`); + await conn.execute( + `CREATE TABLE ${tableName} ( + ${columns} + ${table.SQL ? "," + table.SQL : ""} + ) ${no_rowid}` + ); +} + +/** + * Database creation and access. Used by FormHistory and some of the + * utility functions, but is not exposed to the outside world. + * + * @class + */ +var DB = { + // Once we establish a database connection, we have to hold a reference + // to it so that it won't get GC'd. + _instance: null, + // MAX_ATTEMPTS is how many times we'll try to establish a connection + // or migrate a database before giving up. + MAX_ATTEMPTS: 2, + + /** String representing where the FormHistory database is on the filesystem */ + get path() { + return PathUtils.join(PathUtils.profileDir, DB_FILENAME); + }, + + /** + * Sets up and returns a connection to the FormHistory database. The + * connection also registers itself with AsyncShutdown so that the + * connection is closed on when the profile-before-change observer + * notification is fired. + * + * @returns {Promise<OpenedConnection>} + * A {@link toolkit/modules/Sqlite.sys.mjs} connection to the database. + * @throws + * If connecting to the database, or migrating the database + * failed after MAX_ATTEMPTS attempts (where each attempt + * backs up and deletes the old database), this will reject + * with the Sqlite.sys.mjs error. + */ + get conn() { + delete this.conn; + const conn = (async () => { + try { + this._instance = await this._establishConn(); + } catch (e) { + log("Failed to establish database connection: " + e); + throw e; + } + + return this._instance; + })(); + + return (this.conn = conn); + }, + + // Private functions + + /** + * Tries to connect to the Sqlite database at this.path, and then + * migrates the database as necessary. If any of the steps to do this + * fail, this function should re-enter itself with an incremented + * attemptNum so that another attempt can be made after backing up + * and deleting the old database. + * + * @async + * @param {number} attemptNum + * The optional number of the attempt that is being made to connect + * to the database. Defaults to 0. + * @returns {Promise<OpenedConnection>} + * A {@link toolkit/modules/Sqlite.sys.mjs} connection to the database. + * @throws + * If connecting to the database, or migrating the database + * failed after MAX_ATTEMPTS attempts (where each attempt + * backs up and deletes the old database), this will reject + * with the Sqlite.sys.mjs error. + */ + async _establishConn(attemptNum = 0) { + log(`Establishing database connection - attempt # ${attemptNum}`); + let conn; + try { + conn = await lazy.Sqlite.openConnection({ path: this.path }); + lazy.Sqlite.shutdown.addBlocker("Closing FormHistory database.", () => + conn.close() + ); + } catch (e) { + // Bug 1423729 - We should check the reason for the connection failure, + // in case this is due to the disk being full or the database file being + // inaccessible due to third-party software (like anti-virus software). + // In that case, we should probably fail right away. + if (attemptNum < this.MAX_ATTEMPTS) { + log("Establishing connection failed."); + await this._failover(conn); + return this._establishConn(++attemptNum); + } + + if (conn) { + await conn.close(); + } + log("Establishing connection failed too many times. Giving up."); + throw e; + } + + try { + // Enable foreign keys support. + await conn.execute("PRAGMA foreign_keys = ON"); + + const dbVersion = parseInt(await conn.getSchemaVersion(), 10); + + // Case 1: Database is up to date and we're ready to go. + if (dbVersion == DB_SCHEMA_VERSION) { + return conn; + } + + // Case 2: Downgrade + if (dbVersion > DB_SCHEMA_VERSION) { + log("Downgrading to version " + DB_SCHEMA_VERSION); + // User's DB is newer. Sanity check that our expected columns are + // present, and if so mark the lower version and merrily continue + // on. If the columns are borked, something is wrong so blow away + // the DB and start from scratch. [Future incompatible upgrades + // should switch to a different table or file.] + if (!(await this._expectedColumnsPresent(conn))) { + throw Components.Exception( + "DB is missing expected columns", + Cr.NS_ERROR_FILE_CORRUPTED + ); + } + + // Change the stored version to the current version. If the user + // runs the newer code again, it will see the lower version number + // and re-upgrade (to fixup any entries the old code added). + await conn.setSchemaVersion(DB_SCHEMA_VERSION); + return conn; + } + + // Case 3: Very old database that cannot be migrated. + // + // When FormHistory is released, we will no longer support the various + // schema versions prior to this release that nsIFormHistory2 once did. + // We'll throw an NS_ERROR_FILE_CORRUPTED, which should cause us to wipe + // out this DB and create a new one (unless this is our MAX_ATTEMPTS + // attempt). + if (dbVersion > 0 && dbVersion < 3) { + throw Components.Exception( + "DB version is unsupported.", + Cr.NS_ERROR_FILE_CORRUPTED + ); + } + + if (dbVersion == 0) { + // Case 4: New database + await conn.executeTransaction(async () => { + log("Creating DB -- tables"); + for (const name in dbSchema.tables) { + await createTable(conn, name); + } + + log("Creating DB -- indices"); + for (const name in dbSchema.indices) { + const index = dbSchema.indices[name]; + const statement = `CREATE INDEX IF NOT EXISTS ${name} ON ${ + index.table + }(${index.columns.join(", ")})`; + await conn.execute(statement); + } + }); + } else { + // Case 5: Old database requiring a migration + await conn.executeTransaction(async () => { + for (let v = dbVersion + 1; v <= DB_SCHEMA_VERSION; v++) { + log(`Upgrading to version ${v}...`); + await Migrators["dbAsyncMigrateToVersion" + v](conn); + } + }); + } + + await conn.setSchemaVersion(DB_SCHEMA_VERSION); + + return conn; + } catch (e) { + if (e.result != Cr.NS_ERROR_FILE_CORRUPTED) { + throw e; + } + + if (attemptNum < this.MAX_ATTEMPTS) { + log("Setting up database failed."); + await this._failover(conn); + return this._establishConn(++attemptNum); + } + + if (conn) { + await conn.close(); + } + + log("Setting up database failed too many times. Giving up."); + + throw e; + } + }, + + /** + * Closes a connection to the database, then backs up the database before + * deleting it. + * + * @async + * @param {SqliteConnection | null} conn + * The connection to the database that we failed to establish or + * migrate. + * @throws If any file operations fail. + */ + async _failover(conn) { + log("Cleaning up DB file - close & remove & backup."); + if (conn) { + await conn.close(); + } + const backupFile = this.path + ".corrupt"; + const uniquePath = await IOUtils.createUniqueFile( + PathUtils.parent(backupFile), + PathUtils.filename(backupFile), + 0o600 + ); + await IOUtils.copy(this.path, uniquePath); + await IOUtils.remove(this.path); + log("Completed DB cleanup."); + }, + + /** + * Tests that a database connection contains the tables that we expect. + * + * @async + * @param {SqliteConnection | null} conn + * The connection to the database that we're testing. + * @returns {Promise<boolean>} true if all expected columns are present. + */ + async _expectedColumnsPresent(conn) { + for (const name in dbSchema.tables) { + const table = dbSchema.tables[name]; + const columns = Object.keys(table).filter(col => col != "SQL"); + const query = `SELECT ${columns.join(", ")} FROM ${name}`; + try { + await conn.execute(query, null, (_row, cancel) => { + // One row is enough to let us know this worked. + cancel(); + }); + } catch (e) { + return false; + } + } + + log("Verified that expected columns are present in DB."); + return true; + }, +}; + +FormHistory = { + get db() { + return DB.conn; + }, + + get enabled() { + return Prefs.get("enabled"); + }, + + async search(aSelectTerms, aSearchData, aRowFunc) { + // if no terms selected, select everything + if (!aSelectTerms) { + // Source is not a valid column in moz_formhistory. + aSelectTerms = validFields.filter(f => f != "source"); + } + + validateSearchData(aSearchData, "Search"); + + let query = `SELECT ${aSelectTerms.join(", ")} FROM moz_formhistory`; + const { queryTerms, params } = makeQueryPredicates(aSearchData); + if (queryTerms) { + query += " WHERE " + queryTerms; + } + + const allResults = []; + + const conn = await this.db; + await conn.executeCached(query, params, row => { + const result = {}; + for (const field of aSelectTerms) { + result[field] = row.getResultByName(field); + } + aRowFunc?.(result); + allResults.push(result); + }); + + return allResults; + }, + + async count(aSearchData) { + validateSearchData(aSearchData, "Count"); + + let query = "SELECT COUNT(*) AS numEntries FROM moz_formhistory"; + const { queryTerms, params } = makeQueryPredicates(aSearchData); + if (queryTerms) { + query += " WHERE " + queryTerms; + } + + const conn = await this.db; + const rows = await conn.executeCached(query, params); + return rows[0].getResultByName("numEntries"); + }, + + async update(aChanges) { + function validIdentifier(change) { + // The identifier is only valid if one of either the guid + // or the (fieldname/value) are set (so an X-OR) + return Boolean(change.guid) != Boolean(change.fieldname && change.value); + } + + if (!("length" in aChanges)) { + aChanges = [aChanges]; + } + + const isRemoveOperation = aChanges.every(change => change?.op == "remove"); + if (!this.enabled && !isRemoveOperation) { + throw new Error( + "Form history is disabled, only remove operations are allowed" + ); + } + + for (const change of aChanges) { + switch (change.op) { + case "remove": + validateSearchData(change, "Remove"); + continue; + case "update": + if (validIdentifier(change)) { + validateOpData(change, "Update"); + if (change.guid) { + continue; + } + } else { + throw Components.Exception( + "update op='update' does not correctly reference a entry.", + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + break; + case "bump": + if (validIdentifier(change)) { + validateOpData(change, "Bump"); + if (change.guid) { + continue; + } + } else { + throw Components.Exception( + "update op='bump' does not correctly reference a entry.", + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + break; + case "add": + if (change.fieldname && change.value) { + validateOpData(change, "Add"); + } else { + throw Components.Exception( + "update op='add' must have a fieldname and a value.", + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + break; + default: + throw Components.Exception( + "update does not recognize op='" + change.op + "'", + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + + const results = await FormHistory.search(["guid"], { + fieldname: change.fieldname, + value: change.value, + }); + if (results.length > 1) { + const error = + "Database contains multiple entries with the same fieldname/value pair."; + log(error); + throw new Error(error); + } + change.guid = results[0]?.guid; + } + + await updateFormHistoryWrite(aChanges); + }, + + /** + * Gets results for the autocomplete widget. + * + * @param {string} searchString The string to search for. + * @param {object} params zero or more filter properties: + * - fieldname + * - source + * @param {Function} [callback] if provided, it is invoked for each result. + * the first argument is the result with four properties (text, + * textLowerCase, frequency, totalScore), the second argument is a cancel + * function that can be invoked to cancel the search. + * @returns {Promise<Array>} + * An array of results. If the search was canceled it will be an empty array. + */ + async getAutoCompleteResults(searchString, params, callback) { + // only do substring matching when the search string contains more than one character + let searchTokens; + let where = ""; + let boundaryCalc = ""; + + params = { + agedWeight: Prefs.get("agedWeight"), + bucketSize: Prefs.get("bucketSize"), + expiryDate: + 1000 * (Date.now() - Prefs.get("expireDays") * 24 * 60 * 60 * 1000), + maxTimeGroupings: Prefs.get("maxTimeGroupings"), + timeGroupingSize: Prefs.get("timeGroupingSize"), + prefixWeight: Prefs.get("prefixWeight"), + boundaryWeight: Prefs.get("boundaryWeight"), + ...params, + }; + + if (searchString.length >= 1) { + params.valuePrefix = searchString.replaceAll("/", "//") + "%"; + } + + if (searchString.length > 1) { + searchTokens = searchString.split(/\s+/); + + // build up the word boundary and prefix match bonus calculation + boundaryCalc = + "MAX(1, :prefixWeight * (value LIKE :valuePrefix ESCAPE '/') + ("; + // for each word, calculate word boundary weights for the SELECT clause and + // add word to the WHERE clause of the query + let tokenCalc = []; + let searchTokenCount = Math.min(searchTokens.length, MAX_SEARCH_TOKENS); + for (let i = 0; i < searchTokenCount; i++) { + let escapedToken = searchTokens[i].replaceAll("/", "//"); + params["tokenBegin" + i] = escapedToken + "%"; + params["tokenBoundary" + i] = "% " + escapedToken + "%"; + params["tokenContains" + i] = "%" + escapedToken + "%"; + + tokenCalc.push( + `(value LIKE :tokenBegin${i} ESCAPE '/') + (value LIKE :tokenBoundary${i} ESCAPE '/')` + ); + where += `AND (value LIKE :tokenContains${i} ESCAPE '/') `; + } + // add more weight if we have a traditional prefix match and + // multiply boundary bonuses by boundary weight + boundaryCalc += tokenCalc.join(" + ") + ") * :boundaryWeight)"; + } else if (searchString.length == 1) { + where = "AND (value LIKE :valuePrefix ESCAPE '/') "; + boundaryCalc = "1"; + delete params.prefixWeight; + delete params.boundaryWeight; + } else { + where = ""; + boundaryCalc = "1"; + delete params.prefixWeight; + delete params.boundaryWeight; + } + + params.now = Date.now() * 1000; // convert from ms to microseconds + + if (params.source) { + where += `AND EXISTS( + SELECT 1 FROM moz_history_to_sources + JOIN moz_sources s ON s.id = source_id + WHERE source = :source + AND history_id = moz_formhistory.id + )`; + } + + /* Three factors in the frecency calculation for an entry (in order of use in calculation): + * 1) average number of times used - items used more are ranked higher + * 2) how recently it was last used - items used recently are ranked higher + * 3) additional weight for aged entries surviving expiry - these entries are relevant + * since they have been used multiple times over a large time span so rank them higher + * The score is then divided by the bucket size and we round the result so that entries + * with a very similar frecency are bucketed together with an alphabetical sort. This is + * to reduce the amount of moving around by entries while typing. + */ + + const query = + "/* do not warn (bug 496471): can't use an index */ " + + "SELECT value, guid, " + + "ROUND( " + + "timesUsed / MAX(1.0, (lastUsed - firstUsed) / :timeGroupingSize) * " + + "MAX(1.0, :maxTimeGroupings - (:now - lastUsed) / :timeGroupingSize) * " + + "MAX(1.0, :agedWeight * (firstUsed < :expiryDate)) / " + + ":bucketSize " + + ", 3) AS frecency, " + + boundaryCalc + + " AS boundaryBonuses " + + "FROM moz_formhistory " + + "WHERE fieldname=:fieldname " + + where + + "ORDER BY ROUND(frecency * boundaryBonuses) DESC, UPPER(value) ASC"; + + const results = []; + let cancelled = false; + function cancelFn() { + cancelled = true; + } + + const conn = await this.db; + await conn.executeCached(query, params, (row, cancel) => { + if (cancelled) { + cancel(); + return; + } + + const value = row.getResultByName("value"); + const guid = row.getResultByName("guid"); + const frecency = row.getResultByName("frecency"); + const entry = { + text: value, + guid, + textLowerCase: value.toLowerCase(), + frecency, + totalScore: Math.round( + frecency * row.getResultByName("boundaryBonuses") + ), + }; + callback?.(entry, cancelFn); + results.push(entry); + }); + return cancelled ? [] : results; + }, + + // This is used only so that the test can verify deleted table support. + get _supportsDeletedTable() { + return supportsDeletedTable; + }, + set _supportsDeletedTable(val) { + supportsDeletedTable = val; + }, + + // The remaining methods are called by FormHistoryStartup.js + async expireOldEntries() { + log("expireOldEntries"); + + // Determine how many days of history we're supposed to keep. + // Calculate expireTime in microseconds + const expireTime = + (Date.now() - Prefs.get("expireDays") * DAY_IN_MS) * 1000; + + sendNotification("formhistory-beforeexpireoldentries", expireTime); + + const count = await FormHistory.count({}); + await expireOldEntriesDeletion(expireTime, count); + }, +}; + +// Prevent add-ons from redefining this API +Object.freeze(FormHistory); diff --git a/toolkit/components/satchel/FormHistoryChild.sys.mjs b/toolkit/components/satchel/FormHistoryChild.sys.mjs new file mode 100644 index 0000000000..242d8f2e29 --- /dev/null +++ b/toolkit/components/satchel/FormHistoryChild.sys.mjs @@ -0,0 +1,139 @@ +/* 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, { + CreditCard: "resource://gre/modules/CreditCard.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", +}); + +XPCOMUtils.defineLazyPreferenceGetter(lazy, "gDebug", "browser.formfill.debug"); +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "gEnabled", + "browser.formfill.enable" +); +XPCOMUtils.defineLazyServiceGetter( + lazy, + "gFormFillService", + "@mozilla.org/satchel/form-fill-controller;1", + "nsIFormFillController" +); + +function log(message) { + if (!lazy.gDebug) { + return; + } + dump("satchelFormListener: " + message + "\n"); + Services.console.logStringMessage("satchelFormListener: " + message); +} + +export class FormHistoryChild extends JSWindowActorChild { + handleEvent(event) { + switch (event.type) { + case "DOMFormBeforeSubmit": + this.#onDOMFormBeforeSubmit(event.target); + break; + default: + throw new Error("Unexpected event"); + } + } + + #onDOMFormBeforeSubmit(form) { + if ( + !lazy.gEnabled || + lazy.PrivateBrowsingUtils.isContentWindowPrivate(form.ownerGlobal) + ) { + return; + } + + log("Form submit observer notified."); + + if (form.getAttribute("autocomplete")?.toLowerCase() == "off") { + return; + } + + const entries = []; + for (const input of form.elements) { + if (!HTMLInputElement.isInstance(input)) { + continue; + } + + // Only use inputs that hold text values (not including type="password") + if (!input.mozIsTextField(true)) { + continue; + } + + // Don't save fields that were previously type=password such as on sites + // that allow the user to toggle password visibility. + if (input.hasBeenTypePassword) { + continue; + } + + // Bug 1780571, Bug 394612: If Login Manager marked this input, don't save it. + // The login manager will deal with remembering it. + if (lazy.gFormFillService.isLoginManagerField(input)) { + continue; + } + + // Don't save values when @autocomplete is "off" or has a sensitive field name. + const autocompleteInfo = input.getAutocompleteInfo(); + if (autocompleteInfo?.canAutomaticallyPersist === false) { + continue; + } + + const value = input.lastInteractiveValue?.trim(); + + // Only save user entered values even if they match the default value. + // Any script input is ignored. + // See Bug 1642570 for details. + if (!value) { + continue; + } + + // Save only when user input was last. + if (value != input.value.trim()) { + continue; + } + + // Don't save credit card numbers. + if (lazy.CreditCard.isValidNumber(value)) { + log("skipping saving a credit card number"); + continue; + } + + const name = input.name || input.id; + if (!name) { + continue; + } + + if (name == "searchbar-history") { + log('addEntry for input name "' + name + '" is denied'); + continue; + } + + // Limit stored data to 200 characters. + if (name.length > 200 || value.length > 200) { + log("skipping input that has a name/value too large"); + continue; + } + + entries.push({ name, value }); + + // Limit number of fields stored per form. + if (entries.length >= 100) { + log("not saving any more entries for this form."); + break; + } + } + + if (entries.length) { + log("sending entries to parent process for form " + form.id); + this.sendAsyncMessage("FormHistory:FormSubmitEntries", entries); + } + } +} diff --git a/toolkit/components/satchel/FormHistoryParent.sys.mjs b/toolkit/components/satchel/FormHistoryParent.sys.mjs new file mode 100644 index 0000000000..d86abbe808 --- /dev/null +++ b/toolkit/components/satchel/FormHistoryParent.sys.mjs @@ -0,0 +1,51 @@ +/* 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, { + FormHistory: "resource://gre/modules/FormHistory.sys.mjs", +}); + +export class FormHistoryParent extends JSWindowActorParent { + receiveMessage(message) { + switch (message.name) { + case "FormHistory:FormSubmitEntries": + this.#onFormSubmitEntries(message.data); + break; + + case "FormHistory:AutoCompleteSearchAsync": + return this.#onAutoCompleteSearch(message.data); + + case "FormHistory:RemoveEntry": + this.#onRemoveEntry(message.data); + break; + } + + return undefined; + } + + #onFormSubmitEntries(entries) { + const changes = entries.map(entry => ({ + op: "bump", + fieldname: entry.name, + value: entry.value, + })); + + lazy.FormHistory.update(changes); + } + + #onAutoCompleteSearch({ searchString, params }) { + return lazy.FormHistory.getAutoCompleteResults(searchString, params); + } + + #onRemoveEntry({ inputName, value, guid }) { + lazy.FormHistory.update({ + op: "remove", + fieldname: inputName, + value, + guid, + }); + } +} diff --git a/toolkit/components/satchel/FormHistoryStartup.sys.mjs b/toolkit/components/satchel/FormHistoryStartup.sys.mjs new file mode 100644 index 0000000000..0ad71cd2b8 --- /dev/null +++ b/toolkit/components/satchel/FormHistoryStartup.sys.mjs @@ -0,0 +1,100 @@ +/* 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, { + FormHistory: "resource://gre/modules/FormHistory.sys.mjs", +}); + +export class FormHistoryStartup { + classID = Components.ID("{3A0012EB-007F-4BB8-AA81-A07385F77A25}"); + + QueryInterface = ChromeUtils.generateQI([ + "nsIObserver", + "nsISupportsWeakReference", + ]); + + observe(_subject, topic, _data) { + switch (topic) { + case "idle-daily": + case "formhistory-expire-now": + lazy.FormHistory.expireOldEntries().catch(console.error); + break; + case "profile-after-change": + this.init(); + break; + } + } + + init() { + if (this.inited) { + return; + } + this.inited = true; + + // triggers needed service cleanup and db shutdown + Services.obs.addObserver(this, "idle-daily", true); + Services.obs.addObserver(this, "formhistory-expire-now", true); + + Services.ppmm.addMessageListener( + "FormHistory:AutoCompleteSearchAsync", + this + ); + Services.ppmm.addMessageListener("FormHistory:RemoveEntry", this); + } + + receiveMessage(message) { + switch (message.name) { + case "FormHistory:AutoCompleteSearchAsync": + this.#onFormHistoryAutoCompleteSearchAsync({ + ...message.data, + target: message.target, + }); + break; + + case "FormHistory:RemoveEntry": + this.#onFormHistoryRemoveEntry(message.data); + break; + } + } + + async #onFormHistoryAutoCompleteSearchAsync({ + id, + searchString, + params, + target, + }) { + // This case is only used for the search field. There is a + // similar algorithm in FormHistoryParent.jsm that uses + // sendQuery for other form fields. + + const instance = (this._queryInstance = {}); + const results = await lazy.FormHistory.getAutoCompleteResults( + searchString, + params, + (_row, cancel) => { + if (this._queryInstance != instance) { + cancel(); + } + } + ); + + if (this._queryInstance == instance) { + target.sendAsyncMessage("FormHistory:AutoCompleteSearchResults", { + id, + results, + }); + } + } + + #onFormHistoryRemoveEntry({ inputName, value, guid }) { + lazy.FormHistory.update({ + op: "remove", + fieldname: inputName, + value, + guid, + }); + } +} diff --git a/toolkit/components/satchel/InputListAutoComplete.sys.mjs b/toolkit/components/satchel/InputListAutoComplete.sys.mjs new file mode 100644 index 0000000000..61623df09d --- /dev/null +++ b/toolkit/components/satchel/InputListAutoComplete.sys.mjs @@ -0,0 +1,54 @@ +/* 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 { FormAutoCompleteResult } from "resource://gre/modules/nsFormAutoCompleteResult.sys.mjs"; + +export class InputListAutoComplete { + classID = Components.ID("{bf1e01d0-953e-11df-981c-0800200c9a66}"); + QueryInterface = ChromeUtils.generateQI(["nsIInputListAutoComplete"]); + + autoCompleteSearch(aUntrimmedSearchString, aField) { + const items = this.getListSuggestions(aField); + const searchResult = items.length + ? Ci.nsIAutoCompleteResult.RESULT_SUCCESS + : Ci.nsIAutoCompleteResult.RESULT_NOMATCH; + const defaultIndex = items.length ? 0 : -1; + + return new FormAutoCompleteResult( + aUntrimmedSearchString, + searchResult, + defaultIndex, + "", + items, + null + ); + } + + getListSuggestions(aField) { + const items = []; + + if (!aField?.list) { + return items; + } + + const lowerFieldValue = aField.value.toLowerCase(); + + for (const option of aField.list.options) { + const label = option.label || option.text || option.value || ""; + + if (!label.toLowerCase().includes(lowerFieldValue)) { + continue; + } + + items.push({ + label, + value: option.value, + comment: "", + removable: false, + }); + } + + return items; + } +} diff --git a/toolkit/components/satchel/components.conf b/toolkit/components/satchel/components.conf new file mode 100644 index 0000000000..526c52534d --- /dev/null +++ b/toolkit/components/satchel/components.conf @@ -0,0 +1,39 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +Classes = [ + { + 'cid': '{895db6c7-dbdf-40ea-9f64-b175033243dc}', + 'contract_ids': [ + '@mozilla.org/satchel/form-fill-controller;1', + '@mozilla.org/autocomplete/search;1?name=form-history', + ], + 'type': 'nsFormFillController', + 'constructor': 'nsFormFillController::GetSingleton', + 'headers': ['/toolkit/components/satchel/nsFormFillController.h'], + 'categories': {'app-startup': 'FormFillController'}, + }, + + { + 'cid': '{c11c21b2-71c9-4f87-a0f8-5e13f50495fd}', + 'contract_ids': ['@mozilla.org/satchel/form-autocomplete;1'], + 'esModule': 'resource://gre/modules/FormAutoComplete.sys.mjs', + 'constructor': 'FormAutoComplete', + }, + { + 'cid': '{bf1e01d0-953e-11df-981c-0800200c9a66}', + 'contract_ids': ['@mozilla.org/satchel/inputlist-autocomplete;1'], + 'esModule': 'resource://gre/modules/InputListAutoComplete.sys.mjs', + 'constructor': 'InputListAutoComplete', + }, + { + 'cid': '{3a0012eb-007f-4bb8-aa81-a07385f77a25}', + 'contract_ids': ['@mozilla.org/satchel/form-history-startup;1'], + 'esModule': 'resource://gre/modules/FormHistoryStartup.sys.mjs', + 'constructor': 'FormHistoryStartup', + 'categories': {'profile-after-change': 'formHistoryStartup'}, + }, +] diff --git a/toolkit/components/satchel/moz.build b/toolkit/components/satchel/moz.build new file mode 100644 index 0000000000..53acf16e8b --- /dev/null +++ b/toolkit/components/satchel/moz.build @@ -0,0 +1,54 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +with Files("**"): + BUG_COMPONENT = ("Toolkit", "Form Manager") + +MOCHITEST_MANIFESTS += ["test/mochitest.ini"] +XPCSHELL_TESTS_MANIFESTS += ["test/unit/xpcshell.ini"] +BROWSER_CHROME_MANIFESTS += ["test/browser/browser.ini"] + +XPIDL_SOURCES += [ + "nsIFormAutoComplete.idl", + "nsIFormFillController.idl", + "nsIInputListAutoComplete.idl", +] + +XPIDL_MODULE = "satchel" + +SOURCES += [ + "nsFormFillController.cpp", +] + +LOCAL_INCLUDES += [ + "../build", +] + +EXTRA_JS_MODULES += [ + "FillHelpers.sys.mjs", + "FormAutoComplete.sys.mjs", + "FormHistory.sys.mjs", + "FormHistoryStartup.sys.mjs", + "InputListAutoComplete.sys.mjs", + "nsFormAutoCompleteResult.sys.mjs", +] + +XPCOM_MANIFESTS += [ + "components.conf", +] + +TESTING_JS_MODULES += [ + "test/FormHistoryTestUtils.sys.mjs", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_TARGET_FILES.actors += [ + "FormHistoryChild.sys.mjs", + "FormHistoryParent.sys.mjs", +] + +FINAL_LIBRARY = "xul" diff --git a/toolkit/components/satchel/nsFormAutoCompleteResult.sys.mjs b/toolkit/components/satchel/nsFormAutoCompleteResult.sys.mjs new file mode 100644 index 0000000000..6c86119a86 --- /dev/null +++ b/toolkit/components/satchel/nsFormAutoCompleteResult.sys.mjs @@ -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/. */ + +export class FormAutoCompleteResult { + constructor( + searchString, + searchResult, + defaultIndex, + errorDescription, + items, + prevResult + ) { + this.searchString = searchString; + this._searchResult = searchResult; + this._defaultIndex = defaultIndex; + this._errorDescription = errorDescription; + this._items = items; + this._formHistResult = prevResult; + this.entries = prevResult ? prevResult.wrappedJSObject.entries : []; + } + + // nsISupports + QueryInterface = ChromeUtils.generateQI(["nsIAutoCompleteResult"]); + + // The user's query string + searchString = ""; + + // The result code of this result object, see |get searchResult| for possible values. + _searchResult = 0; + + // The default item that should be entered if none is selected + _defaultIndex = 0; + + // The reason the search failed + _errorDescription = ""; + + /** + * A reference to the form history nsIAutocompleteResult that we're wrapping. + * We use this to forward removeEntryAt calls as needed. + */ + _formHistResult = null; + + entries = null; + + get wrappedJSObject() { + return this; + } + + /** + * @returns {number} the result code of this result object, either: + * RESULT_IGNORED (invalid searchString) + * RESULT_FAILURE (failure) + * RESULT_NOMATCH (no matches found) + * RESULT_SUCCESS (matches found) + */ + get searchResult() { + return this._searchResult; + } + + /** + * @returns {number} the default item that should be entered if none is selected + */ + get defaultIndex() { + return this._defaultIndex; + } + + /** + * @returns {string} the reason the search failed + */ + get errorDescription() { + return this._errorDescription; + } + + /** + * @returns {number} the number of results + */ + get matchCount() { + return this._items.length; + } + + _checkIndexBounds(index) { + if (index < 0 || index >= this._items.length) { + throw Components.Exception( + "Index out of range.", + Cr.NS_ERROR_ILLEGAL_VALUE + ); + } + } + + /** + * Retrieves a result + * + * @param {number} index the index of the result requested + * @returns {string} the result at the specified index + */ + getValueAt(index) { + this._checkIndexBounds(index); + return this._items[index].value; + } + + getLabelAt(index) { + this._checkIndexBounds(index); + return this._items[index].label || this._items[index].value; + } + + /** + * Retrieves a comment (metadata instance) + * + * @param {number} index the index of the comment requested + * @returns {object} the comment at the specified index + */ + getCommentAt(index) { + this._checkIndexBounds(index); + return this._items[index].comment; + } + + /** + * Retrieves a style hint specific to a particular index. + * + * @param {number} index the index of the style hint requested + * @returns {string|null} the style hint at the specified index + */ + getStyleAt(index) { + this._checkIndexBounds(index); + + if (index < this._formHistResult?.matchCount) { + return "fromhistory"; + } + + if ( + this._formHistResult?.matchCount > 0 && + index == this._formHistResult.matchCount + ) { + return "datalist-first"; + } + + return null; + } + + /** + * Retrieves an image url. + * + * @param {number} index the index of the image url requested + * @returns {string} the image url at the specified index + */ + getImageAt(index) { + this._checkIndexBounds(index); + return ""; + } + + /** + * Retrieves a result + * + * @param {number} index the index of the result requested + * @returns {string} the result at the specified index + */ + getFinalCompleteValueAt(index) { + return this.getValueAt(index); + } + + /** + * Returns true if the value at the given index is removable + * + * @param {number} index the index of the result to remove + * @returns {boolean} True if the value is removable + */ + isRemovableAt(index) { + this._checkIndexBounds(index); + return this._items[index].removable; + } + + /** + * Removes a result from the resultset + * + * @param {number} index the index of the result to remove + */ + removeValueAt(index) { + this._checkIndexBounds(index); + // Forward the removeValueAt call to the underlying result if we have one + // Note: this assumes that the form history results were added to the top + // of our arrays. + if (this._formHistResult && index < this._formHistResult.matchCount) { + // Delete the history result from the DB + this._formHistResult.removeValueAt(index); + } + this._items.splice(index, 1); + } +} diff --git a/toolkit/components/satchel/nsFormFillController.cpp b/toolkit/components/satchel/nsFormFillController.cpp new file mode 100644 index 0000000000..ba55e678d4 --- /dev/null +++ b/toolkit/components/satchel/nsFormFillController.cpp @@ -0,0 +1,1359 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#include "nsFormFillController.h" + +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/EventListenerManager.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/Event.h" // for Event +#include "mozilla/dom/HTMLDataListElement.h" +#include "mozilla/dom/HTMLInputElement.h" +#include "mozilla/dom/KeyboardEvent.h" +#include "mozilla/dom/KeyboardEventBinding.h" +#include "mozilla/dom/MouseEvent.h" +#include "mozilla/dom/PageTransitionEvent.h" +#include "mozilla/Logging.h" +#include "mozilla/PresShell.h" +#include "mozilla/Services.h" +#include "mozilla/StaticPrefs_ui.h" +#include "nsCRT.h" +#include "nsIFormAutoComplete.h" +#include "nsIInputListAutoComplete.h" +#include "nsString.h" +#include "nsPIDOMWindow.h" +#include "nsIAutoCompleteResult.h" +#include "nsIContent.h" +#include "nsInterfaceHashtable.h" +#include "nsContentUtils.h" +#include "nsGenericHTMLElement.h" +#include "nsILoadContext.h" +#include "nsIFrame.h" +#include "nsIScriptSecurityManager.h" +#include "nsFocusManager.h" +#include "nsQueryActor.h" +#include "nsQueryObject.h" +#include "nsServiceManagerUtils.h" +#include "xpcpublic.h" + +using namespace mozilla; +using namespace mozilla::dom; +using mozilla::ErrorResult; +using mozilla::LogLevel; + +static mozilla::LazyLogModule sLogger("satchel"); + +static nsIFormAutoComplete* GetFormAutoComplete() { + static nsCOMPtr<nsIFormAutoComplete> sInstance; + static bool sInitialized = false; + if (!sInitialized) { + nsresult rv; + sInstance = do_GetService("@mozilla.org/satchel/form-autocomplete;1", &rv); + + if (NS_SUCCEEDED(rv)) { + ClearOnShutdown(&sInstance); + sInitialized = true; + } + } + return sInstance; +} + +NS_IMPL_CYCLE_COLLECTION(nsFormFillController, mController, mLoginManagerAC, + mLoginReputationService, mFocusedPopup, mPopups, + mLastListener, mLastFormAutoComplete) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsFormFillController) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIFormFillController) + NS_INTERFACE_MAP_ENTRY(nsIFormFillController) + NS_INTERFACE_MAP_ENTRY(nsIAutoCompleteInput) + NS_INTERFACE_MAP_ENTRY(nsIAutoCompleteSearch) + NS_INTERFACE_MAP_ENTRY(nsIFormAutoCompleteObserver) + NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsIMutationObserver) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(nsFormFillController) +NS_IMPL_CYCLE_COLLECTING_RELEASE(nsFormFillController) + +nsFormFillController::nsFormFillController() + : mFocusedInput(nullptr), + mListNode(nullptr), + // The amount of time a context menu event supresses showing a + // popup from a focus event in ms. This matches the threshold in + // toolkit/components/passwordmgr/LoginManagerChild.jsm. + mFocusAfterRightClickThreshold(400), + mTimeout(50), + mMinResultsForPopup(1), + mMaxRows(0), + mLastRightClickTimeStamp(TimeStamp()), + mDisableAutoComplete(false), + mCompleteDefaultIndex(false), + mCompleteSelectedIndex(false), + mForceComplete(false), + mSuppressOnInput(false), + mPasswordPopupAutomaticallyOpened(false) { + mController = do_GetService("@mozilla.org/autocomplete/controller;1"); + MOZ_ASSERT(mController); + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + MOZ_ASSERT(obs); + + obs->AddObserver(this, "chrome-event-target-created", false); + obs->AddObserver(this, "autofill-fill-starting", false); + obs->AddObserver(this, "autofill-fill-complete", false); +} + +nsFormFillController::~nsFormFillController() { + if (mListNode) { + mListNode->RemoveMutationObserver(this); + mListNode = nullptr; + } + if (mFocusedInput) { + MaybeRemoveMutationObserver(mFocusedInput); + mFocusedInput = nullptr; + } + RemoveForDocument(nullptr); +} + +/* static */ +already_AddRefed<nsFormFillController> nsFormFillController::GetSingleton() { + static RefPtr<nsFormFillController> sSingleton; + if (!sSingleton) { + sSingleton = new nsFormFillController(); + ClearOnShutdown(&sSingleton); + } + return do_AddRef(sSingleton); +} + +//////////////////////////////////////////////////////////////////////// +//// nsIMutationObserver +// + +MOZ_CAN_RUN_SCRIPT_BOUNDARY +void nsFormFillController::AttributeChanged(mozilla::dom::Element* aElement, + int32_t aNameSpaceID, + nsAtom* aAttribute, + int32_t aModType, + const nsAttrValue* aOldValue) { + if ((aAttribute == nsGkAtoms::type || aAttribute == nsGkAtoms::readonly || + aAttribute == nsGkAtoms::autocomplete) && + aNameSpaceID == kNameSpaceID_None) { + RefPtr<HTMLInputElement> focusedInput(mFocusedInput); + // Reset the current state of the controller, unconditionally. + StopControllingInput(); + // Then restart based on the new values. We have to delay this + // to avoid ending up in an endless loop due to re-registering our + // mutation observer (which would notify us again for *this* event). + nsCOMPtr<nsIRunnable> event = + mozilla::NewRunnableMethod<RefPtr<HTMLInputElement>>( + "nsFormFillController::MaybeStartControllingInput", this, + &nsFormFillController::MaybeStartControllingInput, focusedInput); + aElement->OwnerDoc()->Dispatch(TaskCategory::Other, event.forget()); + } + + if (mListNode && mListNode->Contains(aElement)) { + RevalidateDataList(); + } +} + +MOZ_CAN_RUN_SCRIPT_BOUNDARY +void nsFormFillController::ContentAppended(nsIContent* aChild) { + if (mListNode && mListNode->Contains(aChild->GetParent())) { + RevalidateDataList(); + } +} + +MOZ_CAN_RUN_SCRIPT_BOUNDARY +void nsFormFillController::ContentInserted(nsIContent* aChild) { + if (mListNode && mListNode->Contains(aChild->GetParent())) { + RevalidateDataList(); + } +} + +MOZ_CAN_RUN_SCRIPT_BOUNDARY +void nsFormFillController::ContentRemoved(nsIContent* aChild, + nsIContent* aPreviousSibling) { + if (mListNode && mListNode->Contains(aChild->GetParent())) { + RevalidateDataList(); + } +} + +void nsFormFillController::CharacterDataWillChange( + nsIContent* aContent, const CharacterDataChangeInfo&) {} + +void nsFormFillController::CharacterDataChanged( + nsIContent* aContent, const CharacterDataChangeInfo&) {} + +void nsFormFillController::AttributeWillChange(mozilla::dom::Element* aElement, + int32_t aNameSpaceID, + nsAtom* aAttribute, + int32_t aModType) {} + +void nsFormFillController::ParentChainChanged(nsIContent* aContent) {} + +void nsFormFillController::ARIAAttributeDefaultWillChange( + mozilla::dom::Element* aElement, nsAtom* aAttribute, int32_t aModType) {} + +void nsFormFillController::ARIAAttributeDefaultChanged( + mozilla::dom::Element* aElement, nsAtom* aAttribute, int32_t aModType) {} + +MOZ_CAN_RUN_SCRIPT_BOUNDARY +void nsFormFillController::NodeWillBeDestroyed(nsINode* aNode) { + MOZ_LOG(sLogger, LogLevel::Verbose, ("NodeWillBeDestroyed: %p", aNode)); + mPwmgrInputs.Remove(aNode); + mAutofillInputs.Remove(aNode); + MaybeRemoveMutationObserver(aNode); + if (aNode == mListNode) { + mListNode = nullptr; + RevalidateDataList(); + } else if (aNode == mFocusedInput) { + mFocusedInput = nullptr; + } +} + +void nsFormFillController::MaybeRemoveMutationObserver(nsINode* aNode) { + // Nodes being tracked in mPwmgrInputs will have their observers removed when + // they stop being tracked. + if (!mPwmgrInputs.Get(aNode) && !mAutofillInputs.Get(aNode)) { + aNode->RemoveMutationObserver(this); + } +} + +//////////////////////////////////////////////////////////////////////// +//// nsIFormFillController + +NS_IMETHODIMP +nsFormFillController::AttachPopupElementToDocument(Document* aDocument, + dom::Element* aPopupEl) { + if (!xpc::IsInAutomation()) { + return NS_ERROR_NOT_AVAILABLE; + } + + MOZ_LOG(sLogger, LogLevel::Debug, + ("AttachPopupElementToDocument for document %p with popup %p", + aDocument, aPopupEl)); + NS_ENSURE_TRUE(aDocument && aPopupEl, NS_ERROR_ILLEGAL_VALUE); + + nsCOMPtr<nsIAutoCompletePopup> popup = aPopupEl->AsAutoCompletePopup(); + NS_ENSURE_STATE(popup); + + mPopups.InsertOrUpdate(aDocument, popup); + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::DetachFromDocument(Document* aDocument) { + if (!xpc::IsInAutomation()) { + return NS_ERROR_NOT_AVAILABLE; + } + mPopups.Remove(aDocument); + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::MarkAsLoginManagerField(HTMLInputElement* aInput) { + /* + * The Login Manager can supply autocomplete results for username fields, + * when a user has multiple logins stored for a site. It uses this + * interface to indicate that the form manager shouldn't handle the + * autocomplete. The form manager also checks for this tag when saving + * form history (so it doesn't save usernames). + */ + NS_ENSURE_STATE(aInput); + + // If the field was already marked, we don't want to show the popup again. + if (mPwmgrInputs.Get(aInput)) { + return NS_OK; + } + + mPwmgrInputs.InsertOrUpdate(aInput, true); + aInput->AddMutationObserverUnlessExists(this); + + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + if (fm) { + nsCOMPtr<nsIContent> focusedContent = fm->GetFocusedElement(); + if (focusedContent == aInput) { + if (!mFocusedInput) { + MaybeStartControllingInput(aInput); + } else { + // If we change who is responsible for searching the autocomplete + // result, notify the controller that the previous result is not valid + // anymore. + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->ResetInternalState(); + } + } + } + + if (!mLoginManagerAC) { + mLoginManagerAC = + do_GetService("@mozilla.org/login-manager/autocompletesearch;1"); + } + + return NS_OK; +} + +MOZ_CAN_RUN_SCRIPT NS_IMETHODIMP nsFormFillController::IsLoginManagerField( + HTMLInputElement* aInput, bool* isLoginManagerField) { + *isLoginManagerField = mPwmgrInputs.Get(aInput); + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::MarkAsAutofillField(HTMLInputElement* aInput) { + /* + * Support other components implementing form autofill and handle autocomplete + * for the field. + */ + NS_ENSURE_STATE(aInput); + + MOZ_LOG(sLogger, LogLevel::Verbose, + ("MarkAsAutofillField: aInput = %p", aInput)); + + if (mAutofillInputs.Get(aInput)) { + return NS_OK; + } + + mAutofillInputs.InsertOrUpdate(aInput, true); + aInput->AddMutationObserverUnlessExists(this); + + aInput->EnablePreview(); + + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + if (fm) { + nsCOMPtr<nsIContent> focusedContent = fm->GetFocusedElement(); + if (focusedContent == aInput) { + if (!mFocusedInput) { + MaybeStartControllingInput(aInput); + } else { + // See `MarkAsLoginManagerField` for why this is needed. + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->ResetInternalState(); + } + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetFocusedInput(HTMLInputElement** aInput) { + *aInput = mFocusedInput; + NS_IF_ADDREF(*aInput); + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////// +//// nsIAutoCompleteInput + +NS_IMETHODIMP +nsFormFillController::GetPopup(nsIAutoCompletePopup** aPopup) { + *aPopup = mFocusedPopup; + NS_IF_ADDREF(*aPopup); + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetPopupElement(Element** aPopup) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsFormFillController::GetController(nsIAutoCompleteController** aController) { + *aController = mController; + NS_IF_ADDREF(*aController); + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetPopupOpen(bool* aPopupOpen) { + if (mFocusedPopup) { + mFocusedPopup->GetPopupOpen(aPopupOpen); + } else { + *aPopupOpen = false; + } + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::SetPopupOpen(bool aPopupOpen) { + if (mFocusedPopup) { + if (aPopupOpen) { + // make sure input field is visible before showing popup (bug 320938) + nsCOMPtr<nsIContent> content = mFocusedInput; + NS_ENSURE_STATE(content); + nsCOMPtr<nsIDocShell> docShell = GetDocShellForInput(mFocusedInput); + NS_ENSURE_STATE(docShell); + RefPtr<PresShell> presShell = docShell->GetPresShell(); + NS_ENSURE_STATE(presShell); + presShell->ScrollContentIntoView( + content, + ScrollAxis(WhereToScroll::Nearest, WhenToScroll::IfNotVisible), + ScrollAxis(WhereToScroll::Nearest, WhenToScroll::IfNotVisible), + ScrollFlags::ScrollOverflowHidden); + // mFocusedPopup can be destroyed after ScrollContentIntoView, see bug + // 420089 + if (mFocusedPopup) { + mFocusedPopup->OpenAutocompletePopup(this, mFocusedInput); + } + } else { + mFocusedPopup->ClosePopup(); + mPasswordPopupAutomaticallyOpened = false; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetDisableAutoComplete(bool* aDisableAutoComplete) { + *aDisableAutoComplete = mDisableAutoComplete; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::SetDisableAutoComplete(bool aDisableAutoComplete) { + mDisableAutoComplete = aDisableAutoComplete; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetCompleteDefaultIndex(bool* aCompleteDefaultIndex) { + *aCompleteDefaultIndex = mCompleteDefaultIndex; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::SetCompleteDefaultIndex(bool aCompleteDefaultIndex) { + mCompleteDefaultIndex = aCompleteDefaultIndex; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetCompleteSelectedIndex(bool* aCompleteSelectedIndex) { + *aCompleteSelectedIndex = mCompleteSelectedIndex; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::SetCompleteSelectedIndex(bool aCompleteSelectedIndex) { + mCompleteSelectedIndex = aCompleteSelectedIndex; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetForceComplete(bool* aForceComplete) { + *aForceComplete = mForceComplete; + return NS_OK; +} + +NS_IMETHODIMP nsFormFillController::SetForceComplete(bool aForceComplete) { + mForceComplete = aForceComplete; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetMinResultsForPopup(uint32_t* aMinResultsForPopup) { + *aMinResultsForPopup = mMinResultsForPopup; + return NS_OK; +} + +NS_IMETHODIMP nsFormFillController::SetMinResultsForPopup( + uint32_t aMinResultsForPopup) { + mMinResultsForPopup = aMinResultsForPopup; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetMaxRows(uint32_t* aMaxRows) { + *aMaxRows = mMaxRows; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::SetMaxRows(uint32_t aMaxRows) { + mMaxRows = aMaxRows; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetTimeout(uint32_t* aTimeout) { + *aTimeout = mTimeout; + return NS_OK; +} + +NS_IMETHODIMP nsFormFillController::SetTimeout(uint32_t aTimeout) { + mTimeout = aTimeout; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::SetSearchParam(const nsAString& aSearchParam) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsFormFillController::GetSearchParam(nsAString& aSearchParam) { + if (!mFocusedInput) { + NS_WARNING( + "mFocusedInput is null for some reason! avoiding a crash. should find " + "out why... - ben"); + return NS_ERROR_FAILURE; // XXX why? fix me. + } + + mFocusedInput->GetName(aSearchParam); + if (aSearchParam.IsEmpty()) { + mFocusedInput->GetId(aSearchParam); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetSearchCount(uint32_t* aSearchCount) { + *aSearchCount = 1; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetSearchAt(uint32_t index, nsACString& _retval) { + if (mAutofillInputs.Get(mFocusedInput)) { + MOZ_LOG(sLogger, LogLevel::Debug, ("GetSearchAt: autofill-profiles field")); + nsCOMPtr<nsIAutoCompleteSearch> profileSearch = do_GetService( + "@mozilla.org/autocomplete/search;1?name=autofill-profiles"); + if (profileSearch) { + _retval.AssignLiteral("autofill-profiles"); + return NS_OK; + } + } + + MOZ_LOG(sLogger, LogLevel::Debug, ("GetSearchAt: form-history field")); + _retval.AssignLiteral("form-history"); + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetTextValue(nsAString& aTextValue) { + if (mFocusedInput) { + mFocusedInput->GetValue(aTextValue, CallerType::System); + } else { + aTextValue.Truncate(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::SetTextValue(const nsAString& aTextValue) { + if (mFocusedInput) { + mSuppressOnInput = true; + mFocusedInput->SetUserInput(aTextValue, + *nsContentUtils::GetSystemPrincipal()); + mSuppressOnInput = false; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetSelectionStart(int32_t* aSelectionStart) { + if (!mFocusedInput) { + return NS_ERROR_UNEXPECTED; + } + ErrorResult rv; + *aSelectionStart = mFocusedInput->GetSelectionStartIgnoringType(rv); + return rv.StealNSResult(); +} + +NS_IMETHODIMP +nsFormFillController::GetSelectionEnd(int32_t* aSelectionEnd) { + if (!mFocusedInput) { + return NS_ERROR_UNEXPECTED; + } + ErrorResult rv; + *aSelectionEnd = mFocusedInput->GetSelectionEndIgnoringType(rv); + return rv.StealNSResult(); +} + +MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP +nsFormFillController::SelectTextRange(int32_t aStartIndex, int32_t aEndIndex) { + if (!mFocusedInput) { + return NS_ERROR_UNEXPECTED; + } + RefPtr<HTMLInputElement> focusedInput(mFocusedInput); + ErrorResult rv; + focusedInput->SetSelectionRange(aStartIndex, aEndIndex, Optional<nsAString>(), + rv); + return rv.StealNSResult(); +} + +NS_IMETHODIMP +nsFormFillController::OnSearchBegin() { return NS_OK; } + +NS_IMETHODIMP +nsFormFillController::OnSearchComplete() { return NS_OK; } + +NS_IMETHODIMP +nsFormFillController::OnTextEntered(Event* aEvent, bool itemWasSelected, + bool* aPrevent) { + NS_ENSURE_ARG(aPrevent); + NS_ENSURE_TRUE(mFocusedInput, NS_OK); + + /** + * This function can get called when text wasn't actually entered + * into the field (e.g. if an autocomplete item wasn't selected) so + * we don't fire DOMAutoComplete in that case since nothing + * was actually autocompleted. + */ + if (!itemWasSelected) { + return NS_OK; + } + + // Fire off a DOMAutoComplete event + + IgnoredErrorResult ignored; + RefPtr<Event> event = mFocusedInput->OwnerDoc()->CreateEvent( + u"Events"_ns, CallerType::System, ignored); + NS_ENSURE_STATE(event); + + event->InitEvent(u"DOMAutoComplete"_ns, true, true); + + // XXXjst: We mark this event as a trusted event, it's up to the + // callers of this to ensure that it's only called from trusted + // code. + event->SetTrusted(true); + + bool defaultActionEnabled = + mFocusedInput->DispatchEvent(*event, CallerType::System, IgnoreErrors()); + *aPrevent = !defaultActionEnabled; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::OnTextReverted(bool* _retval) { + mPasswordPopupAutomaticallyOpened = false; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetConsumeRollupEvent(bool* aConsumeRollupEvent) { + *aConsumeRollupEvent = false; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetInPrivateContext(bool* aInPrivateContext) { + if (!mFocusedInput) { + *aInPrivateContext = false; + return NS_OK; + } + + RefPtr<Document> doc = mFocusedInput->OwnerDoc(); + nsCOMPtr<nsILoadContext> loadContext = doc->GetLoadContext(); + *aInPrivateContext = loadContext && loadContext->UsePrivateBrowsing(); + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetNoRollupOnCaretMove(bool* aNoRollupOnCaretMove) { + *aNoRollupOnCaretMove = false; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetNoRollupOnEmptySearch(bool* aNoRollupOnEmptySearch) { + if (mFocusedInput && (mPwmgrInputs.Get(mFocusedInput) || + mFocusedInput->HasBeenTypePassword())) { + // Don't close the login popup when the field is cleared (bug 1534896). + *aNoRollupOnEmptySearch = true; + } else { + *aNoRollupOnEmptySearch = false; + } + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetUserContextId(uint32_t* aUserContextId) { + *aUserContextId = nsIScriptSecurityManager::DEFAULT_USER_CONTEXT_ID; + return NS_OK; +} + +NS_IMETHODIMP +nsFormFillController::GetInvalidatePreviousResult( + bool* aInvalidatePreviousResult) { + *aInvalidatePreviousResult = mInvalidatePreviousResult; + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////// +//// nsIAutoCompleteSearch + +NS_IMETHODIMP +nsFormFillController::StartSearch(const nsAString& aSearchString, + const nsAString& aSearchParam, + nsIAutoCompleteResult* aPreviousResult, + nsIAutoCompleteObserver* aListener, + nsIPropertyBag2* aOptions) { + MOZ_LOG(sLogger, LogLevel::Debug, ("StartSearch for %p", mFocusedInput)); + + nsresult rv; + + // If the login manager has indicated it's responsible for this field, let it + // handle the autocomplete. Otherwise, handle with form history. + // This method is sometimes called in unit tests and from XUL without a + // focused node. + if (mFocusedInput && (mPwmgrInputs.Get(mFocusedInput) || + mFocusedInput->HasBeenTypePassword())) { + MOZ_LOG(sLogger, LogLevel::Debug, ("StartSearch: login field")); + + // Handle the case where a password field is focused but + // MarkAsLoginManagerField wasn't called because password manager is + // disabled. + if (!mLoginManagerAC) { + mLoginManagerAC = + do_GetService("@mozilla.org/login-manager/autocompletesearch;1"); + } + + if (NS_WARN_IF(!mLoginManagerAC)) { + return NS_ERROR_FAILURE; + } + + // XXX aPreviousResult shouldn't ever be a historyResult type, since we're + // not letting satchel manage the field? + mLastListener = aListener; + rv = mLoginManagerAC->StartSearch(aSearchString, aPreviousResult, + mFocusedInput, this); + NS_ENSURE_SUCCESS(rv, rv); + } else { + MOZ_LOG(sLogger, LogLevel::Debug, ("StartSearch: non-login field")); + mLastListener = aListener; + + nsCOMPtr<nsIAutoCompleteResult> datalistResult; + if (IsTextControl(mFocusedInput)) { + rv = PerformInputListAutoComplete(aSearchString, + getter_AddRefs(datalistResult)); + NS_ENSURE_SUCCESS(rv, rv); + } + + auto formAutoComplete = GetFormAutoComplete(); + NS_ENSURE_TRUE(formAutoComplete, NS_ERROR_FAILURE); + + formAutoComplete->AutoCompleteSearchAsync(aSearchParam, aSearchString, + mFocusedInput, aPreviousResult, + datalistResult, this, aOptions); + mLastFormAutoComplete = formAutoComplete; + } + + return NS_OK; +} + +nsresult nsFormFillController::PerformInputListAutoComplete( + const nsAString& aSearch, nsIAutoCompleteResult** aResult) { + // If an <input> is focused, check if it has a list="<datalist>" which can + // provide the list of suggestions. + + MOZ_ASSERT(!mPwmgrInputs.Get(mFocusedInput)); + nsresult rv; + + nsCOMPtr<nsIInputListAutoComplete> inputListAutoComplete = + do_GetService("@mozilla.org/satchel/inputlist-autocomplete;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + rv = inputListAutoComplete->AutoCompleteSearch(aSearch, mFocusedInput, + aResult); + NS_ENSURE_SUCCESS(rv, rv); + + if (mFocusedInput) { + Element* list = mFocusedInput->GetList(); + + // Add a mutation observer to check for changes to the items in the + // <datalist> and update the suggestions accordingly. + if (mListNode != list) { + if (mListNode) { + mListNode->RemoveMutationObserver(this); + mListNode = nullptr; + } + if (list) { + list->AddMutationObserverUnlessExists(this); + mListNode = list; + } + } + } + + return NS_OK; +} + +void nsFormFillController::RevalidateDataList() { + if (!mLastListener) { + return; + } + + nsCOMPtr<nsIAutoCompleteController> controller( + do_QueryInterface(mLastListener)); + if (!controller) { + return; + } + + // We cannot use previous result since any items in search target are updated. + mInvalidatePreviousResult = true; + controller->StartSearch(mLastSearchString); +} + +NS_IMETHODIMP +nsFormFillController::StopSearch() { + // Make sure to stop and clear this, otherwise the controller will prevent + // mLastFormAutoComplete from being deleted. + if (mLastFormAutoComplete) { + mLastFormAutoComplete->StopAutoCompleteSearch(); + mLastFormAutoComplete = nullptr; + } + + if (mLoginManagerAC) { + mLoginManagerAC->StopSearch(); + } + return NS_OK; +} + +nsresult nsFormFillController::StartQueryLoginReputation( + HTMLInputElement* aInput) { + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////// +//// nsIFormAutoCompleteObserver + +NS_IMETHODIMP +nsFormFillController::OnSearchCompletion(nsIAutoCompleteResult* aResult) { + nsAutoString searchString; + aResult->GetSearchString(searchString); + + mLastSearchString = searchString; + + if (mLastListener) { + nsCOMPtr<nsIAutoCompleteObserver> lastListener = mLastListener; + lastListener->OnSearchResult(this, aResult); + } + + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////// +//// nsIObserver + +NS_IMETHODIMP +nsFormFillController::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (!nsCRT::strcmp(aTopic, "chrome-event-target-created")) { + if (RefPtr<EventTarget> eventTarget = do_QueryObject(aSubject)) { + AttachListeners(eventTarget); + } + } else if (!nsCRT::strcmp(aTopic, "autofill-fill-starting")) { + mAutoCompleteActive = true; + } else if (!nsCRT::strcmp(aTopic, "autofill-fill-complete")) { + mAutoCompleteActive = false; + } + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////// +//// nsIDOMEventListener + +NS_IMETHODIMP +nsFormFillController::HandleEvent(Event* aEvent) { + EventTarget* target = aEvent->GetOriginalTarget(); + NS_ENSURE_STATE(target); + + mInvalidatePreviousResult = false; + + nsIGlobalObject* global = target->GetOwnerGlobal(); + NS_ENSURE_STATE(global); + nsPIDOMWindowInner* inner = global->AsInnerWindow(); + NS_ENSURE_STATE(inner); + + if (!inner->GetBrowsingContext()->IsContent()) { + return NS_OK; + } + + if (aEvent->ShouldIgnoreChromeEventTargetListener()) { + return NS_OK; + } + + WidgetEvent* internalEvent = aEvent->WidgetEventPtr(); + NS_ENSURE_STATE(internalEvent); + + switch (internalEvent->mMessage) { + case eFocus: + return Focus(aEvent); + case eMouseDown: + return MouseDown(aEvent); + case eKeyDown: + return KeyDown(aEvent); + case eEditorInput: { + if (!(mAutoCompleteActive || mSuppressOnInput)) { + nsCOMPtr<nsINode> input = + do_QueryInterface(aEvent->GetComposedTarget()); + if (IsTextControl(input) && IsFocusedInputControlled()) { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + bool unused = false; + return controller->HandleText(&unused); + } + } + return NS_OK; + } + case eBlur: + if (mFocusedInput && !StaticPrefs::ui_popup_disable_autohide()) { + StopControllingInput(); + } + return NS_OK; + case eCompositionStart: + NS_ASSERTION(mController, "should have a controller!"); + if (IsFocusedInputControlled()) { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleStartComposition(); + } + return NS_OK; + case eCompositionEnd: + NS_ASSERTION(mController, "should have a controller!"); + if (IsFocusedInputControlled()) { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleEndComposition(); + } + return NS_OK; + case eContextMenu: + if (mFocusedPopup) { + mFocusedPopup->ClosePopup(); + } + return NS_OK; + case ePageHide: { + nsCOMPtr<Document> doc = do_QueryInterface(aEvent->GetTarget()); + if (!doc) { + return NS_OK; + } + + if (mFocusedInput && doc == mFocusedInput->OwnerDoc()) { + StopControllingInput(); + } + + // Only remove the observer notifications and marked autofill and password + // manager fields if the page isn't going to be persisted (i.e. it's being + // unloaded) so that appropriate autocomplete handling works with bfcache. + bool persisted = aEvent->AsPageTransitionEvent()->Persisted(); + if (!persisted) { + RemoveForDocument(doc); + } + } break; + default: + // Handling the default case to shut up stupid -Wswitch warnings. + // One day compilers will be smarter... + break; + } + + return NS_OK; +} + +void nsFormFillController::AttachListeners(EventTarget* aEventTarget) { + EventListenerManager* elm = aEventTarget->GetOrCreateListenerManager(); + NS_ENSURE_TRUE_VOID(elm); + + elm->AddEventListenerByType(this, u"focus"_ns, TrustedEventsAtCapture()); + elm->AddEventListenerByType(this, u"blur"_ns, TrustedEventsAtCapture()); + elm->AddEventListenerByType(this, u"pagehide"_ns, TrustedEventsAtCapture()); + elm->AddEventListenerByType(this, u"mousedown"_ns, TrustedEventsAtCapture()); + elm->AddEventListenerByType(this, u"input"_ns, TrustedEventsAtCapture()); + elm->AddEventListenerByType(this, u"keydown"_ns, TrustedEventsAtCapture()); + elm->AddEventListenerByType(this, u"keypress"_ns, + TrustedEventsAtSystemGroupCapture()); + elm->AddEventListenerByType(this, u"compositionstart"_ns, + TrustedEventsAtCapture()); + elm->AddEventListenerByType(this, u"compositionend"_ns, + TrustedEventsAtCapture()); + elm->AddEventListenerByType(this, u"contextmenu"_ns, + TrustedEventsAtCapture()); +} + +void nsFormFillController::RemoveForDocument(Document* aDoc) { + MOZ_LOG(sLogger, LogLevel::Verbose, ("RemoveForDocument: %p", aDoc)); + for (auto iter = mPwmgrInputs.Iter(); !iter.Done(); iter.Next()) { + const nsINode* key = iter.Key(); + if (key && (!aDoc || key->OwnerDoc() == aDoc)) { + // mFocusedInput's observer is tracked separately, so don't remove it + // here. + if (key != mFocusedInput) { + const_cast<nsINode*>(key)->RemoveMutationObserver(this); + } + iter.Remove(); + } + } + + for (auto iter = mAutofillInputs.Iter(); !iter.Done(); iter.Next()) { + const nsINode* key = iter.Key(); + if (key && (!aDoc || key->OwnerDoc() == aDoc)) { + // mFocusedInput's observer is tracked separately, so don't remove it + // here. + if (key != mFocusedInput) { + const_cast<nsINode*>(key)->RemoveMutationObserver(this); + } + iter.Remove(); + } + } +} + +bool nsFormFillController::IsTextControl(nsINode* aNode) { + nsCOMPtr<nsIFormControl> formControl = do_QueryInterface(aNode); + return formControl && formControl->IsSingleLineTextControl(false); +} + +void nsFormFillController::MaybeStartControllingInput( + HTMLInputElement* aInput) { + MOZ_LOG(sLogger, LogLevel::Verbose, + ("MaybeStartControllingInput for %p", aInput)); + if (!aInput) { + return; + } + + bool hasList = !!aInput->GetList(); + + if (!IsTextControl(aInput)) { + // Even if this is not a text control yet, it can become one in the future + if (hasList) { + StartControllingInput(aInput); + } + return; + } + + bool autocomplete = nsContentUtils::IsAutocompleteEnabled(aInput); + + bool isPwmgrInput = false; + if (mPwmgrInputs.Get(aInput) || aInput->HasBeenTypePassword()) { + isPwmgrInput = true; + } + + bool isAutofillInput = false; + if (mAutofillInputs.Get(aInput)) { + isAutofillInput = true; + } + + if (isAutofillInput || isPwmgrInput || hasList || autocomplete) { + StartControllingInput(aInput); + } + +#ifdef NIGHTLY_BUILD + // Trigger an asynchronous login reputation query when user focuses on the + // password field. + if (aInput->HasBeenTypePassword()) { + StartQueryLoginReputation(aInput); + } +#endif +} + +nsresult nsFormFillController::HandleFocus(HTMLInputElement* aInput) { + MaybeStartControllingInput(aInput); + + // Bail if we didn't start controlling the input. + if (!mFocusedInput) { + return NS_OK; + } + + // If this focus doesn't follow a right click within our specified + // threshold then show the autocomplete popup for all password fields. + // This is done to avoid showing both the context menu and the popup + // at the same time. + // We use a timestamp instead of a bool to avoid complexity when dealing with + // multiple input forms and the fact that a mousedown into an already focused + // field does not trigger another focus. + + if (!mFocusedInput->HasBeenTypePassword()) { + return NS_OK; + } + + // If we have not seen a right click yet, just show the popup. + if (mLastRightClickTimeStamp.IsNull()) { + mPasswordPopupAutomaticallyOpened = true; + ShowPopup(); + return NS_OK; + } + + uint64_t timeDiff = + (TimeStamp::Now() - mLastRightClickTimeStamp).ToMilliseconds(); + if (timeDiff > mFocusAfterRightClickThreshold) { + mPasswordPopupAutomaticallyOpened = true; + ShowPopup(); + } + + return NS_OK; +} + +nsresult nsFormFillController::Focus(Event* aEvent) { + nsCOMPtr<nsIContent> input = do_QueryInterface(aEvent->GetComposedTarget()); + return HandleFocus(MOZ_KnownLive(HTMLInputElement::FromNodeOrNull(input))); +} + +nsresult nsFormFillController::KeyDown(Event* aEvent) { + NS_ASSERTION(mController, "should have a controller!"); + + mPasswordPopupAutomaticallyOpened = false; + + if (!IsFocusedInputControlled()) { + return NS_OK; + } + + RefPtr<KeyboardEvent> keyEvent = aEvent->AsKeyboardEvent(); + if (!keyEvent) { + return NS_ERROR_FAILURE; + } + + bool cancel = false; + bool unused = false; + + uint32_t k = keyEvent->KeyCode(); + switch (k) { + case KeyboardEvent_Binding::DOM_VK_RETURN: { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleEnter(false, aEvent, &cancel); + break; + } + case KeyboardEvent_Binding::DOM_VK_DELETE: +#ifndef XP_MACOSX + { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleDelete(&cancel); + break; + } + case KeyboardEvent_Binding::DOM_VK_BACK_SPACE: { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleText(&unused); + break; + } +#else + case KeyboardEvent_Binding::DOM_VK_BACK_SPACE: { + if (keyEvent->ShiftKey()) { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleDelete(&cancel); + } else { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleText(&unused); + } + break; + } +#endif + case KeyboardEvent_Binding::DOM_VK_PAGE_UP: + case KeyboardEvent_Binding::DOM_VK_PAGE_DOWN: { + if (keyEvent->CtrlKey() || keyEvent->AltKey() || keyEvent->MetaKey()) { + break; + } + } + [[fallthrough]]; + case KeyboardEvent_Binding::DOM_VK_UP: + case KeyboardEvent_Binding::DOM_VK_DOWN: + case KeyboardEvent_Binding::DOM_VK_LEFT: + case KeyboardEvent_Binding::DOM_VK_RIGHT: { + // Get the writing-mode of the relevant input element, + // so that we can remap arrow keys if necessary. + mozilla::WritingMode wm; + if (mFocusedInput) { + nsIFrame* frame = mFocusedInput->GetPrimaryFrame(); + if (frame) { + wm = frame->GetWritingMode(); + } + } + if (wm.IsVertical()) { + switch (k) { + case KeyboardEvent_Binding::DOM_VK_LEFT: + k = wm.IsVerticalLR() ? KeyboardEvent_Binding::DOM_VK_UP + : KeyboardEvent_Binding::DOM_VK_DOWN; + break; + case KeyboardEvent_Binding::DOM_VK_RIGHT: + k = wm.IsVerticalLR() ? KeyboardEvent_Binding::DOM_VK_DOWN + : KeyboardEvent_Binding::DOM_VK_UP; + break; + case KeyboardEvent_Binding::DOM_VK_UP: + k = KeyboardEvent_Binding::DOM_VK_LEFT; + break; + case KeyboardEvent_Binding::DOM_VK_DOWN: + k = KeyboardEvent_Binding::DOM_VK_RIGHT; + break; + } + } + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleKeyNavigation(k, &cancel); + break; + } + case KeyboardEvent_Binding::DOM_VK_ESCAPE: { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleEscape(&cancel); + break; + } + case KeyboardEvent_Binding::DOM_VK_TAB: { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->HandleTab(); + cancel = false; + break; + } + } + + if (cancel) { + aEvent->PreventDefault(); + // Don't let the page see the RETURN event when the popup is open + // (indicated by cancel=true) so sites don't manually submit forms + // (e.g. via submit.click()) without the autocompleted value being filled. + // Bug 286933 will fix this for other key events. + if (k == KeyboardEvent_Binding::DOM_VK_RETURN) { + aEvent->StopPropagation(); + } + } + + return NS_OK; +} + +nsresult nsFormFillController::MouseDown(Event* aEvent) { + MouseEvent* mouseEvent = aEvent->AsMouseEvent(); + if (!mouseEvent) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsINode> targetNode = do_QueryInterface(aEvent->GetComposedTarget()); + if (!HTMLInputElement::FromNodeOrNull(targetNode)) { + return NS_OK; + } + + int16_t button = mouseEvent->Button(); + + // In case of a right click we set a timestamp that + // will be checked in Focus() to avoid showing + // both contextmenu and popup at the same time. + if (button == 2) { + mLastRightClickTimeStamp = TimeStamp::Now(); + return NS_OK; + } + + if (button != 0) { + return NS_OK; + } + + return ShowPopup(); +} + +NS_IMETHODIMP +nsFormFillController::ShowPopup() { + bool isOpen = false; + GetPopupOpen(&isOpen); + if (isOpen) { + return SetPopupOpen(false); + } + + nsCOMPtr<nsIAutoCompleteController> controller = mController; + + nsCOMPtr<nsIAutoCompleteInput> input; + controller->GetInput(getter_AddRefs(input)); + if (!input) { + return NS_OK; + } + + nsAutoString value; + input->GetTextValue(value); + if (value.Length() > 0) { + // Show the popup with a filtered result set + controller->SetSearchString(u""_ns); + bool unused = false; + controller->HandleText(&unused); + } else { + // Show the popup with the complete result set. Can't use HandleText() + // because it doesn't display the popup if the input is blank. + bool cancel = false; + controller->HandleKeyNavigation(KeyboardEvent_Binding::DOM_VK_DOWN, + &cancel); + } + + return NS_OK; +} + +NS_IMETHODIMP nsFormFillController::GetPasswordPopupAutomaticallyOpened( + bool* _retval) { + *_retval = mPasswordPopupAutomaticallyOpened; + return NS_OK; +} + +void nsFormFillController::StartControllingInput(HTMLInputElement* aInput) { + MOZ_LOG(sLogger, LogLevel::Verbose, ("StartControllingInput for %p", aInput)); + // Make sure we're not still attached to an input + StopControllingInput(); + + if (!mController || !aInput) { + return; + } + + nsCOMPtr<nsIAutoCompletePopup> popup = mPopups.Get(aInput->OwnerDoc()); + if (!popup) { + popup = do_QueryActor("AutoComplete", aInput->OwnerDoc()); + if (!popup) { + return; + } + } + + mFocusedPopup = popup; + + aInput->AddMutationObserverUnlessExists(this); + mFocusedInput = aInput; + + if (Element* list = mFocusedInput->GetList()) { + list->AddMutationObserverUnlessExists(this); + mListNode = list; + } + + if (!mFocusedInput->ReadOnly()) { + nsCOMPtr<nsIAutoCompleteController> controller = mController; + controller->SetInput(this); + } +} + +bool nsFormFillController::IsFocusedInputControlled() const { + return mFocusedInput && mController && !mFocusedInput->ReadOnly(); +} + +void nsFormFillController::StopControllingInput() { + mPasswordPopupAutomaticallyOpened = false; + + if (mListNode) { + mListNode->RemoveMutationObserver(this); + mListNode = nullptr; + } + + if (nsCOMPtr<nsIAutoCompleteController> controller = mController) { + // Reset the controller's input, but not if it has been switched + // to another input already, which might happen if the user switches + // focus by clicking another autocomplete textbox + nsCOMPtr<nsIAutoCompleteInput> input; + controller->GetInput(getter_AddRefs(input)); + if (input == this) { + MOZ_LOG(sLogger, LogLevel::Verbose, + ("StopControllingInput: Nulled controller input for %p", this)); + controller->SetInput(nullptr); + } + } + + MOZ_LOG(sLogger, LogLevel::Verbose, + ("StopControllingInput: Stopped controlling %p", mFocusedInput)); + if (mFocusedInput) { + MaybeRemoveMutationObserver(mFocusedInput); + mFocusedInput = nullptr; + } + + if (mFocusedPopup) { + mFocusedPopup->ClosePopup(); + } + mFocusedPopup = nullptr; +} + +nsIDocShell* nsFormFillController::GetDocShellForInput( + HTMLInputElement* aInput) { + NS_ENSURE_TRUE(aInput, nullptr); + + nsCOMPtr<nsPIDOMWindowOuter> win = aInput->OwnerDoc()->GetWindow(); + NS_ENSURE_TRUE(win, nullptr); + + return win->GetDocShell(); +} diff --git a/toolkit/components/satchel/nsFormFillController.h b/toolkit/components/satchel/nsFormFillController.h new file mode 100644 index 0000000000..d3baf60949 --- /dev/null +++ b/toolkit/components/satchel/nsFormFillController.h @@ -0,0 +1,151 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef __nsFormFillController__ +#define __nsFormFillController__ + +#include "mozilla/TimeStamp.h" +#include "nsIFormFillController.h" +#include "nsIAutoCompleteInput.h" +#include "nsIAutoCompleteSearch.h" +#include "nsIAutoCompleteController.h" +#include "nsIAutoCompletePopup.h" +#include "nsIDOMEventListener.h" +#include "nsIFormAutoComplete.h" +#include "nsCOMPtr.h" +#include "nsStubMutationObserver.h" +#include "nsTHashMap.h" +#include "nsInterfaceHashtable.h" +#include "nsIDocShell.h" +#include "nsILoginAutoCompleteSearch.h" +#include "nsIMutationObserver.h" +#include "nsIObserver.h" +#include "nsCycleCollectionParticipant.h" +#include "nsILoginReputation.h" + +class nsFormHistory; +class nsINode; + +namespace mozilla { +namespace dom { +class EventTarget; +class HTMLInputElement; +} // namespace dom +} // namespace mozilla + +class nsFormFillController final : public nsIFormFillController, + public nsIAutoCompleteInput, + public nsIAutoCompleteSearch, + public nsIFormAutoCompleteObserver, + public nsIDOMEventListener, + public nsIObserver, + public nsMultiMutationObserver { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_NSIFORMFILLCONTROLLER + NS_DECL_NSIAUTOCOMPLETESEARCH + NS_DECL_NSIAUTOCOMPLETEINPUT + NS_DECL_NSIFORMAUTOCOMPLETEOBSERVER + NS_DECL_NSIDOMEVENTLISTENER + NS_DECL_NSIOBSERVER + NS_DECL_NSIMUTATIONOBSERVER + + NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsFormFillController, + nsIFormFillController) + + MOZ_CAN_RUN_SCRIPT nsresult Focus(mozilla::dom::Event* aEvent); + MOZ_CAN_RUN_SCRIPT nsresult KeyDown(mozilla::dom::Event* aKeyEvent); + MOZ_CAN_RUN_SCRIPT nsresult MouseDown(mozilla::dom::Event* aMouseEvent); + + nsFormFillController(); + + static already_AddRefed<nsFormFillController> GetSingleton(); + + protected: + MOZ_CAN_RUN_SCRIPT virtual ~nsFormFillController(); + + MOZ_CAN_RUN_SCRIPT + void StartControllingInput(mozilla::dom::HTMLInputElement* aInput); + MOZ_CAN_RUN_SCRIPT void StopControllingInput(); + + bool IsFocusedInputControlled() const; + + MOZ_CAN_RUN_SCRIPT + nsresult HandleFocus(mozilla::dom::HTMLInputElement* aInput); + + void AttachListeners(mozilla::dom::EventTarget* aEventTarget); + + /** + * Checks that aElement is a type of element we want to fill, then calls + * StartControllingInput on it. + */ + MOZ_CAN_RUN_SCRIPT + void MaybeStartControllingInput(mozilla::dom::HTMLInputElement* aElement); + + nsresult PerformInputListAutoComplete(const nsAString& aSearch, + nsIAutoCompleteResult** aResult); + + MOZ_CAN_RUN_SCRIPT void RevalidateDataList(); + bool RowMatch(nsFormHistory* aHistory, uint32_t aIndex, + const nsAString& aInputName, const nsAString& aInputValue); + + inline nsIDocShell* GetDocShellForInput( + mozilla::dom::HTMLInputElement* aInput); + + void MaybeRemoveMutationObserver(nsINode* aNode); + + void RemoveForDocument(mozilla::dom::Document* aDoc); + + bool IsTextControl(nsINode* aNode); + + nsresult StartQueryLoginReputation(mozilla::dom::HTMLInputElement* aInput); + + MOZ_CAN_RUN_SCRIPT NS_IMETHODIMP isLoginManagerField( + mozilla::dom::HTMLInputElement* aInput, bool* isLoginManagerField); + + // members ////////////////////////////////////////// + + nsCOMPtr<nsIAutoCompleteController> mController; + nsCOMPtr<nsILoginAutoCompleteSearch> mLoginManagerAC; + nsCOMPtr<nsILoginReputationService> mLoginReputationService; + mozilla::dom::HTMLInputElement* mFocusedInput; + + // mListNode is a <datalist> element which, is set, has the form fill + // controller as a mutation observer for it. + nsINode* mListNode; + nsCOMPtr<nsIAutoCompletePopup> mFocusedPopup; + + // Only used by tests. + nsInterfaceHashtable<nsRefPtrHashKey<mozilla::dom::Document>, + nsIAutoCompletePopup> + mPopups; + + // The observer passed to StartSearch. It will be notified when the search + // is complete or the data from a datalist changes. + nsCOMPtr<nsIAutoCompleteObserver> mLastListener; + + // This is cleared by StopSearch(). + nsCOMPtr<nsIFormAutoComplete> mLastFormAutoComplete; + nsString mLastSearchString; + + nsTHashMap<nsPtrHashKey<const nsINode>, bool> mPwmgrInputs; + nsTHashMap<nsPtrHashKey<const nsINode>, bool> mAutofillInputs; + + uint16_t mFocusAfterRightClickThreshold; + uint32_t mTimeout; + uint32_t mMinResultsForPopup; + uint32_t mMaxRows; + mozilla::TimeStamp mLastRightClickTimeStamp; + bool mDisableAutoComplete; + bool mCompleteDefaultIndex; + bool mCompleteSelectedIndex; + bool mForceComplete; + bool mSuppressOnInput; + bool mPasswordPopupAutomaticallyOpened; + bool mAutoCompleteActive = false; + bool mInvalidatePreviousResult = false; +}; + +#endif // __nsFormFillController__ diff --git a/toolkit/components/satchel/nsIFormAutoComplete.idl b/toolkit/components/satchel/nsIFormAutoComplete.idl new file mode 100644 index 0000000000..d4520da764 --- /dev/null +++ b/toolkit/components/satchel/nsIFormAutoComplete.idl @@ -0,0 +1,45 @@ +/* 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/. */ + + +#include "nsISupports.idl" + +interface nsIAutoCompleteResult; +interface nsIFormAutoCompleteObserver; +interface nsIPropertyBag2; + +webidl HTMLInputElement; + +[scriptable, uuid(bfd9b82b-0ab3-4b6b-9e54-aa961ff4b732)] +interface nsIFormAutoComplete: nsISupports { + /** + * Generate results for a form input autocomplete menu asynchronously. + */ + void autoCompleteSearchAsync(in AString aInputName, + in AString aSearchString, + in HTMLInputElement aField, + in nsIAutoCompleteResult aPreviousResult, + in nsIAutoCompleteResult aDatalistResult, + in nsIFormAutoCompleteObserver aListener, + [optional] in nsIPropertyBag2 options); + + /** + * If a search is in progress, stop it. Otherwise, do nothing. This is used + * to cancel an existing search, for example, in preparation for a new search. + */ + void stopAutoCompleteSearch(); +}; + +[scriptable, function, uuid(604419ab-55a0-4831-9eca-1b9e67cc4751)] +interface nsIFormAutoCompleteObserver : nsISupports +{ + /* + * Called when a search is complete and the results are ready even if the + * result set is empty. If the search is cancelled or a new search is + * started, this is not called. + * + * @param result - The search result object + */ + [can_run_script] void onSearchCompletion(in nsIAutoCompleteResult result); +}; diff --git a/toolkit/components/satchel/nsIFormFillController.idl b/toolkit/components/satchel/nsIFormFillController.idl new file mode 100644 index 0000000000..25bd2d6738 --- /dev/null +++ b/toolkit/components/satchel/nsIFormFillController.idl @@ -0,0 +1,69 @@ +/* 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/. */ + +#include "nsISupports.idl" + +interface nsIAutoCompletePopup; + +webidl Document; +webidl Element; +webidl Event; +webidl HTMLInputElement; + +/* + * nsIFormFillController is an interface for controlling form fill behavior + * on HTML documents. Any number of docShells can be controller concurrently. + * While a docShell is attached, all HTML documents that are loaded within it + * will have a focus listener attached that will listen for when a text input + * is focused. When this happens, the input will be bound to the + * global nsIAutoCompleteController service. + */ + +[scriptable, uuid(07f0a0dc-f6e9-4cdd-a55f-56d770523a4c)] +interface nsIFormFillController : nsISupports +{ + /* + * The input element the form fill controller is currently bound to. + */ + readonly attribute HTMLInputElement focusedInput; + + /* + * Whether the autocomplete popup on a password field was automatically opened + * by the form fill controller (upon focus). + */ + readonly attribute boolean passwordPopupAutomaticallyOpened; + + // Only used by tests. + void attachPopupElementToDocument(in Document document, in Element popup); + void detachFromDocument(in Document document); + + /* + * Returns true if aInput is managed by the login manager. + * + * @param aInput - The HTML <input> element to tag + */ + [can_run_script] boolean isLoginManagerField(in HTMLInputElement aInput); + + /* + * Mark the specified <input> element as being managed by password manager. + * Autocomplete requests will be handed off to the password manager, and will + * not be stored in form history. + * + * @param aInput - The HTML <input> element to tag + */ + [can_run_script] void markAsLoginManagerField(in HTMLInputElement aInput); + + /* + * Mark the specified <input> element as being managed by a form autofill component. + * Autocomplete requests will be handed off to the autofill component. + * + * @param aInput - The HTML <input> element to mark + */ + [can_run_script] void markAsAutofillField(in HTMLInputElement aInput); + + /* + * Open the autocomplete popup, if possible. + */ + [can_run_script] void showPopup(); +}; diff --git a/toolkit/components/satchel/nsIInputListAutoComplete.idl b/toolkit/components/satchel/nsIInputListAutoComplete.idl new file mode 100644 index 0000000000..2cb11011f5 --- /dev/null +++ b/toolkit/components/satchel/nsIInputListAutoComplete.idl @@ -0,0 +1,18 @@ +/* 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/. */ + +#include "nsISupports.idl" + +interface nsIAutoCompleteResult; + +webidl HTMLInputElement; + +[scriptable, uuid(0e33de3e-4faf-4a1a-b96e-24115b8bfd45)] +interface nsIInputListAutoComplete: nsISupports { + /** + * Generate results for a form input autocomplete menu. + */ + nsIAutoCompleteResult autoCompleteSearch(in AString aSearchString, + in HTMLInputElement aField); +}; diff --git a/toolkit/components/satchel/test/FormHistoryTestUtils.sys.mjs b/toolkit/components/satchel/test/FormHistoryTestUtils.sys.mjs new file mode 100644 index 0000000000..f17b952b90 --- /dev/null +++ b/toolkit/components/satchel/test/FormHistoryTestUtils.sys.mjs @@ -0,0 +1,106 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + FormHistory: "resource://gre/modules/FormHistory.sys.mjs", +}); + +/** + * Provides a js-friendly promise-based API around FormHistory, and utils. + * + * Note: This is not a 100% complete implementation, it is intended for quick + * additions and check, thus further changes may be necessary for different + * use-cases. + */ +export var FormHistoryTestUtils = { + /** + * Adds values to form history. + * + * @param {string} fieldname The field name. + * @param {Array} additions Array of entries describing the values to add. + * Each entry can either be a string, or an object with the shape + * { value, source}. + * @returns {Promise} Resolved once the operation is complete. + */ + async add(fieldname, additions = []) { + // Additions are made one by one, so multiple identical entries are properly + // applied. + additions = additions.map(v => (typeof v == "string" ? { value: v } : v)); + for (let { value, source } of additions) { + await lazy.FormHistory.update( + Object.assign({ fieldname }, { op: "bump", value, source }) + ); + } + }, + + /** + * Counts values from form history. + * + * @param {string} fieldname The field name. + * @param {Array} filters Objects describing the search properties. + * @returns {number} The number of entries found. + */ + async count(fieldname, filters = {}) { + return lazy.FormHistory.count(Object.assign({ fieldname }, filters)); + }, + + /** + * Removes values from form history. + * If you want to remove all history, use clear() instead. + * + * @param {string} fieldname The field name. + * @param {Array} removals Array of entries describing the values to add. + * Each entry can either be a string, or an object with the shape + * { value, source}. If source is specified, only the source relation will + * be removed, while the global form history value persists. + * @returns {Promise} Resolved once the operation is complete. + */ + remove(fieldname, removals) { + let changes = removals.map(v => { + let criteria = typeof v == "string" ? { value: v } : v; + return Object.assign({ fieldname, op: "remove" }, criteria); + }); + return lazy.FormHistory.update(changes); + }, + + /** + * Removes all values from form history. + * If you want to remove individual values, use remove() instead. + * + * @param {string} fieldname The field name whose history should be cleared. + * Can be omitted to clear all form history. + * @returns {Promise} Resolved once the operation is complete. + */ + clear(fieldname) { + let baseChange = fieldname ? { fieldname } : {}; + return lazy.FormHistory.update(Object.assign(baseChange, { op: "remove" })); + }, + + /** + * Searches form history. + * + * @param {string} fieldname The field name. + * @param {Array} filters Objects describing the search properties. + * @returns {Promise<Array>} Resolves an array of found form history entries. + */ + search(fieldname, filters = {}) { + return lazy.FormHistory.search(null, Object.assign({ fieldname }, filters)); + }, + + /** + * Gets autocomplete results from form history. + * + * @param {string} searchString The search string. + * @param {string} fieldname The field name. + * @param {Array} filters Objects describing the search properties. + * @returns {Promise<Array>} Resolves an array of found form history entries. + */ + autocomplete(searchString, fieldname, filters = {}) { + return lazy.FormHistory.getAutoCompleteResults( + searchString, + Object.assign({ fieldname }, filters) + ); + }, +}; diff --git a/toolkit/components/satchel/test/browser/browser.ini b/toolkit/components/satchel/test/browser/browser.ini new file mode 100644 index 0000000000..6e50b45e7e --- /dev/null +++ b/toolkit/components/satchel/test/browser/browser.ini @@ -0,0 +1,9 @@ +[DEFAULT] +support-files = + !/toolkit/components/satchel/test/subtst_privbrowsing.html + +[browser_close_tab.js] +[browser_popup_mouseover.js] +skip-if = verify +[browser_privbrowsing_perwindowpb.js] +skip-if = verify diff --git a/toolkit/components/satchel/test/browser/browser_close_tab.js b/toolkit/components/satchel/test/browser/browser_close_tab.js new file mode 100644 index 0000000000..37962d37d8 --- /dev/null +++ b/toolkit/components/satchel/test/browser/browser_close_tab.js @@ -0,0 +1,46 @@ +/* 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 { FormHistory } = ChromeUtils.importESModule( + "resource://gre/modules/FormHistory.sys.mjs" +); + +add_task(async function test() { + const url = `data:text/html,<input type="text" name="field1">`; + + // Open a dummy tab. + await BrowserTestUtils.withNewTab( + { gBrowser, url }, + async function (browser) {} + ); + + await BrowserTestUtils.withNewTab( + { gBrowser, url }, + async function (browser) { + const { autoCompletePopup } = browser; + const mockHistory = [{ op: "add", fieldname: "field1", value: "value1" }]; + + await FormHistory.update([{ op: "remove" }, ...mockHistory]); + await SpecialPowers.spawn(browser, [], async function () { + const input = content.document.querySelector("input"); + + input.focus(); + }); + + // show popup + await BrowserTestUtils.synthesizeKey("VK_DOWN", {}, browser); + await TestUtils.waitForCondition(() => { + return autoCompletePopup.popupOpen; + }); + + gBrowser.removeCurrentTab(); + + await TestUtils.waitForCondition(() => { + return !autoCompletePopup.popupOpen; + }); + + Assert.ok(!autoCompletePopup.popupOpen, "Ensure the popup is closed."); + } + ); +}); diff --git a/toolkit/components/satchel/test/browser/browser_popup_mouseover.js b/toolkit/components/satchel/test/browser/browser_popup_mouseover.js new file mode 100644 index 0000000000..2b293ab983 --- /dev/null +++ b/toolkit/components/satchel/test/browser/browser_popup_mouseover.js @@ -0,0 +1,81 @@ +/* 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 { FormHistory } = ChromeUtils.importESModule( + "resource://gre/modules/FormHistory.sys.mjs" +); + +add_task(async function test() { + const url = `data:text/html,<input type="text" name="field1">`; + await BrowserTestUtils.withNewTab( + { gBrowser, url }, + async function (browser) { + const { + autoCompletePopup, + autoCompletePopup: { richlistbox: itemsBox }, + } = browser; + const mockHistory = [ + { op: "add", fieldname: "field1", value: "value1" }, + { op: "add", fieldname: "field1", value: "value2" }, + { op: "add", fieldname: "field1", value: "value3" }, + { op: "add", fieldname: "field1", value: "value4" }, + ]; + + await FormHistory.update([{ op: "remove" }, ...mockHistory]); + await SpecialPowers.spawn(browser, [], async function () { + const input = content.document.querySelector("input"); + + input.focus(); + }); + + // show popup + await BrowserTestUtils.synthesizeKey("VK_DOWN", {}, browser); + await BrowserTestUtils.waitForCondition(() => { + return autoCompletePopup.popupOpen; + }); + const listItemElems = itemsBox.querySelectorAll( + ".autocomplete-richlistitem" + ); + Assert.equal( + listItemElems.length, + mockHistory.length, + "ensure result length" + ); + Assert.equal( + autoCompletePopup.mousedOverIndex, + -1, + "mousedOverIndex should be -1" + ); + + // navigate to the first item + await BrowserTestUtils.synthesizeKey("VK_DOWN", {}, browser); + Assert.equal( + autoCompletePopup.selectedIndex, + 0, + "selectedIndex should be 0" + ); + + // mouseover the second item + EventUtils.synthesizeMouseAtCenter(listItemElems[1], { + type: "mouseover", + }); + await BrowserTestUtils.waitForCondition(() => { + return (autoCompletePopup.mousedOverIndex = 1); + }); + Assert.ok(true, "mousedOverIndex changed"); + Assert.equal( + autoCompletePopup.selectedIndex, + 0, + "selectedIndex should not be changed by mouseover" + ); + + // close popup + await SpecialPowers.spawn(browser, [], async function () { + const input = content.document.querySelector("input"); + + input.blur(); + }); + } + ); +}); diff --git a/toolkit/components/satchel/test/browser/browser_privbrowsing_perwindowpb.js b/toolkit/components/satchel/test/browser/browser_privbrowsing_perwindowpb.js new file mode 100644 index 0000000000..9614fd8f15 --- /dev/null +++ b/toolkit/components/satchel/test/browser/browser_privbrowsing_perwindowpb.js @@ -0,0 +1,49 @@ +/* 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 { FormHistory } = ChromeUtils.importESModule( + "resource://gre/modules/FormHistory.sys.mjs" +); + +/** Test for Bug 472396 */ +add_task(async function test() { + // initialization + let windowsToClose = []; + let testURI = + "http://example.com/tests/toolkit/components/satchel/test/subtst_privbrowsing.html"; + + async function doTest(aShouldValueExist, aWindow) { + let browser = aWindow.gBrowser.selectedBrowser; + BrowserTestUtils.loadURIString(browser, testURI); + await BrowserTestUtils.browserLoaded(browser); + + // Wait for the page to reload itself. + await BrowserTestUtils.browserLoaded(browser); + + let count = await FormHistory.count({ fieldname: "field", value: "value" }); + + if (aShouldValueExist) { + Assert.equal(count, 1, "In non-PB mode, we add a single entry"); + } else { + Assert.equal(count, 0, "In PB mode, we don't add any entries"); + } + } + + function testOnWindow(aOptions, aCallback) { + return BrowserTestUtils.openNewBrowserWindow(aOptions).then(win => { + windowsToClose.push(win); + return win; + }); + } + + await testOnWindow({ private: true }).then(aWin => doTest(false, aWin)); + + // Test when not on private mode after visiting a site on private + // mode. The form history should not exist. + await testOnWindow({}).then(aWin => doTest(true, aWin)); + + await Promise.all( + windowsToClose.map(win => BrowserTestUtils.closeWindow(win)) + ); +}); diff --git a/toolkit/components/satchel/test/mochitest.ini b/toolkit/components/satchel/test/mochitest.ini new file mode 100644 index 0000000000..54c05a16c6 --- /dev/null +++ b/toolkit/components/satchel/test/mochitest.ini @@ -0,0 +1,30 @@ +[DEFAULT] +skip-if = toolkit == 'android' +support-files = + satchel_common.js + subtst_form_submission_1.html + subtst_privbrowsing.html + parent_utils.js + +[test_capture_limit.html] +[test_bug_511615.html] +[test_bug_787624.html] +[test_history_datalist_duplicates.html] +[test_datalist_dynamic.html] +[test_datalist_with_caching.html] +[test_datalist_readonly_change.html] +[test_datalist_shadow_dom.html] +[test_datalist_attribute_change.html] +[test_form_autocomplete.html] +skip-if = (verify && debug && (os == 'win')) || (os == 'mac') # Bug 1514249 +[test_form_autocomplete_validation_at_input_event.html] +[test_form_autocomplete_with_list.html] +skip-if = + http3 +[test_form_submission.html] +[test_input_valid_state_with_autocomplete.html] +[test_password_autocomplete.html] +scheme = https +[test_popup_direction.html] +[test_popup_enter_event.html] +[test_submit_on_keydown_enter.html] diff --git a/toolkit/components/satchel/test/parent_utils.js b/toolkit/components/satchel/test/parent_utils.js new file mode 100644 index 0000000000..a46db9a63c --- /dev/null +++ b/toolkit/components/satchel/test/parent_utils.js @@ -0,0 +1,194 @@ +/* eslint-env mozilla/chrome-script */ + +const { FormHistory } = ChromeUtils.importESModule( + "resource://gre/modules/FormHistory.sys.mjs" +); +const { ContentTaskUtils } = ChromeUtils.importESModule( + "resource://testing-common/ContentTaskUtils.sys.mjs" +); +const { TestUtils } = ChromeUtils.importESModule( + "resource://testing-common/TestUtils.sys.mjs" +); + +var gAutocompletePopup = + Services.ww.activeWindow.document.getElementById("PopupAutoComplete"); +assert.ok(gAutocompletePopup, "Got autocomplete popup"); + +var ParentUtils = { + getMenuEntries() { + let entries = []; + let numRows = gAutocompletePopup.view.matchCount; + for (let i = 0; i < numRows; i++) { + entries.push(gAutocompletePopup.view.getValueAt(i)); + } + return entries; + }, + + cleanUpFormHistory() { + return FormHistory.update({ op: "remove" }); + }, + + updateFormHistory(changes) { + FormHistory.update(changes).then( + () => { + sendAsyncMessage("formHistoryUpdated", { ok: true }); + }, + error => { + sendAsyncMessage("formHistoryUpdated", { ok: false }); + assert.ok(false, error); + } + ); + }, + + popupshownListener() { + let results = this.getMenuEntries(); + sendAsyncMessage("onpopupshown", { results }); + }, + + countEntries(name, value) { + let obj = {}; + if (name) { + obj.fieldname = name; + } + if (value) { + obj.value = value; + } + + FormHistory.count(obj).then( + count => { + sendAsyncMessage("entriesCounted", { ok: true, count }); + }, + error => { + assert.ok(false, error); + sendAsyncMessage("entriesCounted", { ok: false }); + } + ); + }, + + async checkRowCount(expectedCount, expectedFirstValue = null) { + await ContentTaskUtils.waitForCondition(() => { + // This may be called before gAutocompletePopup has initialised + // which causes it to throw + try { + return ( + gAutocompletePopup.view.matchCount === expectedCount && + (!expectedFirstValue || + expectedCount <= 1 || + gAutocompletePopup.view.getValueAt(0) === expectedFirstValue) + ); + } catch (e) { + return false; + } + }, `Waiting for row count change to ${expectedCount}, first value: ${expectedFirstValue}.`); + return this.getMenuEntries(); + }, + + async checkSelectedIndex(expectedIndex) { + await ContentTaskUtils.waitForCondition( + () => + gAutocompletePopup.popupOpen && + gAutocompletePopup.selectedIndex === expectedIndex, + "Checking selected index" + ); + }, + + // Tests using this function need to flip pref for exceptional use of + // `new Function` / `eval()`. + // See test_autofill_and_ordinal_forms.html for example. + testMenuEntry(index, statement) { + ContentTaskUtils.waitForCondition(() => { + let el = gAutocompletePopup.richlistbox.getItemAtIndex(index); + let testFunc = new Services.ww.activeWindow.Function( + "el", + `return ${statement}` + ); + return gAutocompletePopup.popupOpen && el && testFunc(el); + }, "Testing menu entry").then(() => { + sendAsyncMessage("menuEntryTested"); + }); + }, + + getPopupState() { + function reply() { + sendAsyncMessage("gotPopupState", { + open: gAutocompletePopup.popupOpen, + selectedIndex: gAutocompletePopup.selectedIndex, + direction: gAutocompletePopup.style.direction, + }); + } + // If the popup state is stable, we can reply immediately. However, if + // it's showing or hiding, we should wait its finish and then, send the + // reply. + if ( + gAutocompletePopup.state == "open" || + gAutocompletePopup.state == "closed" + ) { + reply(); + return; + } + const stablerState = + gAutocompletePopup.state == "showing" ? "open" : "closed"; + TestUtils.waitForCondition( + () => gAutocompletePopup.state == stablerState, + `Waiting for autocomplete popup getting "${stablerState}" state` + ).then(reply); + }, + + observe(_subject, topic, data) { + // This function can be called after SimpleTest.finish(). + // Do not write assertions here, they will lead to intermittent failures. + sendAsyncMessage("satchel-storage-changed", { subject: null, topic, data }); + }, + + async cleanup() { + gAutocompletePopup.removeEventListener( + "popupshown", + this._popupshownListener + ); + await this.cleanUpFormHistory(); + }, +}; + +ParentUtils._popupshownListener = + ParentUtils.popupshownListener.bind(ParentUtils); +gAutocompletePopup.addEventListener( + "popupshown", + ParentUtils._popupshownListener +); +ParentUtils.cleanUpFormHistory(); + +addMessageListener("updateFormHistory", msg => { + ParentUtils.updateFormHistory(msg.changes); +}); + +addMessageListener("countEntries", ({ name, value }) => { + ParentUtils.countEntries(name, value); +}); + +addMessageListener( + "waitForMenuChange", + ({ expectedCount, expectedFirstValue }) => + ParentUtils.checkRowCount(expectedCount, expectedFirstValue) +); + +addMessageListener("waitForSelectedIndex", ({ expectedIndex }) => + ParentUtils.checkSelectedIndex(expectedIndex) +); +addMessageListener("waitForMenuEntryTest", ({ index, statement }) => { + ParentUtils.testMenuEntry(index, statement); +}); + +addMessageListener("getPopupState", () => { + ParentUtils.getPopupState(); +}); + +addMessageListener("addObserver", () => { + Services.obs.addObserver(ParentUtils, "satchel-storage-changed"); +}); +addMessageListener("removeObserver", () => { + Services.obs.removeObserver(ParentUtils, "satchel-storage-changed"); +}); + +addMessageListener("cleanup", async () => { + await ParentUtils.cleanup(); +}); diff --git a/toolkit/components/satchel/test/satchel_common.js b/toolkit/components/satchel/test/satchel_common.js new file mode 100644 index 0000000000..2590cb4d15 --- /dev/null +++ b/toolkit/components/satchel/test/satchel_common.js @@ -0,0 +1,323 @@ +/* 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/. */ + +/* eslint + "no-unused-vars": ["error", { + vars: "local", + args: "none", + }], +*/ + +var gPopupShownExpected = false; +var gPopupShownListener; +var gLastAutoCompleteResults; +var gChromeScript; + +const TelemetryFilterPropsAC = Object.freeze({ + category: "form_autocomplete", + method: "show", + object: "logins", +}); + +/* + * Returns the element with the specified |name| attribute. + */ +function getFormElementByName(formNum, name) { + const formElement = document.querySelector( + `#form${formNum} [name="${name}"]` + ); + + if (!formElement) { + ok(false, `getFormElementByName: Couldn't find specified CSS selector.`); + return null; + } + + return formElement; +} + +function registerPopupShownListener(listener) { + if (gPopupShownListener) { + ok(false, "got too many popupshownlisteners"); + return; + } + gPopupShownListener = listener; +} + +function getMenuEntries() { + if (!gLastAutoCompleteResults) { + throw new Error("no autocomplete results"); + } + + let results = gLastAutoCompleteResults; + gLastAutoCompleteResults = null; + return results; +} + +class StorageEventsObserver { + promisesToResolve = []; + + constructor() { + gChromeScript.sendAsyncMessage("addObserver"); + gChromeScript.addMessageListener( + "satchel-storage-changed", + this.observe.bind(this) + ); + } + + async cleanup() { + await gChromeScript.sendQuery("removeObserver"); + } + + observe({ subject, topic, data }) { + this.promisesToResolve.shift()?.({ subject, topic, data }); + } + + promiseNextStorageEvent() { + return new Promise(resolve => this.promisesToResolve.push(resolve)); + } +} + +function getFormSubmitButton(formNum) { + let form = $("form" + formNum); // by id, not name + ok(form != null, "getting form " + formNum); + + // we can't just call form.submit(), because that doesn't seem to + // invoke the form onsubmit handler. + let button = form.firstChild; + while (button && button.type != "submit") { + button = button.nextSibling; + } + ok(button != null, "getting form submit button"); + + return button; +} + +// Count the number of entries with the given name and value, and call then(number) +// when done. If name or value is null, then the value of that field does not matter. +function countEntries(name, value, then = null) { + return new Promise(resolve => { + gChromeScript.sendAsyncMessage("countEntries", { name, value }); + gChromeScript.addMessageListener("entriesCounted", function counted(data) { + gChromeScript.removeMessageListener("entriesCounted", counted); + if (!data.ok) { + ok(false, "Error occurred counting form history"); + SimpleTest.finish(); + return; + } + + if (then) { + then(data.count); + } + resolve(data.count); + }); + }); +} + +// Wrapper around FormHistory.update which handles errors. Calls then() when done. +function updateFormHistory(changes, then = null) { + return new Promise(resolve => { + gChromeScript.sendAsyncMessage("updateFormHistory", { changes }); + gChromeScript.addMessageListener( + "formHistoryUpdated", + function updated({ ok }) { + gChromeScript.removeMessageListener("formHistoryUpdated", updated); + if (!ok) { + ok(false, "Error occurred updating form history"); + SimpleTest.finish(); + return; + } + + if (then) { + then(); + } + resolve(); + } + ); + }); +} + +async function notifyMenuChanged(expectedCount, expectedFirstValue) { + gLastAutoCompleteResults = await gChromeScript.sendQuery( + "waitForMenuChange", + { expectedCount, expectedFirstValue } + ); + return gLastAutoCompleteResults; +} + +function notifySelectedIndex(expectedIndex) { + return gChromeScript.sendQuery("waitForSelectedIndex", { expectedIndex }); +} + +function testMenuEntry(index, statement) { + return new Promise(resolve => { + gChromeScript.sendAsyncMessage("waitForMenuEntryTest", { + index, + statement, + }); + gChromeScript.addMessageListener("menuEntryTested", function changed() { + gChromeScript.removeMessageListener("menuEntryTested", changed); + resolve(); + }); + }); +} + +function getPopupState(then = null) { + return new Promise(resolve => { + gChromeScript.sendAsyncMessage("getPopupState"); + gChromeScript.addMessageListener("gotPopupState", function listener(state) { + gChromeScript.removeMessageListener("gotPopupState", listener); + if (then) { + then(state); + } + resolve(state); + }); + }); +} + +function listenForUnexpectedPopupShown() { + gPopupShownListener = function onPopupShown() { + if (!gPopupShownExpected) { + ok(false, "Unexpected autocomplete popupshown event"); + } + }; +} + +async function popupBy(triggerFn) { + gPopupShownExpected = true; + const promise = new Promise(resolve => { + gPopupShownListener = ({ results }) => { + gPopupShownExpected = false; + resolve(results); + }; + }); + if (triggerFn) { + triggerFn(); + } + return promise; +} + +async function noPopupBy(triggerFn) { + gPopupShownExpected = false; + listenForUnexpectedPopupShown(); + SimpleTest.requestFlakyTimeout( + "Giving a chance for an unexpected popupshown to occur" + ); + if (triggerFn) { + await triggerFn(); + } + await new Promise(resolve => setTimeout(resolve, 500)); +} + +async function popupByArrowDown() { + return popupBy(() => { + synthesizeKey("KEY_Escape"); // in case popup is already open + synthesizeKey("KEY_ArrowDown"); + }); +} + +async function noPopupByArrowDown() { + await noPopupBy(() => { + synthesizeKey("KEY_Escape"); // in case popup is already open + synthesizeKey("KEY_ArrowDown"); + }); +} + +function checkACTelemetryEvent(actualEvent, input, augmentedExtra) { + ok( + parseInt(actualEvent[4], 10) > 0, + "elapsed time is a positive integer after converting from a string" + ); + let expectedExtra = { + acFieldName: SpecialPowers.wrap(input).getAutocompleteInfo().fieldName, + typeWasPassword: SpecialPowers.wrap(input).hasBeenTypePassword ? "1" : "0", + fieldType: input.type, + stringLength: input.value.length + "", + ...augmentedExtra, + }; + isDeeply(actualEvent[5], expectedExtra, "Check event extra object"); +} + +let gStorageEventsObserver; + +function promiseNextStorageEvent() { + return gStorageEventsObserver.promiseNextStorageEvent(); +} + +function satchelCommonSetup() { + let chromeURL = SimpleTest.getTestFileURL("parent_utils.js"); + gChromeScript = SpecialPowers.loadChromeScript(chromeURL); + gChromeScript.addMessageListener("onpopupshown", ({ results }) => { + gLastAutoCompleteResults = results; + if (gPopupShownListener) { + gPopupShownListener({ results }); + } + }); + + gStorageEventsObserver = new StorageEventsObserver(); + + SimpleTest.registerCleanupFunction(async () => { + await gStorageEventsObserver.cleanup(); + await gChromeScript.sendQuery("cleanup"); + gChromeScript.destroy(); + }); +} + +function add_named_task(name, fn) { + add_task( + { + [name]() { + return fn(); + }, + }[name] + ); +} + +function preventSubmitOnForms() { + for (const form of document.querySelectorAll("form")) { + form.onsubmit = e => e.preventDefault(); + } +} + +/** + * Press requested keys and assert input's value + * + * @param {HTMLInputElement} input + * @param {string | Array} keys + * @param {string} expectedValue + */ +function assertValueAfterKeys(input, keys, expectedValue) { + if (!Array.isArray(keys)) { + keys = [keys]; + } + for (const key of keys) { + synthesizeKey(key); + } + + is(input.value, expectedValue, "input value"); +} + +function assertAutocompleteItems(...expectedValues) { + const actualValues = getMenuEntries(); + isDeeply(actualValues, expectedValues, "expected autocomplete list"); +} + +function deleteSelectedAutocompleteItem() { + synthesizeKey("KEY_Delete", { shiftKey: true }); +} + +async function openPopupOn( + inputOrSelector, + { inputValue = "", expectPopup = true } = {} +) { + const input = + typeof inputOrSelector == "string" + ? document.querySelector(inputOrSelector) + : inputOrSelector; + input.value = inputValue; + input.focus(); + const items = await (expectPopup ? popupByArrowDown() : noPopupByArrowDown()); + return { input, items }; +} + +satchelCommonSetup(); diff --git a/toolkit/components/satchel/test/subtst_form_submission_1.html b/toolkit/components/satchel/test/subtst_form_submission_1.html new file mode 100644 index 0000000000..c1b902d6bc --- /dev/null +++ b/toolkit/components/satchel/test/subtst_form_submission_1.html @@ -0,0 +1,15 @@ +<!DOCTYPE HTML> +<html> + +<head> +</head> + +<body> + +<form> + <input id="subtest2" type="text" name="subtest2"> + <button type="submit">Submit</button> +</form> + +</body> +</html> diff --git a/toolkit/components/satchel/test/subtst_privbrowsing.html b/toolkit/components/satchel/test/subtst_privbrowsing.html new file mode 100644 index 0000000000..a61da1a714 --- /dev/null +++ b/toolkit/components/satchel/test/subtst_privbrowsing.html @@ -0,0 +1,23 @@ +<html> +<head> + <meta charset=UTF-8> + <title>Subtest for bug 472396</title> + <script> + /* exported submitForm */ + function submitForm() { + if (!location.search.includes("field")) { + let form = document.getElementById("form"); + let field = SpecialPowers.wrap(document.getElementById("field")); + field.setUserInput("value"); + form.submit(); + } + } + </script> +</head> +<body onload="submitForm();"> + <h2>Subtest for bug 472396</h2> + <form id="form"> + <input name="field" id="field"> + </form> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_bug_511615.html b/toolkit/components/satchel/test/test_bug_511615.html new file mode 100644 index 0000000000..2d67c5468b --- /dev/null +++ b/toolkit/components/satchel/test/test_bug_511615.html @@ -0,0 +1,179 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Form History Autocomplete Untrusted Events: Bug 511615</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +Test for Form History Autocomplete Untrusted Events: Bug 511615 +<p id="display"></p> + +<!-- we presumably can't hide the content for this test. --> +<div id="content"> + <!-- normal, basic form --> + <form id="form1" onsubmit="return false;"> + <input type="text" name="field1"> + <button type="submit">Submit</button> + </form> +</div> + +<script> +/** + * Indicates the time to wait before checking that the state of the autocomplete + * popup, including whether it is open, has not changed in response to events. + * + * Manual testing on a fast machine revealed that 80ms was still unreliable, + * while 100ms detected a simulated failure reliably. Unfortunately, this means + * that to take into account slower machines we should use a larger value. + * + * Note that if a machine takes more than this time to show the popup, this + * would not cause a failure, conversely the machine would not be able to detect + * whether the test should have failed. In other words, this use of timeouts is + * never expected to cause intermittent failures with test automation. + */ +const POPUP_RESPONSE_WAIT_TIME_MS = 200; + +/** + * Checks that the selected index in the popup still matches the given value. + * + * @param {number} expectedIndex + * @returns {Promise} + */ +async function checkSelectedIndexAfterResponseTime(expectedIndex) { + const popupState = await new Promise(resolve => { + setTimeout(() => getPopupState(resolve), POPUP_RESPONSE_WAIT_TIME_MS); + }); + is(popupState.open, true, "Popup should still be open."); + is(popupState.selectedIndex, expectedIndex, "Selected index should match."); +} + +const input = document.querySelector("#form1 > input"); + +function doKeyUnprivileged(key) { + const keyName = "DOM_VK_" + key.toUpperCase(); + let keycode, charcode, alwaysval; + + if (key.length == 1) { + [keycode, charcode, alwaysval] = [0, key.charCodeAt(0), charcode]; + } else { + [keycode, charcode, alwaysval] = [KeyEvent[keyName], 0, keycode]; + if (!keycode) { + throw new Error("invalid keyname in test"); + } + } + + const dnEvent = new KeyboardEvent("keydown", { + bubbles: true, + cancelable: true, + view: null, + keyCode: alwaysval, + charCode: 0, + }); + const prEvent = new KeyboardEvent("keypress", { + bubbles: true, + cancelable: true, + view: null, + keyCode: keycode, + charCode: charcode, + }); + const upEvent = new KeyboardEvent("keyup", { + bubbles: true, + cancelable: true, + view: null, + keyCode: alwaysval, + charCode: 0, + }); + + input.dispatchEvent(dnEvent); + input.dispatchEvent(prEvent); + input.dispatchEvent(upEvent); +} + +function doClickWithMouseEventUnprivileged() { + let dnEvent = document.createEvent("MouseEvent"); + let upEvent = document.createEvent("MouseEvent"); + let ckEvent = document.createEvent("MouseEvent"); + + /* eslint-disable no-multi-spaces, max-len */ + dnEvent.initMouseEvent("mousedown", true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null); + upEvent.initMouseEvent("mouseup", true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null); + ckEvent.initMouseEvent("mouseclick", true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null); + /* eslint-enable no-multi-spaces, max-len */ + + input.dispatchEvent(dnEvent); + input.dispatchEvent(upEvent); + input.dispatchEvent(ckEvent); +} + +add_setup(async () => { + await new Promise(resolve => updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "value1" }, + { op: "add", fieldname: "field1", value: "value2" }, + { op: "add", fieldname: "field1", value: "value3" }, + { op: "add", fieldname: "field1", value: "value4" }, + { op: "add", fieldname: "field1", value: "value5" }, + { op: "add", fieldname: "field1", value: "value6" }, + { op: "add", fieldname: "field1", value: "value7" }, + { op: "add", fieldname: "field1", value: "value8" }, + { op: "add", fieldname: "field1", value: "value9" }, + ], resolve)); +}); + +add_task(async function test_untrusted_events_ignored() { + // The autocomplete popup should not open from untrusted events. + for (let triggerFn of [ + () => input.focus(), + () => input.click(), + () => doClickWithMouseEventUnprivileged(), + () => doKeyUnprivileged("down"), + () => doKeyUnprivileged("page_down"), + () => doKeyUnprivileged("return"), + () => doKeyUnprivileged("v"), + () => doKeyUnprivileged(" "), + () => doKeyUnprivileged("back_space"), + ]) { + // We must wait for the entire timeout for each individual test, because the + // next event in the list might prevent the popup from opening. + await noPopupBy(triggerFn); + } + + // A privileged key press will actually open the popup. + await openPopupOn(input); + + // The selected autocomplete item should not change from untrusted events. + for (let triggerFn of [ + () => doKeyUnprivileged("down"), + () => doKeyUnprivileged("page_down"), + ]) { + triggerFn(); + await checkSelectedIndexAfterResponseTime(-1); + } + + // A privileged key press will actually change the selected index. + const indexChanged = notifySelectedIndex(0); + synthesizeKey("KEY_ArrowDown"); + await indexChanged; + + // The selected autocomplete item should not change and it should not be + // possible to use it from untrusted events. + for (let triggerFn of [ + () => doKeyUnprivileged("down"), + () => doKeyUnprivileged("page_down"), + () => doKeyUnprivileged("right"), + () => doKeyUnprivileged(" "), + () => doKeyUnprivileged("back_space"), + () => doKeyUnprivileged("back_space"), + () => doKeyUnprivileged("return"), + ]) { + triggerFn(); + await checkSelectedIndexAfterResponseTime(0); + is(input.value, "", "The selected item should not have been used."); + } +}); +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_bug_787624.html b/toolkit/components/satchel/test/test_bug_787624.html new file mode 100644 index 0000000000..13af53a477 --- /dev/null +++ b/toolkit/components/satchel/test/test_bug_787624.html @@ -0,0 +1,73 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Layout of Form History Autocomplete: Bug 787624</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <style> + .container { + border: 1px solid #333; + width: 80px; + height: 26px; + position: absolute; + z-index: 2; + } + + .subcontainer { + width: 100%; + overflow: hidden; + } + + .subcontainer input { + width: 120px; + margin: 2px 6px; + padding-right: 4px; + border: none; + height: 22px; + z-index: 1; + outline: 1px dashed #555 + } + </style> +</head> +<body> +Form History Layout test: form field autocomplete: Bug 787624 +<p id="display"></p> + +<!-- we presumably can't hide the content for this test. --> +<div id="content"> + <!-- in this form, the input field is partially hidden and can scroll --> + <div class="container"> + <div class="subcontainer"> + <form id="form1" onsubmit="return false;"> + <input type="text" name="field1"> + <button type="submit">Submit</button> + </form> + </div> + </div> +</div> + +<script> +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "value1" }, + { op: "add", fieldname: "field1", value: "value2" }, + ]); +}); + +add_task(async function test_popup_not_move_input() { + const input = document.querySelector("#form1 > input"); + const rect = input.getBoundingClientRect(); + await openPopupOn(input); + const newRect = input.getBoundingClientRect(); + isDeeply( + [newRect.left, newRect.top], + [rect.left, rect.top], + "popup does not disturb the input position"); +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_capture_limit.html b/toolkit/components/satchel/test/test_capture_limit.html new file mode 100644 index 0000000000..8591544016 --- /dev/null +++ b/toolkit/components/satchel/test/test_capture_limit.html @@ -0,0 +1,61 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Form History capture no more than 100 changes</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content" style="display: none"> + <form id="form1"> + <button type="submit">Submit</button> + </form> +</div> +<script> + +add_setup(async () => { + const count = await countEntries(null, null); + ok(!count, "initial storage is empty"); +}); + +add_task(async function captureLimit() { + // Capture no more than 100 fields per submit. See FormHistoryChild.jsm. + const inputsCount = 100 + 2; + const form = document.getElementById("form1"); + for (let i = 1; i <= inputsCount; i++) { + const newField = document.createElement("input"); + newField.setAttribute("type", "text"); + newField.setAttribute("name", "test" + i); + form.appendChild(newField); + if( i != 50) { + SpecialPowers.wrap(newField).setUserInput(i); + } + } + + form.addEventListener("submit", e => e.preventDefault(), { once: true }); + const storageUpdated = promiseNextStorageEvent(); + getFormSubmitButton(1).click(); + await storageUpdated; + + for (let i = 1; i <= inputsCount; i++) { // check all but last + const historyEntries = await countEntries("test" + i, i); + + switch(i) { + case 50: + is(historyEntries, 0, `no history saved for input ${i} because user didn't modify it`); + break; + case 102: + is(historyEntries, 0, `no history saved for input ${i} because form already captured 100 fields`); + break; + default: + is(historyEntries, 1, `history saved for input ${i}`); + break; + } + } +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_datalist_attribute_change.html b/toolkit/components/satchel/test/test_datalist_attribute_change.html new file mode 100644 index 0000000000..f9c774f8d0 --- /dev/null +++ b/toolkit/components/satchel/test/test_datalist_attribute_change.html @@ -0,0 +1,53 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Form History / Attribute change with datalist entries: Bug 1767250</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<div id="content"> + + <form> + <input list="suggest" type="button" name="input" id="input" /> + <datalist id="suggest"> + <option value="Mozilla"> + <option value="Firefox"> + <option value="Thunderbird"> + </datalist> + </form> + +</div> + +<script> + +add_task(async function test_dropdown_shown_when_type_attribute_changed() { + const input = document.getElementById("input"); + input.addEventListener("click", () => input.setAttribute("type", "text")); + + is(input.type, "button", "Input type is initially button."); + + synthesizeMouseAtCenter(input, { button: input, type: "mousedown" }, window); + synthesizeMouseAtCenter(input, { button: input, type: "mouseup" }, window); + + await SimpleTest.promiseWaitForCondition(() => input.type === "text", "Input type changed to text."); + + is(document.activeElement, input, "Text input is focused."); + // In the course of fixing Bug 1767250, we discovered that the focus ring was not shown although the element was focused. + // We decided to refer fixing this to a later bug, This is tracked in Bug 1788698. + // ok(input.matches(":focus-visible"), "Outer focus ring is shown."); + + await openPopupOn(input); + + isDeeply( + getMenuEntries(), + ["Mozilla", "Firefox", "Thunderbird"], + "Datalist shown after changing input type from button to text."); + input.removeEventListener("click", () => input.setAttribute("type", "text")); +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_datalist_dynamic.html b/toolkit/components/satchel/test/test_datalist_dynamic.html new file mode 100644 index 0000000000..95fc3eb589 --- /dev/null +++ b/toolkit/components/satchel/test/test_datalist_dynamic.html @@ -0,0 +1,80 @@ +<!DOCTYPE HTML> +<html> +<title>Dynamic change datalist</title> +<script src="/tests/SimpleTest/SimpleTest.js"></script> +<script src="/tests/SimpleTest/EventUtils.js"></script> +<script src="satchel_common.js"></script> +<link rel="stylesheet" href="/tests/SimpleTest/test.css" /> +<input list="suggest" type="text" name="field1"> +<datalist id="suggest"> + <option value="a1"> + <option value="a2"> + <option value="ab1"> + <option value="ab2"> +</datalist> +<script> +const { TestUtils } = SpecialPowers.Cu.import("resource://testing-common/TestUtils.jsm"); + +const DATALIST_DATA = { + "a": ["a1", "a2", "ab1", "ab2"], + "ab": ["ab1", "ab2", "abc1", "abc2"], + "abc": ["abc1", "abc2", "abcd1", "abcd2"], + "abcd": ["abcd1", "abcd2", "abcde1", "abcde2", "abcde3"] +}; + +add_task(async function() { + const input = document.querySelector("input"); + const datalist = document.querySelector("datalist"); + + async function inputHandler() { + const options = DATALIST_DATA[input.value] || []; + + await TestUtils.waitForTick(); + + while (datalist.firstChild) { + datalist.firstChild.remove(); + } + + for (const option of options) { + const element = document.createElement("option"); + element.setAttribute("value", option); + datalist.appendChild(element); + } + } + + await SimpleTest.promiseFocus(); + + input.addEventListener("input", inputHandler); + + input.focus(); + synthesizeKey("a"); + synthesizeKey("b"); + synthesizeKey("c"); + is(input.value, "abc", "<input>'s value has to be abc for initial data"); + await notifyMenuChanged(4); + let values = getMenuEntries(); + is(values.length, 4, "expected count of datalist popup"); + for (let i = 0; i < values.length; i++) { + is(values[i], DATALIST_DATA[input.value][i], "expected data #" + i); + } + + let promise = notifyMenuChanged(5); + synthesizeKey("d"); + is(input.value, "abcd", "<input>'s value has to be abcd for next test"); + synthesizeKey("KEY_ArrowDown"); + await promise; + + values = getMenuEntries(); + is(values.length, 5, "expected count of datalist popup"); + for (let i = 0; i < values.length; i++) { + is(values[i], DATALIST_DATA[input.value][i], "expected data #" + i); + } + + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_Enter"); + is(input.value, "abcd1", "<input>'s value has to set abcd1"); + + input.removeEventListener("input", inputHandler); +}); +</script> +</html> diff --git a/toolkit/components/satchel/test/test_datalist_readonly_change.html b/toolkit/components/satchel/test/test_datalist_readonly_change.html new file mode 100644 index 0000000000..986ef0cb7e --- /dev/null +++ b/toolkit/components/satchel/test/test_datalist_readonly_change.html @@ -0,0 +1,41 @@ +<!DOCTYPE HTML> +<html> + +<head> + <title>Dynamic change to readonly doesn't prevent datalist to keep working</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script src="satchel_common.js"></script> + <link rel="stylesheet" href="/tests/SimpleTest/test.css" /> +</head> + +<body> + <input readonly list="suggest" type="text" name="field1"> + <datalist id="suggest"> + <option value="First"></option> + <option value="Second"></option> + <option value="Secomundo"></option> + </datalist> +<script> + +add_task(async function readonly() { + const { input } = await openPopupOn("input", { expectPopup: false }); + ok(input.readOnly, "Input should be readonly"); + + input.removeAttribute("readonly"); + await new Promise(resolve => SimpleTest.executeSoon(resolve)); + // AttributeChanged takes control of the input again off a runnable... + ok(!input.readOnly, "Input should not be readonly"); + is(document.activeElement, input, "Should still be focused"); + await openPopupOn(input); + assertAutocompleteItems("First", "Second", "Secomundo"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "First"); +}); + +</script> +</body> + +</html> diff --git a/toolkit/components/satchel/test/test_datalist_shadow_dom.html b/toolkit/components/satchel/test/test_datalist_shadow_dom.html new file mode 100644 index 0000000000..e2baeccb34 --- /dev/null +++ b/toolkit/components/satchel/test/test_datalist_shadow_dom.html @@ -0,0 +1,55 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for datalist in Shadow DOM</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<div id="content"> + <div id="host"></div> +</div> + +<script> + +const host = document.getElementById("host"); +host.attachShadow({ mode: "open" }).innerHTML = ` + <form id="form1" onsubmit="return false;"> + <input list="suggest" type="text" name="field1"> + <button type="submit">Submit</button> + </form> + <datalist id="suggest"> + <option value="First"></option> + <option value="Second"></option> + <option value="Secomundo"></option> + </datalist> +`; + +add_task(async function fill_in_shadow() { + const { input } = await openPopupOn(host.shadowRoot.querySelector("input")); + assertAutocompleteItems("First", "Second", "Secomundo"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "First"); +}); + +add_task(async function filter_and_fill_in_shadow() { + const { input } = await openPopupOn(host.shadowRoot.querySelector("input")); + sendString("Sec"); + await notifyMenuChanged(2); + assertAutocompleteItems("Second", "Secomundo"); + sendString("o"); + await notifyMenuChanged(2); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "Second"); +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_datalist_with_caching.html b/toolkit/components/satchel/test/test_datalist_with_caching.html new file mode 100644 index 0000000000..9366d69ff6 --- /dev/null +++ b/toolkit/components/satchel/test/test_datalist_with_caching.html @@ -0,0 +1,64 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Form History Autocomplete</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +Form History test: form field autocomplete +<p id="display"></p> + +<!-- we presumably can't hide the content for this test. --> +<div id="content"> + + <!-- normal, basic form --> + <form id="form1" onsubmit="return false;"> + <input list="suggest" type="text" name="field1"> + <button type="submit">Submit</button> + </form> + + <datalist id="suggest"> + <option value="First"></option> + <option value="Second"></option> + <option value="Secomundo"></option> + </datalist> +</div> + +<script> +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "Sec" }, + ]); +}); + +add_task(async function datalist_with_caching() { + const { input } = await openPopupOn("#form1 > input"); + assertAutocompleteItems("Sec", "First", "Second", "Secomundo"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "Sec"); +}); + +add_task(async function filtering_datalist_with_caching() { + const { input } = await openPopupOn("#form1 > input"); + sendString("Sec"); + await notifyMenuChanged(3); + assertAutocompleteItems("Sec", "Second", "Secomundo"); + + sendString("o"); + await notifyMenuChanged(2); + assertAutocompleteItems("Second", "Secomundo"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "Second"); +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_form_autocomplete.html b/toolkit/components/satchel/test/test_form_autocomplete.html new file mode 100644 index 0000000000..d18ac03647 --- /dev/null +++ b/toolkit/components/satchel/test/test_form_autocomplete.html @@ -0,0 +1,695 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Form History Autocomplete</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +Form History test: form field autocomplete +<p id="display"></p> + +<!-- We presumably can't hide the content for this test. The large top padding is to allow + listening for scrolls to occur. --> +<div id="content" style="padding-top: 20000px;"> + + <!-- normal, basic form --> + <form id="form1"> + <input type="text" name="field1"> + <button type="submit">Submit</button> + </form> + + <!-- normal, basic form (new fieldname) --> + <form id="form2"> + <input type="text" name="field2"> + <button type="submit">Submit</button> + </form> + + <!-- form with autocomplete=off on input --> + <form id="form3"> + <input type="text" name="field2" autocomplete="off"> + <button type="submit">Submit</button> + </form> + + <!-- form with autocomplete=off on form --> + <form id="form4" autocomplete="off"> + <input type="text" name="field2"> + <button type="submit">Submit</button> + </form> + + <!-- normal form for testing filtering --> + <form id="form5"> + <input type="text" name="field3"> + <button type="submit">Submit</button> + </form> + + <!-- normal form for testing word boundary filtering --> + <form id="form6"> + <input type="text" name="field4"> + <button type="submit">Submit</button> + </form> + + <!-- form with maxlength attribute on input --> + <form id="form7"> + <input type="text" name="field5" maxlength="10"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='email' --> + <form id="form8"> + <input type="email" name="field6"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='tel' --> + <form id="form9"> + <input type="tel" name="field7"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='url' --> + <form id="form10"> + <input type="url" name="field8"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='search' --> + <form id="form11"> + <input type="search" name="field9"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='number' --> + <form id="form12"> + <input type="text" name="field10"> <!-- TODO: change back to type=number --> + <button type="submit">Submit</button> + </form> + + <!-- normal, basic form (with fieldname='searchbar-history') --> + <form id="form13"> + <input type="text" name="searchbar-history"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='date' --> + <form id="form14"> + <input type="date" name="field11"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='time' --> + <form id="form15"> + <input type="time" name="field12"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='range' --> + <form id="form16"> + <input type="range" name="field13" max="64"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='color' --> + <form id="form17"> + <input type="color" name="field14"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='month' --> + <form id="form18"> + <input type="month" name="field15"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='week' --> + <form id="form19"> + <input type="week" name="field16"> + <button type="submit">Submit</button> + </form> + + <!-- form with input type='datetime-local' --> + <form id="form20"> + <input type="datetime-local" name="field17"> + <button type="submit">Submit</button> + </form> + +</div> + +<script> +async function addEntry(fieldname, value) { + await updateFormHistory({ op: "add", fieldname, value }); +} + +preventSubmitOnForms(); +SpecialPowers.pushPrefEnv({"set": [["security.allow_eval_with_system_principal", true]]}); + +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "value1" }, + { op: "add", fieldname: "field1", value: "value2" }, + { op: "add", fieldname: "field1", value: "value3" }, + { op: "add", fieldname: "field1", value: "value4" }, + { op: "add", fieldname: "field2", value: "value1" }, + { op: "add", fieldname: "field3", value: "a" }, + { op: "add", fieldname: "field3", value: "aa" }, + { op: "add", fieldname: "field3", value: "aaz" }, + { op: "add", fieldname: "field3", value: "aa\xe6" }, // 0xae == latin ae pair (0xc6 == AE) + { op: "add", fieldname: "field3", value: "az" }, + { op: "add", fieldname: "field3", value: "z" }, + { op: "add", fieldname: "field4", value: "a\xe6" }, + { op: "add", fieldname: "field4", value: "aa a\xe6" }, + { op: "add", fieldname: "field4", value: "aba\xe6" }, + { op: "add", fieldname: "field4", value: "bc d\xe6" }, + { op: "add", fieldname: "field5", value: "1" }, + { op: "add", fieldname: "field5", value: "12" }, + { op: "add", fieldname: "field5", value: "123" }, + { op: "add", fieldname: "field5", value: "1234" }, + { op: "add", fieldname: "field6", value: "value" }, + { op: "add", fieldname: "field7", value: "value" }, + { op: "add", fieldname: "field8", value: "value" }, + { op: "add", fieldname: "field9", value: "value" }, + { op: "add", fieldname: "field10", value: "42" }, + // not used, since type=date doesn't have autocomplete currently + { op: "add", fieldname: "field11", value: "2010-10-10" }, + // not used, since type=time doesn't have autocomplete currently + { op: "add", fieldname: "field12", value: "21:21" }, + // not used, since type=range doesn't have a dropdown menu + { op: "add", fieldname: "field13", value: "32" }, + // not used, since type=color doesn't have autocomplete currently + { op: "add", fieldname: "field14", value: "#ffffff" }, + { op: "add", fieldname: "field15", value: "2016-08" }, + { op: "add", fieldname: "field16", value: "2016-W32" }, + { op: "add", fieldname: "field17", value: "2016-10-21T10:10" }, + { op: "add", fieldname: "searchbar-history", value: "blacklist test" }, + ]); +}); + +add_task(async function use_1st_item() { + const { input } = await openPopupOn("#form1 > input"); + + assertAutocompleteItems("value1", "value2", "value3", "value4"); + assertValueAfterKeys(input, "KEY_ArrowDown", ""); + assertValueAfterKeys(input, "KEY_Enter", "value1"); +}); + +add_task(async function use_2nd_item() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "value2"); +}); + +add_task(async function use_3rd_item() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "value3"); +}); + +add_task(async function use_4th_item() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "value4"); +}); + +add_task(async function use_1st_item_wrap_around() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", + "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "value1"); +}); + +add_task(async function use_last_item_via_arrow_up() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowUp", "KEY_Enter"], + "value4"); +}); + +add_task(async function use_last_item_via_arrow_up_from_selected_1st() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowUp", "KEY_ArrowUp", "KEY_Enter"], + "value4"); +}); + +add_task(async function test9() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowUp", "KEY_ArrowUp", "KEY_ArrowUp", "KEY_ArrowUp", + "KEY_ArrowUp", "KEY_ArrowUp", "KEY_ArrowUp", "KEY_Enter"], + "value4"); +}); + +add_task(async function select_1st_item_without_autocomplete() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowRight"], + "value1"); +}); + +add_task(async function set_first_item_without_autocomplete() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowLeft"], + "value1"); +}); + +add_task(async function use_1st_item_with_page_up() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_PageUp", "KEY_Enter"], + "value1"); +}); + +add_task(async function use_last_item_with_page_down() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_PageDown", "KEY_Enter"], + "value4"); +}); + +add_task(async function delete_1st_item() { + assertAutocompleteItems("value1", "value2", "value3", "value4"); + + const { input } = await openPopupOn("#form1 > input", { inputValue: "value" }); + synthesizeKey("KEY_ArrowDown"); + + // Tests that on OS X shift-backspace didn't delete the last character + // in the input (bug 480262). + // On OS X, shift-backspace and shift-delete work, just delete does not. + // On Win/Linux, shift-backspace does not work, delete and shift-delete do. + synthesizeKey(SpecialPowers.OS == "Darwin" ? "KEY_Backspace" : "KEY_Delete", { shiftKey: true }); + assertValueAfterKeys(input, [], "value"); + await notifyMenuChanged(3); + is(await countEntries("field1", "value1"), 0, "field1:value1 item deleted"); + assertValueAfterKeys(input, ["KEY_Enter"], "value2"); + assertAutocompleteItems("value2", "value3", "value4"); +}); + +add_task(async function use_1st_item_of_3() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "value2"); +}); + +add_task(async function delete_2nd_item() { + const { input } = await openPopupOn("#form1 > input"); + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_ArrowDown"); + deleteSelectedAutocompleteItem(); + await notifyMenuChanged(2); + assertValueAfterKeys(input, [], ""); + is(await countEntries("field1", "value3"), 0, "field1:value3 item deleted"); + assertValueAfterKeys(input, ["KEY_Enter"], "value4"); + assertAutocompleteItems("value2", "value4"); +}); + +add_task(async function use_1st_item_of_2() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "value2"); +}); + +add_task(async function delete_last_item_of_2() { + const { input } = await openPopupOn("#form1 > input"); + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_ArrowDown"); + deleteSelectedAutocompleteItem(); + await notifyMenuChanged(1); + assertValueAfterKeys(input, [], ""); + is(await countEntries("field1", "value4"), 0, "field1/value4 item deleted"); + assertAutocompleteItems("value2"); + assertValueAfterKeys(input, "KEY_Enter", "value2"); +}); + +add_task(async function use_1st_item_of_1() { + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "value2"); +}); + +add_task(async function delete_only_item() { + const { input } = await openPopupOn("#form1 > input"); + synthesizeKey("KEY_ArrowDown"); + deleteSelectedAutocompleteItem(); + await notifyMenuChanged(0); + is(await countEntries("field1", "value2"), 0, "field1/value2 item deleted"); + assertValueAfterKeys(input, [], ""); +}); + +add_task(async function form2_fills() { + const { input } = await openPopupOn("#form2 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "value1"); +}); + +add_task(async function form3_autocomplete_off() { + // Look at form 3, try to trigger autocomplete popup + // Sometimes, this will fail if scrollTo(0, 0) is called, so that doesn't + // happen here. Fortunately, a different input is used from the last test, + // so a scroll should still occur. + const scroll = new Promise(resolve => { + addEventListener("scroll", function listener() { + if (!window.pageYOffset) { + return; + } + + removeEventListener("scroll", listener, false); + resolve(); + }, false); + }); + const { input } = await openPopupOn("#form3 > input", { expectPopup: false }); + await scroll; + // Ensure there's no autocomplete dropdown (autocomplete=off is present) + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + ""); +}); + +add_task(async function form4_autocomplete_off() { + const { input } = await openPopupOn("#form4 > input", { expectPopup: false }); + await notifyMenuChanged(0); + + // Ensure there's no autocomplete dropdown (autocomplete=off is present) + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + ""); +}); + +add_task(async function filtering_form5() { + const { input } = await openPopupOn("#form5 > input"); + sendChar("a"); + await notifyMenuChanged(5); + assertAutocompleteItems("a", "aa", "aaz", "aa\xe6", "az"); + sendChar("a"); + await notifyMenuChanged(3); + assertAutocompleteItems("aa", "aaz", "aa\xe6"); + sendChar("\xc6"); + await notifyMenuChanged(1); + assertAutocompleteItems("aa\xe6"); + synthesizeKey("KEY_Backspace"); + await notifyMenuChanged(3); + assertAutocompleteItems("aa", "aaz", "aa\xe6"); + synthesizeKey("KEY_Backspace"); + await notifyMenuChanged(5); + assertAutocompleteItems("a", "aa", "aaz", "aa\xe6", "az"); + input.focus(); + sendChar("z"); + await notifyMenuChanged(2); + assertAutocompleteItems("az", "aaz"); + synthesizeKey("KEY_ArrowLeft"); + // Check case-insensitivity. + sendChar("A"); + await notifyMenuChanged(1); + assertAutocompleteItems("aaz"); + await addEntry("field3", "aazq"); + // check that results were cached + input.focus(); + synthesizeKey("KEY_ArrowRight"); + sendChar("q"); + await notifyMenuChanged(0); + // check that results were cached + assertAutocompleteItems(); + await addEntry("field3", "aazqq"); + input.focus(); + window.scrollTo(0, 0); + sendChar("q"); + await notifyMenuChanged(0); + // check that empty results were cached - bug 496466 + assertAutocompleteItems(); + synthesizeKey("KEY_Escape"); +}); + +add_task(async function filtering_form6_part1() { + await openPopupOn("#form6 > input"); + sendChar("a"); + await notifyMenuChanged(3); + + // Test substring matches and word boundary bonuses + // alphabetical results for first character + assertAutocompleteItems("aa a\xe6", "aba\xe6", "a\xe6"); + sendChar("\xe6"); + await notifyMenuChanged(3, "a\xe6"); + + // prefix match comes first, then word boundary match + // followed by substring match + assertAutocompleteItems("a\xe6", "aa a\xe6", "aba\xe6"); +}); + +add_task(async function filtering_form6_part2() { + await openPopupOn("#form6 > input"); + sendChar("b"); + await notifyMenuChanged(1, "bc d\xe6"); + assertAutocompleteItems("bc d\xe6"); + sendChar(" "); + await notifyMenuChanged(1); + + // check that trailing space has no effect after single char. + assertAutocompleteItems("bc d\xe6"); + sendChar("\xc6"); + await notifyMenuChanged(2); + + // check multi-word substring matches + assertAutocompleteItems("bc d\xe6", "aba\xe6"); + synthesizeKey("KEY_ArrowLeft"); + sendChar("d"); + await notifyMenuChanged(1); + + // check inserting in multi-word searches + assertAutocompleteItems("bc d\xe6"); + sendChar("z"); + await notifyMenuChanged(0); + assertAutocompleteItems(); +}); + +add_task(async function input_maxLength() { + let { input } = await openPopupOn("#form7 > input"); + await notifyMenuChanged(4); + assertAutocompleteItems("1", "12", "123", "1234"); + + input.maxLength = 4; + input = (await openPopupOn("#form7 > input")).input; + await notifyMenuChanged(4); + assertAutocompleteItems("1", "12", "123", "1234"); + + input.maxLength = 3; + input = (await openPopupOn("#form7 > input")).input; + await notifyMenuChanged(3); + assertAutocompleteItems("1", "12", "123"); + + input.maxLength = 2; + input = (await openPopupOn("#form7 > input")).input; + await notifyMenuChanged(2); + assertAutocompleteItems("1", "12"); + + input.maxLength = 1; + input = (await openPopupOn("#form7 > input")).input; + await notifyMenuChanged(1); + assertAutocompleteItems("1"); + + input.maxLength = 0; + synthesizeKey("KEY_Escape"); + synthesizeKey("KEY_ArrowDown"); + await notifyMenuChanged(0); + assertAutocompleteItems(); + + input.maxLength = 4; +}); + +add_task(async function input_maxLength_with_character_typed() { + let { input } = await openPopupOn("#form7 > input"); + sendChar("1"); + await notifyMenuChanged(4); + assertAutocompleteItems("1", "12", "123", "1234"); + + input.maxLength = 3; + input = (await openPopupOn("#form7 > input")).input; + assertAutocompleteItems("1", "12", "123"); + + input.maxLength = 2; + input = (await openPopupOn("#form7 > input")).input; + assertAutocompleteItems("1", "12"); + + input.maxLength = 1; + input = (await openPopupOn("#form7 > input")).input; + assertAutocompleteItems("1"); + + input.maxLength = 0; + synthesizeKey("KEY_Escape"); + synthesizeKey("KEY_ArrowDown"); + await notifyMenuChanged(0); + assertAutocompleteItems(); +}); + +for (const formId of ["form8", "form9", "form10", "form11"]) { + add_named_task(formId, async () => { + const { input } = await openPopupOn(`#${formId} > input`); + assertAutocompleteItems("value"); + assertValueAfterKeys(input, ["KEY_ArrowDown", "KEY_Enter"], "value"); + }); +} + +add_task(async function form12() { + const { input } = await openPopupOn("#form12 > input"); + assertAutocompleteItems("42"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "42"); +}); + +add_task(async function form14() { + const { input } = await openPopupOn("#form14 > input", { expectPopup: false }); + await notifyMenuChanged(0); + // type=date with it's own control frame does not have a dropdown menu + assertAutocompleteItems(); + assertValueAfterKeys(input, [], ""); +}); + +add_task(async function form15() { + const { input } = await openPopupOn("#form15 > input", { expectPopup: false }); + await notifyMenuChanged(0); + // type=time with it's own control frame does not have a dropdown menu + assertAutocompleteItems(); + assertValueAfterKeys(input, [], ""); +}); + +add_task(async function form16() { + const { input } = await openPopupOn("#form16 > input", { expectPopup: false }); + await notifyMenuChanged(0); + // type=range does not have a dropdown menu + assertAutocompleteItems(); + // default (midway between minimum (0) and maximum (64)) - step + assertValueAfterKeys(input, [], "31"); +}); + +add_task(async function form17() { + const { input } = await openPopupOn("#form17 > input", { expectPopup: false }); + await notifyMenuChanged(0); + // type=color does not have a dropdown menu + assertAutocompleteItems(); + // default color value + assertValueAfterKeys(input, [], "#000000"); +}); + +add_task(async function form18() { + const { input } = await openPopupOn("#form18 > input"); + assertAutocompleteItems("2016-08"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "2016-08"); +}); + +add_task(async function form19() { + const { input } = await openPopupOn("#form19 > input"); + assertAutocompleteItems("2016-W32"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "2016-W32"); +}); + +add_task(async function form20() { + const { input } = await openPopupOn("#form20 > input", { expectPopup: false }); + await notifyMenuChanged(0); + // type=datetime-local with it's own control frame does not have a dropdown menu + assertAutocompleteItems(); + assertValueAfterKeys(input, [], ""); +}); + +add_task(async function input_event_fired() { + await addEntry("field1", "value1"); + const { input } = await openPopupOn("#form1 > input"); + + let beforeInputFired = false; + input.addEventListener("beforeinput", (e) => { + beforeInputFired = true; + ok(e instanceof InputEvent, "beforeinput event has InputEvent interface"); + ok(e.bubbles, "beforeinput event should bubble"); + is(e.cancelable, SpecialPowers.getBoolPref("dom.input_event.allow_to_cancel_set_user_input"), + "beforeinput event for insertReplacementText should be cancelable unless it's suppressed by the pref"); + is(e.inputType, "insertReplacementText", + "inputType of beforeinput event should be insertReplacementText"); + is(e.data, "value1", "data of beforeinput event should be value1"); + is(e.dataTransfer, null, "dataTransfer of beforeinput event should be null"); + is(e.getTargetRanges().length, 0, + "getTargetRanges() of beforeinput event should empty array"); + is(input.value, "", "input value should've not been modified yet at beforeinput event"); + }, { once: true }); + + let inputFired = false; + input.addEventListener("input", (e) => { + inputFired = true; + ok(e instanceof InputEvent, "input event has InputEvent interface"); + ok(e.bubbles, "input event should bubble"); + ok(!e.cancelable, "input event shouldn't be cancelable"); + is(e.inputType, "insertReplacementText", + "inputType of input event should be insertReplacementText"); + is(e.data, "value1","data of input event should be value1"); + is(e.dataTransfer, null, "dataTransfer of input event should be null"); + is(e.getTargetRanges().length, 0, + "getTargetRanges() of input event should empty array"); + is(input.value, "value1", "input value should've already been modified at input event"); + }, { once: true }); + + assertValueAfterKeys(input, "KEY_ArrowDown", ""); + assertValueAfterKeys(input, "KEY_Enter", "value1"); + ok(beforeInputFired, "beforeinput event should have been fired"); + ok(inputFired, "input event should have been fired"); +}); + +add_task(async function cancelling_beforeinput_cancels_autocompletion() { + const { input } = await openPopupOn("#form1 > input"); + await SpecialPowers.pushPrefEnv({ + set: [["dom.input_event.allow_to_cancel_set_user_input", true]], + }); + input.addEventListener("beforeinput", (e) => e.preventDefault(), { once: true }); + + let inputFired = false; + input.addEventListener("input", () => inputFired = true, { once: true }); + + assertValueAfterKeys(input, "KEY_ArrowDown", ""); + assertValueAfterKeys(input, "KEY_Enter", ""); + ok(!inputFired, "no input event when beforeinput is canceled"); + + await SpecialPowers.pushPrefEnv({ + clear: [["dom.input_event.allow_to_cancel_set_user_input"]], + }); +}); + +add_task(async function no_autocomplete_for_searchbar_history() { + await openPopupOn("#form13 > input", { expectPopup: false }); + await notifyMenuChanged(0); + assertAutocompleteItems(); +}); +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_form_autocomplete_validation_at_input_event.html b/toolkit/components/satchel/test/test_form_autocomplete_validation_at_input_event.html new file mode 100644 index 0000000000..7df6e97f27 --- /dev/null +++ b/toolkit/components/satchel/test/test_form_autocomplete_validation_at_input_event.html @@ -0,0 +1,83 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for validation has been done before "input" event</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <style> + input:invalid { + background-color: red; + } + </style> +</head> +<body> +<p id="display"></p> + +<div id="content"> + <form> + <input type="text" name="field1" pattern="[0-9]{4}"> + </form> +</div> + +<script> + +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "1234" }, + { op: "add", fieldname: "field1", value: "12345" }, + ]); +}); + +add_task(async function input_events() { + const { input } = await openPopupOn("input[name=field1]"); + synthesizeKey("KEY_Escape"); + + let inputFired = false; + info("Typing first character to open popup..."); + input.addEventListener("input", e => { + inputFired = true; + is(e.inputType, "insertText", "Typing '1' produces 'input' event with inputType='insertText'"); + is(input.validity.valid, false, "Typing '1' marks it as 'invalid'"); + is(input.matches(":invalid"), true, "Typing '1' causes matching with ':invalid' pseudo-class"); + }, { once: true, capture: true }); + synthesizeKey("1"); + ok(inputFired, "Typing '1' causes one 'input' event"); +}); + +add_task(async function input_events_for_valid_selection() { + const { input } = await openPopupOn("input[name=field1]"); + + let inputFired = false; + input.addEventListener("input", e => { + inputFired = true; + is(e.inputType, "insertReplacementText", "Selecting valid value causes an 'input' event with inputType='insertReplacementText'"); + is(input.validity.valid, true, "Selecting valid value marks it as 'valid'"); + is(input.matches(":invalid"), false, "Selecting valid value causes not matching with ':invalid' pseudo-class"); + }, { once: true, capture: true }); + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_Enter"); + ok(inputFired, "Selecting valid item causes an 'input' event"); +}); + +add_task(async function input_events_for_invalid_selection() { + const { input } = await openPopupOn("input[name=field1]"); + + let inputFired = false; + input.addEventListener("input", e => { + inputFired = true; + is(e.inputType, "insertReplacementText", "Selecting invalid value causes an 'input' event with inputType='insertReplacementText'"); + is(input.validity.valid, false, "Selecting invalid value marks it as 'invalid'"); + is(input.matches(":invalid"), true, "Selecting invalid value causes matching with ':invalid' pseudo-class"); + }, { once: true, capture: true }); + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_Enter"); + ok(inputFired, "Selecting invalid item should cause an 'input' event"); +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_form_autocomplete_with_list.html b/toolkit/components/satchel/test/test_form_autocomplete_with_list.html new file mode 100644 index 0000000000..b903af5246 --- /dev/null +++ b/toolkit/components/satchel/test/test_form_autocomplete_with_list.html @@ -0,0 +1,402 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Form History Autocomplete</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +Form History test: form field autocomplete +<p id="display"></p> + +<!-- we presumably can't hide the content for this test. --> +<div id="content"> + <datalist id="suggest"> + <option value="Google" label="PASS1">FAIL</option> + <option value="Reddit">PASS2</option> + <option value="final"></option> + </datalist> + + <!-- normal, basic form --> + <form id="form1"> + <input list="suggest" type="text" name="field1"> + <button type="submit">Submit</button> + </form> + + <!-- form with autocomplete=off on input --> + <form id="form3"> + <input list="suggest" type="text" name="field2" autocomplete="off"> + <button type="submit">Submit</button> + </form> + + <!-- form with autocomplete=off on form --> + <form id="form4" autocomplete="off"> + <input list="suggest" type="text" name="field2"> + <button type="submit">Submit</button> + </form> + + <!-- yet another normal, basic form, with 2 history entries --> + <form id="form5"> + <input list="suggest" type="text" name="field3"> + <button type="submit">Submit</button> + </form> + + <form id="show_datalist_for_text_inputs_only"> + <input list="suggest" type="button" popup="false" /> + <input list="suggest" type="checkbox" popup="false" /> + <input list="suggest" type="color" popup="false" /> + <input list="suggest" type="date" popup="false" /> + <input list="suggest" type="datetime-local" popup="false" /> + <input list="suggest" type="email" popup="true" /> + <input list="suggest" type="file" popup="false" /> + <input list="suggest" type="image" popup="false" /> + <input list="suggest" type="month" popup="true" /> + <input list="suggest" type="number" popup="false" /> + <input list="suggest" type="password" popup="true" /> + <input list="suggest" type="radio" popup="false" /> + <input list="suggest" type="range" popup="false" /> + <input list="suggest" type="reset" popup="false" /> + <input list="suggest" type="search" popup="true" /> + <input list="suggest" type="submit" popup="false" /> + <input list="suggest" type="tel" popup="true" /> + <input list="suggest" type="text" popup="true" /> + <input list="suggest" type="time" popup="false" /> + <input list="suggest" type="url" popup="true" /> + <input list="suggest" type="week" popup="true" /> + </form> +</div> + +<script> + +preventSubmitOnForms(); + +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "historyvalue" }, + { op: "add", fieldname: "field2", value: "othervalue" }, + { op: "add", fieldname: "field3", value: "history1" }, + { op: "add", fieldname: "field3", value: "history2" }, + ]); +}); + +add_task(async function no_changes_when_opening_popup(){ + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys(input, [], ""); +}); + +add_task(async function use_1st_entry() { + const { input } = await openPopupOn("#form1 > input"); + assertAutocompleteItems("historyvalue", "PASS1", "PASS2", "final"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "historyvalue"); +}); + +add_task(async function use_2nd_entry(){ + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "Google"); +}); + +add_task(async function use_3rd_entry(){ + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "Reddit"); +}); + +add_task(async function use_4th_entry(){ + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "final"); +}); + +add_task(async function delete_1st_entry(){ + const { input } = await openPopupOn("#form1 > input"); + assertValueAfterKeys(input, "KEY_ArrowDown", ""); + deleteSelectedAutocompleteItem(); + await notifyMenuChanged(3); + is(await countEntries("field1", "historyvalue"), 0, "item is absent"); +}); + +add_task(async function can_use_next_item_after_deletion(){ + const { input } = await openPopupOn("#form1 > input"); + assertAutocompleteItems("PASS1", "PASS2", "final"); + assertValueAfterKeys(input, ["KEY_ArrowDown", "KEY_Enter"], "Google"); +}); + +add_task(async function autocomplete_on_datalist_with_cached_results(){ + const { input } = await openPopupOn("#form1 > input"); + sendString("PAS"); + await notifyMenuChanged(2); + sendString("S1"); + await notifyMenuChanged(1); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "Google"); +}); + +add_task(async function fills_with_autocomplete_off_on_form(){ + const { input } = await openPopupOn("#form4 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "Google"); + assertAutocompleteItems("PASS1", "PASS2", "final"); +}); + +add_task(async function use_1st_entry_with_autocomplete_off_on_form(){ + const { input } = await openPopupOn("#form4 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "Google"); +}); + +add_task(async function use_2nd_entry_with_autocomplete_off_on_form(){ + const { input } = await openPopupOn("#form4 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "Reddit"); +}); + +add_task(async function use_3rd_entry_with_autocomplete_off_on_form(){ + const { input } = await openPopupOn("#form4 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "final"); +}); + +add_task(async function fills_with_autocomplete_off_on_input(){ + const { input } = await openPopupOn("#form3 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "Google"); + assertAutocompleteItems("PASS1", "PASS2", "final"); +}); + +add_task(async function use_1st_entry_with_autocomplete_off_on_input(){ + const { input } = await openPopupOn("#form3 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "Google"); +}); + +add_task(async function use_2nd_entry_with_autocomplete_off_on_input(){ + const { input } = await openPopupOn("#form3 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "Reddit"); +}); + +add_task(async function use_3rd_entry_with_autocomplete_off_on_input(){ + const { input } = await openPopupOn("#form3 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "final"); +}); + +add_task(async function remove_item_from_datalist(){ + // When there is an update of the list, the selection is lost so we need to + // go down like if we were at the beginning of the list again. + // + // Removing the second element while on the first then going down and + // push enter. Value should be one from the third suggesion. + const { input } = await openPopupOn("#form3 > input"); + synthesizeKey("KEY_ArrowDown"); + const datalist = document.getElementById("suggest"); + const toRemove = datalist.children[1]; + datalist.removeChild(toRemove); + + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "final"); + + // Restore the element. + datalist.insertBefore(toRemove, datalist.children[1]); +}); + +add_task(async function add_item_to_datalist(){ + const { input } = await openPopupOn("#form3 > input"); + const datalist = document.getElementById("suggest"); + + // Adding an attribute after the first one while on the first then going + // down and push enter. Value should be the on from the new suggestion. + synthesizeKey("KEY_ArrowDown"); + datalist.insertBefore(new Option("New value"), datalist.children[1]); + await notifyMenuChanged(4); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "New value"); +}); + +add_task(async function change_datalist_option_value(){ + const datalist = document.getElementById("suggest"); + + // Remove the element. + datalist.removeChild(datalist.children[1]); + await notifyMenuChanged(0); + + // Change the first element value attribute. + const prevValue = datalist.children[0].value; + datalist.children[0].value = "foo"; + + const { input } = await openPopupOn("#form3 > input"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "foo"); + + datalist.children[0].value = prevValue; + await notifyMenuChanged(0); +}); + +add_task(async function change_datalist_option_text_content(){ + const datalist = document.getElementById("suggest"); + const prevValue = datalist.children[0].getAttribute("value"); + datalist.children[0].removeAttribute("value"); + datalist.children[0].textContent = "foobar"; + const { input } = await openPopupOn("#form3 > input"); + + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_Enter"], + "foobar"); + + datalist.children[0].setAttribute("value", prevValue); + await notifyMenuChanged(0); +}); + +add_task(async function filters_with_1st_letter(){ + const { input } = await openPopupOn("#form3 > input"); + sendString("f"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "final"); +}); + +add_task(async function filters_with_letter_in_the_middle(){ + const { input } = await openPopupOn("#form3 > input"); + sendString("in"); + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown", "KEY_Enter"], + "final"); +}); + +add_task(async function input_events(){ + const { input } = await openPopupOn("#form3 > input"); + + let beforeInputFired = false; + input.addEventListener("beforeinput", (event) => { + beforeInputFired = true; + ok(event instanceof InputEvent, "beforeinput event has InputEvent interface"); + ok(event.bubbles, "beforeinput event should bubble"); + is( + event.cancelable, + SpecialPowers.getBoolPref("dom.input_event.allow_to_cancel_set_user_input"), + "beforeinput event for insertReplacementText should be cancelable if not suppressed"); + is(event.inputType, "insertReplacementText", "inputType of beforeinput event should be insertReplacementText"); + is(event.data, "Google", "data of beforeinput event should be Google"); + is(event.dataTransfer, null, "dataTransfer of beforeinput event should be null"); + is(event.getTargetRanges().length, 0, "getTargetRanges() of beforeinput event should be empty array"); + }, { once: true }); + + let inputFired = false; + input.addEventListener("input", function(event) { + inputFired = true; + ok(event instanceof InputEvent, + "input event should be dispatched with InputEvent interface"); + ok(event.bubbles, "input event should bubble"); + ok(!event.cancelable, "input event should be cancelable"); + is(event.inputType, "insertReplacementText", "inputType of input event should be insertReplacementText"); + is(event.data, "Google", "data of input event should be Google"); + is(event.dataTransfer, null, "dataTransfer of input event should be null"); + is(event.getTargetRanges().length, 0, "getTargetRanges() of input event should be empty array"); + }, { once: true }); + + assertValueAfterKeys(input, ["KEY_ArrowDown", "KEY_Enter"], "Google"); + ok(beforeInputFired, "beforeinput event should've been fired"); + ok(inputFired, "input event should've been fired"); +}); + +add_task(async function cancelled_beforeinput_event(){ + const { input } = await openPopupOn("#form3 > input"); + await SpecialPowers.pushPrefEnv({ + set: [["dom.input_event.allow_to_cancel_set_user_input", true]], + }); + input.addEventListener("beforeinput", e => e.preventDefault(), { once: true }); + let inputFired = false; + input.addEventListener("input", () => inputFired = true, { once: true }); + + assertValueAfterKeys(input, "KEY_ArrowDown", ""); + assertValueAfterKeys(input, "KEY_Enter", ""); + ok(!inputFired, "no input event when beforeinput is canceled"); + + input.blur(); + await SpecialPowers.pushPrefEnv({ + clear: [["dom.input_event.allow_to_cancel_set_user_input"]], + }); +}); + +add_task(async function attempt_to_delete_datalist_entries(){ + const { input } = await openPopupOn("#form5 > input"); + assertAutocompleteItems("history1", "history2", "PASS1", "PASS2", "final"); + + assertValueAfterKeys( + input, + ["KEY_ArrowDown", "KEY_ArrowDown", "KEY_ArrowDown"], + ""); + + deleteSelectedAutocompleteItem(); + synthesizeKey("KEY_ArrowUp"); + deleteSelectedAutocompleteItem(); + await notifyMenuChanged(4); + assertAutocompleteItems("history1", "PASS1", "PASS2", "final"); + // Delete the second entry, that is the 1st entry of datalist. + // This has no effect. + deleteSelectedAutocompleteItem(); + + // Delete the first entry, that is the 1nd entry of history. + synthesizeKey("KEY_ArrowUp"); + deleteSelectedAutocompleteItem(); + await notifyMenuChanged(3); + + assertAutocompleteItems("PASS1", "PASS2", "final"); + assertValueAfterKeys(input, "KEY_Enter", "Google"); +}); + +for (const input of document + .querySelectorAll("form#show_datalist_for_text_inputs_only input")) { + const expectPopup = input.getAttribute("popup") == "true"; + add_named_task( + `datalist_is_${expectPopup ? "" : "not_"}shown_for_${input.type}_input`, + async () => { + input.focus(); + is(document.activeElement, input, "Input is focused."); + await (expectPopup ? popupByArrowDown() : noPopupByArrowDown()); + } + ); +} +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_form_submission.html b/toolkit/components/satchel/test/test_form_submission.html new file mode 100644 index 0000000000..d1c0542609 --- /dev/null +++ b/toolkit/components/satchel/test/test_form_submission.html @@ -0,0 +1,598 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Satchel Test for Form Submisstion</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<p id="display"></p> +<iframe id="iframe" src="https://example.com/tests/toolkit/components/satchel/test/subtst_form_submission_1.html"></iframe> +<div id="content" style="display: none"> + + <!-- ===== Things that should not be saved. ===== --> + + <form purpose="nothing stored for input autocomplete=off (case-insensitive token)" + id="form1"> + <input type="text" name="test1" autocomplete=" oFf "> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for form autocomplete=off" + id="form2" autocomplete="oFf"> + <input type="text" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for type=hidden" + id="form3"> + <input type="hidden" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for type=checkbox" + id="form4"> + <input type="checkbox" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for empty values." + id="form5"> + <input type="text" name="test1" value="originalValue"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for unchanged values when set by a script." + id="form6"> + <input type="text" name="test1" value="dontSaveThis"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for unchanged values. (.value not touched)" + id="form7"> + <input type="text" name="test1" value="dontSaveThis"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for no field name or ID" + id="form8"> + <input type="text"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for nothing to save" + id="form9"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input with name too long (300 chars.)" + id="form10"> + <input type="text" name="12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input with value too long (300 chars.)" + id="form11"> + <input type="text" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input with value of one space (which should be trimmed)" + id="form12"> + <input type="text" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for password field" + id="form13"> + <input type="password" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for password field (type toggled to password and back after pageload)" + id="form14"> + <input type="text" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input with sensitive data (16 digit credit card number)" + id="form15"> + <script type="text/javascript"> + let form = document.getElementById("form15"); + for (let i = 0; i < 10; i++) { + const input = form.appendChild(document.createElement("input")); + input.type = "text"; + input.name = "test" + (i + 1); + } + </script> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input with sensitive data (15 digit credit card number)" + id="form16"> + <script type="text/javascript"> + form = document.getElementById("form16"); + for (let i = 0; i < 10; i++) { + const input = form.appendChild(document.createElement("input")); + input.type = "text"; + input.name = "test" + (i + 1); + } + </script> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input with sensitive data (19 digit credit card number)" + id="form17"> + <input type="text" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input with sensitive data (16 digit hyphenated credit card number)" + id="form18"> + <input type="text" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input with sensitive data (15 digit whitespace-separated credit card number)" + id="form19"> + <input type="text" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for the invalid form" + id="form20"> + <input type='email' name='test1'> + <button type='submit'>Submit</button> + </form> + + <form purpose="nothing stored for the invalid form" + id="form21"> + <input type='email' value='foo'> + <input type='text' name='test1'> + <button type='submit'>Submit</button> + </form> + + <form purpose="nothing stored for the input with name 'searchbar-history'" + id="form22"> + <input type='text' name='searchbar-history'> + <button type='submit'>Submit</button> + </form> + + <form purpose="nothing stored for input autocomplete=cc-csc (case-insensitive token)" + id="form23"> + <input type="text" name="test1" autocomplete=" cc-CSC "> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input autocomplete=new-password (case-insensitive token)" + id="form24"> + <input type="text" name="test1" autocomplete=" NEW-password "> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored after user input followed by reset button click" + id="form25"> + <input type="text" name="test1" defaultValue="do not save me" value="do not save me either"> + <button type="submit">Submit</button> + <button type="reset">Reset</button> + </form> + + <form purpose="nothing stored after user input changed by a script" + id="form26"> + <input type="text" name="test1" defaultValue="do not save me" value="do not save me either"> + <button type="submit">Submit</button> + </form> + + <form purpose="nothing stored for input autocomplete=one-time-code" + id="form27"> + <input type="text" name="test1" autocomplete="one-time-code"> + <button type="submit">Submit</button> + </form> + + <!-- ===== Things that should be saved ===== --> + + <!-- Form 100 is submitted into an iframe, not declared here. --> + + <form purpose="saved input with no default value" + id="form101"> + <input type="text" name="test1"> + <button type="submit">Submit</button> + </form> + + <form purpose="saved input with a default value" + id="form102"> + <input type="text" name="test2" value="originalValue"> + <button type="submit">Submit</button> + </form> + + <form purpose="saved input with id and not name" + id="form103"> + <input type="text" name="test3"> + <button type="submit">Submit</button> + </form> + + <form purpose="saved input with leading and trailing space" + id="form104"> + <input type="text" name="test4"> + <button type="submit">Submit</button> + </form> + + <form purpose="saved input with leading and trailing whitespace" + id="form105"> + <input type="text" name="test5"> + <button type="submit">Submit</button> + </form> + + <form purpose="saved input that looks like sensitive data but doesn't satisfy the requirements (incorrect length)" + id="form106"> + <input type="text" name="test6"> + <button type="submit">Submit</button> + </form> + + <form purpose="input that looks like sensitive data but doesn't satisfy the requirements (Luhn check fails for 16 chars)" + id="form107"> + <script type="text/javascript"> + form = document.getElementById("form107"); + for (let i = 0; i < 10; i++) { + let input = form.appendChild(document.createElement("input")); + input.type = "text"; + input.name = "test7_" + (i + 1); + } + </script> + <button type="submit">Submit</button> + </form> + + <form purpose="input that looks like sensitive data but doesn't satisfy the requirements (Luhn check fails for 15 chars)" + id="form108"> + <script type="text/javascript"> + form = document.getElementById("form108"); + for (let i = 0; i != 10; i++) { + let input = form.appendChild(document.createElement("input")); + input.type = "text"; + input.name = "test8_" + (i + 1); + } + </script> + <button type="submit">Submit</button> + </form> + + <form purpose="form data submitted through HTTPS, when browser.formfill.saveHttpsForms is true" + id="form109" action="https://www.example.com/"> + <input type="text" name="test9"> + <button type="submit">Submit</button> + </form> + +</div> +<script> +/* eslint-disable complexity */ + +const ccNumbers = { + valid15: [ + "930771457288760", "474915027480942", + "924894781317325", "714816113937185", + "790466087343106", "474320195408363", + "219211148122351", "633038472250799", + "354236732906484", "095347810189325", + ], + valid16: [ + "3091269135815020", "5471839082338112", + "0580828863575793", "5015290610002932", + "9465714503078607", "4302068493801686", + "2721398408985465", "6160334316984331", + "8643619970075142", "0218246069710785", + ], + invalid15: [ + "526931005800649", "724952425140686", + "379761391174135", "030551436468583", + "947377014076746", "254848023655752", + "226871580283345", "708025346034339", + "917585839076788", "918632588027666", + ], + invalid16: [ + "9946177098017064", "4081194386488872", + "3095975979578034", "3662215692222536", + "6723210018630429", "4411962856225025", + "8276996369036686", "4449796938248871", + "3350852696538147", "5011802870046957", + ], +}; + +function setUserInput(formNumber, inputName, value) { + const input = SpecialPowers.wrap(getFormElementByName(formNumber, inputName)); + input.setUserInput(value); +} + +function setScriptInput(formNumber, inputName, value) { + getFormElementByName(formNumber, inputName).value = value; +} + +function checkSubmitDoesNotSave(formNumber, inputName, value) { + return new Promise((resolve, reject) => { + const form = document.getElementById("form" + formNumber); + form.addEventListener("submit", async e => { + const historyEntriesCount = await countEntries(null, null); + ok(!historyEntriesCount, form.getAttribute("purpose")); + resolve(); + }, { once: true }); + + getFormSubmitButton(formNumber).click(); + }); +} + +function checkInvalidFirstInputDoesNotSave(formNumber, value) { + return new Promise((resolve, reject) => { + const form = document.getElementById("form" + formNumber); + const input = form.querySelector("input"); + input.addEventListener("invalid", async e => { + const historyEntriesCount = await countEntries(null, null); + ok(!historyEntriesCount, form.getAttribute("purpose")); + resolve(); + }, { once: true}); + + getFormSubmitButton(formNumber).click(); + }); +} + +async function checkSubmitSaves(formNumber, inputName, interactiveValue, savedValue, storageEventData = "formhistory-add") { + setUserInput(formNumber, inputName, interactiveValue); + const form = document.getElementById("form" + formNumber); + const storageEventPromise = promiseNextStorageEvent(); + + getFormSubmitButton(formNumber).click(); + + const storageEvent = await storageEventPromise; + isDeeply(storageEvent, { + subject: null, + topic: "satchel-storage-changed", + data: storageEventData + }, "expected storage event"); + + const historyEntriesCount = await countEntries(inputName, savedValue); + is(historyEntriesCount, 1, form.getAttribute("purpose")); +} + +preventSubmitOnForms(); + +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + ]); + const historyEntriesCount = await countEntries(null, null); + ok(!historyEntriesCount, "checking for initially empty storage"); +}); + +add_task(async function form1_does_not_save() { + setUserInput(1, "test1", "dontSaveThis"); + await checkSubmitDoesNotSave(1); +}); + +add_task(async function form2_does_not_save() { + setUserInput(2, "test1", "dontSaveThis"); + await checkSubmitDoesNotSave(2); +}); + +add_task(async function form3_does_not_save() { + setUserInput(3, "test1", "dontSaveThis"); + await checkSubmitDoesNotSave(3); +}); + +add_task(async function form4_does_not_save() { + setUserInput(4, "test1", "dontSaveThis"); + await checkSubmitDoesNotSave(4); +}); + +add_task(async function form5_does_not_save() { + setUserInput(5, "test1", ""); + await checkSubmitDoesNotSave(5); +}); + +add_task(async function form6_does_not_save() { + setScriptInput(6, "test1", "dontSaveThis"); + await checkSubmitDoesNotSave(6); +}); + +add_task(async function form7_does_not_save() { + // Form 7 deliberately left untouched. + await checkSubmitDoesNotSave(7); +}); + +add_task(async function form8_does_not_save() { + // Form 8 has an input with no name or input attribute. + const input = SpecialPowers.wrap(document.getElementById("form8").elements[0]); + is(input.type, "text", "checking we got unidentified input"); + input.setUserInput("dontSaveThis"); + await checkSubmitDoesNotSave(8); +}); + +add_task(async function form9_does_not_save() { + // Form 9 has nothing to modify. + await checkSubmitDoesNotSave(9); +}); + +add_task(async function form10_does_not_save() { + setUserInput(10, + "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456" + + "789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456" + + "789012345678901234567890123456789012345678901234567890123456789012345678901234567890", + "dontSaveThis"); + await checkSubmitDoesNotSave(10); +}); + +add_task(async function form11_does_not_save() { + setUserInput(11, "test1", + "123456789012345678901234567890123456789012345678901234567890123456789" + + "012345678901234567890123456789012345678901234567890123456789012345678" + + "901234567890123456789012345678901234567890123456789012345678901234567" + + "89012345678901234567890123456789012345678901234567890"); + await checkSubmitDoesNotSave(11); +}); + +add_task(async function form12_does_not_save() { + setUserInput(12, "test1", " "); + await checkSubmitDoesNotSave(12); +}); + +add_task(async function form13_does_not_save() { + setUserInput(13, "test1", "dontSaveThis"); + await checkSubmitDoesNotSave(13); +}); + +add_task(async function form14_does_not_save() { + const input = SpecialPowers.wrap(document.getElementById("form14").elements[0]); + input.type = "password"; + input.setUserInput("dontSaveThis"); + // Set it back to type=text to simulate a password visibility toggle. + input.type = "text"; + await checkSubmitDoesNotSave(14); +}); + +add_task(async function form15_does_not_save() { + const testData = ccNumbers.valid16; + for (let i = 0; i < testData.length; i++) { + setUserInput(15, "test" + (i + 1), testData[i]); + } + await checkSubmitDoesNotSave(15); +}); + +add_task(async function form16_does_not_save() { + const testData = ccNumbers.valid15; + for (let i = 0; i < testData.length; i++) { + setUserInput(16, "test" + (i + 1), testData[i]); + } + await checkSubmitDoesNotSave(16); +}); + +add_task(async function form17_does_not_save() { + setUserInput(17, "test1", "6799990100000000019"); + await checkSubmitDoesNotSave(17); +}); + +add_task(async function form18_does_not_save() { + setUserInput(18, "test1", "0000-0000-0080-4609"); + await checkSubmitDoesNotSave(18); +}); + +add_task(async function form19_does_not_save() { + setUserInput(19, "test1", "0000 0000 0222 331"); + await checkSubmitDoesNotSave(19); +}); + +add_task(async function form20_does_not_save() { + setUserInput(20, "test1", "dontSaveThis"); + await checkInvalidFirstInputDoesNotSave(20, "invalid"); +}); + +add_task(async function form21_does_not_save() { + setUserInput(21, "test1", "dontSaveThis"); + await checkInvalidFirstInputDoesNotSave(21, "invalid"); +}); + +add_task(async function form22_does_not_save() { + setUserInput(22, "searchbar-history", "dontSaveThis"); + await checkSubmitDoesNotSave(22); +}); + +add_task(async function form23_does_not_save() { + setUserInput(23, "test1", "987"); + await checkSubmitDoesNotSave(23); +}); + +add_task(async function form24_does_not_save() { + setUserInput(24, "test1", "s3cr3t"); + await checkSubmitDoesNotSave(24); +}); + +add_task(async function form25_does_not_save() { + setUserInput(25, "test1", "s3cr3t"); + document.querySelector("form[id=form25] button[type=reset]").click(); + await checkSubmitDoesNotSave(25); +}); + +add_task(async function form26_does_not_save() { + setUserInput(26, "test1", "s3cr3t"); + document.querySelector("form[id=form26] input[name=test1]").value = "script changed me"; + await checkSubmitDoesNotSave(26); +}); + +add_task(async function form27_does_not_save() { + setUserInput(27, "test1", "123456"); + await checkSubmitDoesNotSave(27); +}); + +add_task(async function form100_saves() { + const iframe = SpecialPowers.wrap(document.getElementById("iframe")); + const browsingContext = SpecialPowers.unwrap(iframe.browsingContext); + const storageEventPromise = promiseNextStorageEvent(); + await SpecialPowers.spawn(browsingContext, [], () => { + /* eslint-disable no-undef */ + const input = SpecialPowers.wrap(content.document.getElementById("subtest2")); + input.setUserInput("subtestValue"); + // This will prevent endless loop of tests + for (const form of content.document.forms) { + /* eslint-disable-next-line mozilla/balanced-listeners */ + form.addEventListener("submit", e => e.preventDefault()); + } + content.document.querySelector("button").click(); + /* eslint-enable no-undef */ + }); + + const storageEvent = await storageEventPromise; + isDeeply(storageEvent, { + subject: null, + topic: "satchel-storage-changed", + data: "formhistory-add" + }, "expected storage event"); + + const historyEntriesCount = await countEntries("subtest2", "subtestValue"); + is(historyEntriesCount, 1, "saved from iframe"); +}); + +add_task(async function form101_saves() { + await checkSubmitSaves(101, "test1", "savedValue", "savedValue"); +}); + +add_task(async function form102_saves() { + await checkSubmitSaves(102, "test2", "savedValue", "savedValue"); +}); + +add_task(async function form103_saves() { + await checkSubmitSaves(103, "test3", "savedValue", "savedValue"); +}); + +add_task(async function form104_saves() { + await checkSubmitSaves(104, "test4", " trimTrailingAndLeadingSpace ", "trimTrailingAndLeadingSpace"); +}); + +add_task(async function form105_saves() { + await checkSubmitSaves(105, "test5", "\t trimTrailingAndLeadingWhitespace\t ", "trimTrailingAndLeadingWhitespace"); +}); + +add_task(async function form106_saves() { + // passes luhn but too long + await checkSubmitSaves(106, "test6", "55555555555544445553", "55555555555544445553"); +}); + +add_task(async function form107_saves() { + for (let i = 0; i != ccNumbers.invalid16.length; i++) { + const name = "test7_" + (i + 1); + const value = ccNumbers.invalid16[i]; + await checkSubmitSaves(107, name, value, value, i != 0 ? "formhistory-update" : "formhistory-add"); + } +}); + +add_task(async function form108_saves() { + for (let i = 0; i != ccNumbers.invalid15.length; i++) { + const name = "test8_" + (i + 1); + const value = ccNumbers.invalid15[i]; + await checkSubmitSaves(108, name, value, value, i != 0 ? "formhistory-update" : "formhistory-add"); + } +}); + +add_task(async function form109_saves() { + setUserInput(109, "test9", "savedValue"); + await checkSubmitSaves(109, "test9", "savedValue", "savedValue"); +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_history_datalist_duplicates.html b/toolkit/components/satchel/test/test_history_datalist_duplicates.html new file mode 100644 index 0000000000..395405396a --- /dev/null +++ b/toolkit/components/satchel/test/test_history_datalist_duplicates.html @@ -0,0 +1,55 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Form History / DataList Duplicate Autocomplete Entries: Bug 1263588</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<div id="content"> + + <!-- normal, basic form --> + <form id="form1" onsubmit="return false;"> + <input list="suggest" type="text" name="field1" id="field1"> + <button type="submit">Submit</button> + <datalist id="suggest"> + <option value="Mozilla"> + <option value="Firefox"> + <option value="Relay is awesome"> + </datalist> + </form> + +</div> + +<script> + +add_setup(async () => { + await updateFormHistory([ + { op: "add", fieldname: "field1", value: "Mozilla" }, + { op: "add", fieldname: "field1", value: "Firefox" }, + { op: "add", fieldname: "field1", value: "Relay" }, + ]); +}); + +add_task(async function test_all_entries_are_unique_and_ordered() { + await triggerAutofillAndCheckEntriesValue("",["Relay", "Mozilla", "Firefox", "Relay is awesome"]); +}); + +add_task(async function test_duplicate_entries_are_shown_once() { + await triggerAutofillAndCheckEntriesValue("f", ["Firefox"]); +}); + +add_task(async function test_non_duplicate_entries_are_shown_once() { + await triggerAutofillAndCheckEntriesValue("rel",["Relay", "Relay is awesome"]); +}); + +async function triggerAutofillAndCheckEntriesValue(inputValue, expectedValues) { + await openPopupOn("#form1 > input", { inputValue }); + isDeeply(getMenuEntries(), expectedValues, "Matching deduplicated autocomplete list entries with expected values."); +} + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_input_valid_state_with_autocomplete.html b/toolkit/components/satchel/test/test_input_valid_state_with_autocomplete.html new file mode 100644 index 0000000000..196ca59765 --- /dev/null +++ b/toolkit/components/satchel/test/test_input_valid_state_with_autocomplete.html @@ -0,0 +1,125 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <title>Test for valid state with autocomplete</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> + <style> + input:invalid { + border: red 1px solid; + } + </style> +</head> +<body> +<p id="display"></p> + +<div id="content"> + <form id="form1"> + <input type="email" name="field1"> + <button type="submit">Submit</button> + </form> +</div> + +<script> + +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "email@example.com" }, + { op: "add", fieldname: "field1", value: "email@example.com." }, + ]); +}); + +add_task(async function datalist_with_caching() { + const kSetUserInputCancelable = SpecialPowers.getBoolPref("dom.input_event.allow_to_cancel_set_user_input"); + const { input } = await openPopupOn("input[name=field1]"); + synthesizeKey("KEY_Escape"); + + let beforeInputFired = false; + input.addEventListener("beforeinput", e => { + beforeInputFired = true; + ok(e.cancelable, "'beforeinput' event for 'insertText' is cancelable"); + is(e.inputType, "insertText", "inputType of 'beforeinput' event is 'insertText'"); + ok(input.validity.valid, "Valid immediately before inserting a character"); + ok(!input.matches(":invalid"), + "Shouldn't match ':invalid' immediately before inserting a character"); + }, { once: true }); + + let inputFired = false; + input.addEventListener("input", e => { + inputFired = true; + is(e.inputType, "insertText", "inputType of 'input' event should be 'insertText'"); + ok(!input.validity.valid, "Invalid immediately after inserting a character"); + ok(input.matches(":invalid"), + "Should match ':invalid' immediately after inserting a character"); + }, { once: true }); + synthesizeKey("e"); + ok(beforeInputFired, "'beforeinput' event fired at typing 'e'"); + ok(inputFired, "'input' event fired at typing 'e'"); + + await notifyMenuChanged(2); + inputFired = false; + beforeInputFired = false; + input.addEventListener("beforeinput", e => { + beforeInputFired = true; + is(e.cancelable, kSetUserInputCancelable, + "'beforeinput' event for 'insertReplacementText' is cancelable unless it's suppressed by the pref"); + is(e.inputType, "insertReplacementText", + "inputType of 'beforeinput' event is 'insertReplacementText'"); + ok(!input.validity.valid, + "Invalid immediately before selecting valid item in autocomplete list"); + ok(input.matches(":invalid"), + "Matches ':invalid' immediately before selecting valid item in autocomplete list"); + }, { once: true }); + input.addEventListener("input", e => { + inputFired = true; + is(e.inputType, "insertReplacementText", + "inputType of 'input' event is 'insertReplacementText'"); + ok(input.validity.valid, + "Valid immediately after selecting valid item in autocomplete list"); + ok(!input.matches(":invalid"), + "Shouldn't match ':invalid' immediately after selecting valid item in autocomplete list"); + }, { once: true }); + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_Enter"); // Select valid item + ok(beforeInputFired, "'beforeinput' event should have been fired at selecting valid item"); + ok(inputFired, "'input' event should have been fired at selecting valid item"); + + inputFired = false; + beforeInputFired = false; + synthesizeKey("KEY_Backspace"); + await notifyMenuChanged(2); + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_ArrowDown"); + input.addEventListener("beforeinput", e => { + ok(!beforeInputFired, '"input" event should be fired only once at typing'); + beforeInputFired = true; + is(e.cancelable, kSetUserInputCancelable, + `"beforeinput" event for "insertReplacementText" is cancelable unless it's suppressed by the pref`); + is(e.inputType, "insertReplacementText", + "inputType of 'beforeinput' event is 'insertReplacementText'"); + ok(input.validity.valid, + "Valid immediately before selecting invalid item in autocomplete list"); + ok(!input.matches(":invalid"), + "Shouldn't match ':invalid' immediately after selecting invalid item in autocomplete list"); + }, { once: true }); + input.addEventListener("input", (event) => { + ok(!inputFired, '"input" event is fired only once at typing'); + inputFired = true; + is(event.inputType, "insertReplacementText", + "inputType of 'input' event is 'insertReplacementText'"); + ok(!input.validity.valid, + "Invalid immediately after selecting invalid item in autocomplete list"); + ok(input.matches(":invalid"), + "Matches ':invalid' immediately after selecting invalid item in autocomplete list"); + }, { once: true }); + synthesizeKey("KEY_Enter"); // Select invalid item + ok(beforeInputFired, "'beforeinput' event should have been fired at selecting invalid item"); + ok(inputFired, "'input' event should have been fired at selecting invalid item"); +}); + +</script> +</body> diff --git a/toolkit/components/satchel/test/test_password_autocomplete.html b/toolkit/components/satchel/test/test_password_autocomplete.html new file mode 100644 index 0000000000..d24f556d9e --- /dev/null +++ b/toolkit/components/satchel/test/test_password_autocomplete.html @@ -0,0 +1,89 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for form history on type=password</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> + Test for form history on type=password + (based on test_bug_511615.html) +<p id="display"></p> + +<!-- we presumably can't hide the content for this test. --> +<div id="content"> + <datalist id="datalist1"> + <option>value10</option> + <option>value11</option> + <option>value12</option> + </datalist> + <form id="form1" onsubmit="return false;"> + <!-- Don't set the type to password until rememberSignons is false since we + want to test when rememberSignons is false. --> + <input type="to-be-password" name="field1" list="datalist1"> + <button type="submit">Submit</button> + </form> + <!-- Same as form1 but with an insecure HTTP action --> + <form id="form2" onsubmit="return false;" action="http://mochi.test/"> + <input type="to-be-password" name="field1" list="datalist1"> + <button type="submit">Submit</button> + </form> +</div> + +<script> + +add_setup(async () => { + await SpecialPowers.pushPrefEnv({set: [["signon.rememberSignons", false]]}); + + is(window.location.protocol, "https:", "This test must run on HTTPS"); + + // Now that rememberSignons is false, create the password fields. + document.querySelector("#form1 > input").type = "password"; + document.querySelector("#form2 > input").type = "password"; + + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "value1" }, + { op: "add", fieldname: "field1", value: "value2" }, + { op: "add", fieldname: "field1", value: "value3" }, + { op: "add", fieldname: "field1", value: "value4" }, + { op: "add", fieldname: "field1", value: "value5" }, + { op: "add", fieldname: "field1", value: "value6" }, + { op: "add", fieldname: "field1", value: "value7" }, + { op: "add", fieldname: "field1", value: "value8" }, + { op: "add", fieldname: "field1", value: "value9" }, + ]); +}); + +add_task(async function test_secure_noFormHistoryOrWarning() { + const input = document.querySelector("#form1 input"); + + // The autocomplete popup should not open under any circumstances on + // type=password with password manager disabled. + for (let triggerFn of [ + () => input.focus(), + () => input.click(), + () => synthesizeKey("KEY_ArrowDown"), + () => synthesizeKey("KEY_PageDown"), + () => synthesizeKey("KEY_Enter"), + () => sendString("v "), + () => synthesizeKey("KEY_Backspace"), + ]) { + info("Testing: " + triggerFn.toString()); + // We must wait for the entire timeout for each individual test, because the + // next event in the list might prevent the popup from opening. + await noPopupBy(triggerFn); + } +}); + +add_task(async function test_insecure_focusWarning() { + // Form 2 has an insecure action so should show the warning even if password manager is disabled. + await openPopupOn("#form2 > input"); + ok(getMenuEntries()[0].includes("Logins entered here could be compromised"), + "Check warning is first"); +}); +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_popup_direction.html b/toolkit/components/satchel/test/test_popup_direction.html new file mode 100644 index 0000000000..6b2fa010d6 --- /dev/null +++ b/toolkit/components/satchel/test/test_popup_direction.html @@ -0,0 +1,44 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Popup Direction</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +Test for Popup Direction +<p id="display"></p> + +<!-- we presumably can't hide the content for this test. --> +<div id="content"> + <!-- normal, basic form --> + <form id="form1" onsubmit="return false;"> + <input type="text" name="field1"> + <button type="submit">Submit</button> + </form> +</div> + +<script> + +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "value1" }, + { op: "add", fieldname: "field1", value: "value2" }, + ]); +}); + +add_task(async function test_popup_direction() { + for (const direction of ["ltr", "rtl"]) { + document.getElementById("content").style.direction = direction; + await openPopupOn("#form1 > input"); + const popupState = await getPopupState(); + is(popupState.direction, direction, "Direction should match."); + } +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_popup_enter_event.html b/toolkit/components/satchel/test/test_popup_enter_event.html new file mode 100644 index 0000000000..6150a8a57a --- /dev/null +++ b/toolkit/components/satchel/test/test_popup_enter_event.html @@ -0,0 +1,70 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <title>Test for events while the form history popup is open</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +Form History test: Test for events while the form history popup is open +<p id="display"></p> + +<div id="content"> + <form id="form1"> + <input type="text" name="field1"> + <button type="submit">Submit</button> + </form> +</div> + +<script> + +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "value1" }, + ]); +}); + +add_task(async function popupEnterEvent() { + const form = document.querySelector("#form1"); + const input = form.querySelector("input"); + const expectedValue = "value1"; + + function handleEnter(e) { + if (e.keyCode != KeyEvent.DOM_VK_RETURN) { + return; + } + + info("RETURN received for phase: " + e.eventPhase); + if (input.value == expectedValue) { + ok(true, "RETURN should be received when the popup is closed"); + is(input.value, expectedValue, "Check input value when enter is pressed the 2nd time"); + info("form should submit with the default handler"); + } else { + ok(false, "RETURN keypress shouldn't have been received when a popup item is selected"); + } + } + + const submitTested = new Promise(resolve => { + SpecialPowers.addSystemEventListener(input, "keypress", handleEnter, true); + form.addEventListener("submit", e => { + e.preventDefault(); + is(input.value, expectedValue, "Check input value in the submit handler"); + SpecialPowers.removeSystemEventListener(input, "keypress", handleEnter, true); + resolve(); + }, { once: true }); + }); + + await openPopupOn(input, { inputValue: "value" }); + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_Enter"); // select the first entry in the popup + synthesizeKey("KEY_Enter"); // try to submit the form with the filled value + await submitTested; +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/test_submit_on_keydown_enter.html b/toolkit/components/satchel/test/test_submit_on_keydown_enter.html new file mode 100644 index 0000000000..f5879a2b5e --- /dev/null +++ b/toolkit/components/satchel/test/test_submit_on_keydown_enter.html @@ -0,0 +1,108 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <title>Test for events while the form history popup is open</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="satchel_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +Form History test: Test for keydown handler submitting the form +<p id="display"></p> + +<div id="content"> + <form id="form1"> + <input type="text" name="field1"> + <button type="submit">Submit</button> + </form> +</div> + +<script> + +add_setup(async () => { + await updateFormHistory([ + { op: "remove" }, + { op: "add", fieldname: "field1", value: "value1" }, + ]); +}); + +add_task(async function submitOnKeydownEnter() { + const form = document.querySelector("#form1"); + const input = form.querySelector("input"); + const expectedValue = "value1"; + let beforeInputFired = false; + const submitTested = new Promise(resolve => { + + function handleBeforeInput(aEvent) { + info("BeforeInput"); + beforeInputFired = true; + is(input.value, "value", "The value should've not been modified yet"); + ok(aEvent instanceof InputEvent, + '"beforeinput" event should be dispatched with InputEvent interface'); + is(aEvent.cancelable, SpecialPowers.getBoolPref("dom.input_event.allow_to_cancel_set_user_input"), + `"beforeinput" event should be cancelable unless it's supporessed by the pref`); + is(aEvent.bubbles, true, + '"beforeinput" event should always bubble'); + is(aEvent.inputType, "insertReplacementText", + 'inputType of "beforeinput" event should be "insertReplacementText"'); + is(aEvent.data, expectedValue, + `data of "beforeinput" event should be "${expectedValue}"`); + is(aEvent.dataTransfer, null, + 'dataTransfer of "beforeinput" event should be null'); + is(aEvent.getTargetRanges().length, 0, + 'getTargetRanges() of "beforeinput" event should return empty array'); + } + + function handleInput(e) { + info("Input"); + ok(beforeInputFired, '"beforeinput" event should have been fired'); + is(input.value, expectedValue, "Check input value"); + ok(e instanceof InputEvent, + '"input" event should be dispatched with InputEvent interface'); + is(e.cancelable, false, '"input" event should be never cancelable'); + is(e.bubbles, true, '"input" event should always bubble'); + is(e.inputType, "insertReplacementText", 'inputType of "input" event'); + is(e.data, expectedValue, "data of input event"); + is(e.dataTransfer, null, 'dataTransfer of "input" event'); + is(e.getTargetRanges().length, 0, + 'getTargetRanges() of "input" event should return empty array'); + removeEventListeners(); + resolve(); + } + + function removeEventListeners() { + input.removeEventListener("beforeinput", handleBeforeInput, true); + input.removeEventListener("input", handleInput, true); + } + + input.addEventListener("beforeinput", handleBeforeInput, true); + input.addEventListener("input", handleInput, true); + input.addEventListener("keydown", function handleEnterDown(e) { + if (e.keyCode != KeyEvent.DOM_VK_RETURN) { + return; + } + info("Enter KeyDown"); + input.removeEventListener("keydown", handleEnterDown, true); + form.submit(); + }, true); + form.addEventListener("submit", () => { + info("Submit"); + ok(false, "The form should not be submitted"); + removeEventListeners(); + resolve(); + }, { once: true }); + }); + + await openPopupOn(input, { inputValue: "value" }); + + synthesizeKey("KEY_ArrowDown"); + synthesizeKey("KEY_Enter"); // select the first entry in the popup + + await submitTested; +}); + +</script> +</body> +</html> diff --git a/toolkit/components/satchel/test/unit/asyncformhistory_expire.sqlite b/toolkit/components/satchel/test/unit/asyncformhistory_expire.sqlite Binary files differnew file mode 100644 index 0000000000..07b43c2096 --- /dev/null +++ b/toolkit/components/satchel/test/unit/asyncformhistory_expire.sqlite diff --git a/toolkit/components/satchel/test/unit/formhistory_1000.sqlite b/toolkit/components/satchel/test/unit/formhistory_1000.sqlite Binary files differnew file mode 100644 index 0000000000..5eeab074fd --- /dev/null +++ b/toolkit/components/satchel/test/unit/formhistory_1000.sqlite diff --git a/toolkit/components/satchel/test/unit/formhistory_CORRUPT.sqlite b/toolkit/components/satchel/test/unit/formhistory_CORRUPT.sqlite new file mode 100644 index 0000000000..5f7498bfc2 --- /dev/null +++ b/toolkit/components/satchel/test/unit/formhistory_CORRUPT.sqlite @@ -0,0 +1 @@ +BACON diff --git a/toolkit/components/satchel/test/unit/formhistory_apitest.sqlite b/toolkit/components/satchel/test/unit/formhistory_apitest.sqlite Binary files differnew file mode 100644 index 0000000000..00daf03c27 --- /dev/null +++ b/toolkit/components/satchel/test/unit/formhistory_apitest.sqlite diff --git a/toolkit/components/satchel/test/unit/formhistory_autocomplete.sqlite b/toolkit/components/satchel/test/unit/formhistory_autocomplete.sqlite Binary files differnew file mode 100644 index 0000000000..724cff73f6 --- /dev/null +++ b/toolkit/components/satchel/test/unit/formhistory_autocomplete.sqlite diff --git a/toolkit/components/satchel/test/unit/formhistory_v3.sqlite b/toolkit/components/satchel/test/unit/formhistory_v3.sqlite Binary files differnew file mode 100644 index 0000000000..e0e8fe2468 --- /dev/null +++ b/toolkit/components/satchel/test/unit/formhistory_v3.sqlite diff --git a/toolkit/components/satchel/test/unit/formhistory_v3v4.sqlite b/toolkit/components/satchel/test/unit/formhistory_v3v4.sqlite Binary files differnew file mode 100644 index 0000000000..8eab177e97 --- /dev/null +++ b/toolkit/components/satchel/test/unit/formhistory_v3v4.sqlite diff --git a/toolkit/components/satchel/test/unit/formhistory_v999a.sqlite b/toolkit/components/satchel/test/unit/formhistory_v999a.sqlite Binary files differnew file mode 100644 index 0000000000..216bce4a34 --- /dev/null +++ b/toolkit/components/satchel/test/unit/formhistory_v999a.sqlite diff --git a/toolkit/components/satchel/test/unit/formhistory_v999b.sqlite b/toolkit/components/satchel/test/unit/formhistory_v999b.sqlite Binary files differnew file mode 100644 index 0000000000..fe400d04a1 --- /dev/null +++ b/toolkit/components/satchel/test/unit/formhistory_v999b.sqlite diff --git a/toolkit/components/satchel/test/unit/head_satchel.js b/toolkit/components/satchel/test/unit/head_satchel.js new file mode 100644 index 0000000000..631878c7d0 --- /dev/null +++ b/toolkit/components/satchel/test/unit/head_satchel.js @@ -0,0 +1,195 @@ +/* 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/. */ + +/* eslint + "no-unused-vars": ["error", { + vars: "local", + args: "none", + }], +*/ + +const CURRENT_SCHEMA = 5; +const PR_HOURS = 60 * 60 * 1000000; + +var { XPCOMUtils } = ChromeUtils.importESModule( + "resource://gre/modules/XPCOMUtils.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + FormHistory: "resource://gre/modules/FormHistory.sys.mjs", + FormHistoryTestUtils: + "resource://testing-common/FormHistoryTestUtils.sys.mjs", + Sqlite: "resource://gre/modules/Sqlite.sys.mjs", +}); + +do_get_profile(); + +// Send the profile-after-change notification to the form history component to ensure +// that it has been initialized. +var formHistoryStartup = Cc[ + "@mozilla.org/satchel/form-history-startup;1" +].getService(Ci.nsIObserver); +formHistoryStartup.observe(null, "profile-after-change", null); + +function getDBVersion(dbfile) { + let dbConnection = Services.storage.openDatabase(dbfile); + let version = dbConnection.schemaVersion; + dbConnection.close(); + + return version; +} + +async function getDBSchemaVersion(path) { + let db = await Sqlite.openConnection({ path }); + try { + return await db.getSchemaVersion(); + } finally { + await db.close(); + } +} + +function getFormHistoryDBVersion() { + let profileDir = do_get_profile(); + // Cleanup from any previous tests or failures. + let dbFile = profileDir.clone(); + dbFile.append("formhistory.sqlite"); + return getDBVersion(dbFile); +} + +const isGUID = /[A-Za-z0-9\+\/]{16}/; + +// Find form history entries. +function searchEntries(terms, params, iter) { + FormHistory.search(terms, params).then( + results => iter.next(results), + error => do_throw("Error occurred searching form history: " + error) + ); +} + +// Count the number of entries with the given name and value, and call then(number) +// when done. If name or value is null, then the value of that field does not matter. +function countEntries(name, value, then) { + let obj = {}; + if (name !== null) { + obj.fieldname = name; + } + if (value !== null) { + obj.value = value; + } + + FormHistory.count(obj).then( + count => { + then(count); + }, + error => { + do_throw("Error occurred searching form history: " + error); + } + ); +} + +// Perform a single form history update and call then() when done. +function updateEntry(op, name, value, then) { + let obj = { op }; + if (name !== null) { + obj.fieldname = name; + } + if (value !== null) { + obj.value = value; + } + updateFormHistory(obj, then); +} + +// Add a single form history entry with the current time and call then() when done. +function addEntry(name, value, then) { + let now = Date.now() * 1000; + updateFormHistory( + { + op: "add", + fieldname: name, + value, + timesUsed: 1, + firstUsed: now, + lastUsed: now, + }, + then + ); +} + +function promiseCountEntries(name, value, checkFn = () => {}) { + return new Promise(resolve => { + countEntries(name, value, function (result) { + checkFn(result); + resolve(result); + }); + }); +} + +function promiseUpdateEntry(op, name, value) { + return new Promise(res => { + updateEntry(op, name, value, res); + }); +} + +function promiseAddEntry(name, value) { + return new Promise(res => { + addEntry(name, value, res); + }); +} + +// Wrapper around FormHistory.update which handles errors. Calls then() when done. +function updateFormHistory(changes, then) { + FormHistory.update(changes).then(then, error => { + do_throw("Error occurred updating form history: " + error); + }); +} + +function promiseUpdate(change) { + return FormHistory.update(change); +} + +/** + * Logs info to the console in the standard way (includes the filename). + * + * @param {string} aMessage + * The message to log to the console. + */ +function do_log_info(aMessage) { + print("TEST-INFO | " + _TEST_FILE + " | " + aMessage); +} + +/** + * Copies a test file into the profile folder. + * + * @param {string} aFilename + * The name of the file to copy. + * @param {string} aDestFilename + * The name of the file to copy. + * @param {object} [options] + * @param {object} [options.overwriteExisting] + * Whether to overwrite an existing file. + * @returns {string} path to the copied file. + */ +async function copyToProfile( + aFilename, + aDestFilename, + { overwriteExisting = false } = {} +) { + let curDir = Services.dirsvc.get("CurWorkD", Ci.nsIFile).path; + let srcPath = PathUtils.join(curDir, aFilename); + Assert.ok(await IOUtils.exists(srcPath), "Database file found"); + + // Ensure that our file doesn't exist already. + let destPath = PathUtils.join(PathUtils.profileDir, aDestFilename); + let exists = await IOUtils.exists(destPath); + if (exists) { + if (overwriteExisting) { + await IOUtils.remove(destPath); + } else { + throw new Error("The file should not exist"); + } + } + await IOUtils.copy(srcPath, destPath); + info(`Copied ${aFilename} to ${destPath}`); + return destPath; +} diff --git a/toolkit/components/satchel/test/unit/test_async_expire.js b/toolkit/components/satchel/test/unit/test_async_expire.js new file mode 100644 index 0000000000..5fe796d864 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_async_expire.js @@ -0,0 +1,134 @@ +/* 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/. */ + +ChromeUtils.defineESModuleGetters(this, { + TestUtils: "resource://testing-common/TestUtils.sys.mjs", +}); + +function promiseExpiration() { + let promise = TestUtils.topicObserved( + "satchel-storage-changed", + (subject, data) => { + return data == "formhistory-expireoldentries"; + } + ); + + // We can't easily fake a "daily idle" event, so for testing purposes form + // history listens for another notification to trigger an immediate + // expiration. + Services.obs.notifyObservers(null, "formhistory-expire-now"); + + return promise; +} + +add_task(async function () { + // ===== test init ===== + let testfile = do_get_file("asyncformhistory_expire.sqlite"); + let profileDir = do_get_profile(); + + // Cleanup from any previous tests or failures. + let dbFile = profileDir.clone(); + dbFile.append("formhistory.sqlite"); + if (dbFile.exists()) { + dbFile.remove(false); + } + + testfile.copyTo(profileDir, "formhistory.sqlite"); + Assert.ok(dbFile.exists()); + + // We're going to clear this at the end, so it better have the default value now. + Assert.ok(!Services.prefs.prefHasUserValue("browser.formfill.expire_days")); + + // Sanity check initial state + Assert.equal(508, await promiseCountEntries(null, null)); + Assert.ok((await promiseCountEntries("name-A", "value-A")) > 0); // lastUsed == distant past + Assert.ok((await promiseCountEntries("name-B", "value-B")) > 0); // lastUsed == distant future + + Assert.equal(CURRENT_SCHEMA, getDBVersion(dbFile)); + + // Add a new entry + Assert.equal(0, await promiseCountEntries("name-C", "value-C")); + await promiseAddEntry("name-C", "value-C"); + Assert.equal(1, await promiseCountEntries("name-C", "value-C")); + + // Update some existing entries to have ages relative to when the test runs. + let now = 1000 * Date.now(); + let updateLastUsed = (results, age) => { + let lastUsed = now - age * 24 * PR_HOURS; + + let changes = []; + for (let result of results) { + changes.push({ op: "update", lastUsed, guid: result.guid }); + } + + return changes; + }; + + let results = await FormHistory.search(["guid"], { lastUsed: 181 }); + await promiseUpdate(updateLastUsed(results, 181)); + + results = await FormHistory.search(["guid"], { lastUsed: 179 }); + await promiseUpdate(updateLastUsed(results, 179)); + + results = await FormHistory.search(["guid"], { lastUsed: 31 }); + await promiseUpdate(updateLastUsed(results, 31)); + + results = await FormHistory.search(["guid"], { lastUsed: 29 }); + await promiseUpdate(updateLastUsed(results, 29)); + + results = await FormHistory.search(["guid"], { lastUsed: 9999 }); + await promiseUpdate(updateLastUsed(results, 11)); + + results = await FormHistory.search(["guid"], { lastUsed: 9 }); + await promiseUpdate(updateLastUsed(results, 9)); + + Assert.ok((await promiseCountEntries("name-A", "value-A")) > 0); + Assert.ok((await promiseCountEntries("181DaysOld", "foo")) > 0); + Assert.ok((await promiseCountEntries("179DaysOld", "foo")) > 0); + Assert.equal(509, await promiseCountEntries(null, null)); + + // 2 entries are expected to expire. + await promiseExpiration(); + + Assert.equal(0, await promiseCountEntries("name-A", "value-A")); + Assert.equal(0, await promiseCountEntries("181DaysOld", "foo")); + Assert.ok((await promiseCountEntries("179DaysOld", "foo")) > 0); + Assert.equal(507, await promiseCountEntries(null, null)); + + // And again. No change expected. + await promiseExpiration(); + + Assert.equal(507, await promiseCountEntries(null, null)); + + // Set formfill pref to 30 days. + Services.prefs.setIntPref("browser.formfill.expire_days", 30); + + Assert.ok((await promiseCountEntries("179DaysOld", "foo")) > 0); + Assert.ok((await promiseCountEntries("bar", "31days")) > 0); + Assert.ok((await promiseCountEntries("bar", "29days")) > 0); + Assert.equal(507, await promiseCountEntries(null, null)); + + await promiseExpiration(); + + Assert.equal(0, await promiseCountEntries("179DaysOld", "foo")); + Assert.equal(0, await promiseCountEntries("bar", "31days")); + Assert.ok((await promiseCountEntries("bar", "29days")) > 0); + Assert.equal(505, await promiseCountEntries(null, null)); + + // Set override pref to 10 days and expire. This expires a large batch of + // entries, and should trigger a VACCUM to reduce file size. + Services.prefs.setIntPref("browser.formfill.expire_days", 10); + + Assert.ok((await promiseCountEntries("bar", "29days")) > 0); + Assert.ok((await promiseCountEntries("9DaysOld", "foo")) > 0); + Assert.equal(505, await promiseCountEntries(null, null)); + + await promiseExpiration(); + + Assert.equal(0, await promiseCountEntries("bar", "29days")); + Assert.ok((await promiseCountEntries("9DaysOld", "foo")) > 0); + Assert.ok((await promiseCountEntries("name-B", "value-B")) > 0); + Assert.ok((await promiseCountEntries("name-C", "value-C")) > 0); + Assert.equal(3, await promiseCountEntries(null, null)); +}); diff --git a/toolkit/components/satchel/test/unit/test_autocomplete.js b/toolkit/components/satchel/test/unit/test_autocomplete.js new file mode 100644 index 0000000000..81557f6630 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_autocomplete.js @@ -0,0 +1,388 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +var fac; + +var numRecords, timeGroupingSize, now; + +const DEFAULT_EXPIRE_DAYS = 180; + +function padLeft(number, length) { + let str = number + ""; + while (str.length < length) { + str = "0" + str; + } + return str; +} + +function getFormExpiryDays() { + if (Services.prefs.prefHasUserValue("browser.formfill.expire_days")) { + return Services.prefs.getIntPref("browser.formfill.expire_days"); + } + return DEFAULT_EXPIRE_DAYS; +} + +function run_test() { + // ===== test init ===== + let testfile = do_get_file("formhistory_autocomplete.sqlite"); + let profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile); + + // Cleanup from any previous tests or failures. + let destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + if (destFile.exists()) { + destFile.remove(false); + } + + testfile.copyTo(profileDir, "formhistory.sqlite"); + + fac = Cc["@mozilla.org/satchel/form-autocomplete;1"].getService( + Ci.nsIFormAutoComplete + ); + + timeGroupingSize = + Services.prefs.getIntPref("browser.formfill.timeGroupingSize") * + 1000 * + 1000; + + run_next_test(); +} + +add_test(function test0() { + let maxTimeGroupings = Services.prefs.getIntPref( + "browser.formfill.maxTimeGroupings" + ); + let bucketSize = Services.prefs.getIntPref("browser.formfill.bucketSize"); + + // ===== Tests with constant timesUsed and varying lastUsed date ===== + // insert 2 records per bucket to check alphabetical sort within + now = 1000 * Date.now(); + numRecords = Math.ceil(maxTimeGroupings / bucketSize) * 2; + + let changes = []; + for (let i = 0; i < numRecords; i += 2) { + let useDate = now - (i / 2) * bucketSize * timeGroupingSize; + + changes.push({ + op: "add", + fieldname: "field1", + value: "value" + padLeft(numRecords - 1 - i, 2), + timesUsed: 1, + firstUsed: useDate, + lastUsed: useDate, + }); + changes.push({ + op: "add", + fieldname: "field1", + value: "value" + padLeft(numRecords - 2 - i, 2), + timesUsed: 1, + firstUsed: useDate, + lastUsed: useDate, + }); + } + + updateFormHistory(changes, run_next_test); +}); + +add_test(function test1() { + do_log_info("Check initial state is as expected"); + + countEntries(null, null, function () { + countEntries("field1", null, function (count) { + Assert.ok(count > 0); + run_next_test(); + }); + }); +}); + +add_test(function test2() { + do_log_info("Check search contains all entries"); + + fac.autoCompleteSearchAsync("field1", "", null, null, null, { + onSearchCompletion(aResults) { + Assert.equal(numRecords, aResults.matchCount); + run_next_test(); + }, + }); +}); + +add_test(function test3() { + do_log_info("Check search result ordering with empty search term"); + + let lastFound = numRecords; + fac.autoCompleteSearchAsync("field1", "", null, null, null, { + onSearchCompletion(aResults) { + for (let i = 0; i < numRecords; i += 2) { + Assert.equal( + parseInt(aResults.getValueAt(i + 1).substr(5), 10), + --lastFound + ); + Assert.equal( + parseInt(aResults.getValueAt(i).substr(5), 10), + --lastFound + ); + } + run_next_test(); + }, + }); +}); + +add_test(function test4() { + do_log_info('Check search result ordering with "v"'); + + let lastFound = numRecords; + fac.autoCompleteSearchAsync("field1", "v", null, null, null, { + onSearchCompletion(aResults) { + for (let i = 0; i < numRecords; i += 2) { + Assert.equal( + parseInt(aResults.getValueAt(i + 1).substr(5), 10), + --lastFound + ); + Assert.equal( + parseInt(aResults.getValueAt(i).substr(5), 10), + --lastFound + ); + } + run_next_test(); + }, + }); +}); + +const timesUsedSamples = 20; + +add_test(function test5() { + do_log_info("Begin tests with constant use dates and varying timesUsed"); + + let changes = []; + for (let i = 0; i < timesUsedSamples; i++) { + let timesUsed = timesUsedSamples - i; + let change = { + op: "add", + fieldname: "field2", + value: "value" + (timesUsedSamples - 1 - i), + timesUsed: timesUsed * timeGroupingSize, + firstUsed: now, + lastUsed: now, + }; + changes.push(change); + } + updateFormHistory(changes, run_next_test); +}); + +add_test(function test6() { + do_log_info("Check search result ordering with empty search term"); + + let lastFound = timesUsedSamples; + fac.autoCompleteSearchAsync("field2", "", null, null, null, { + onSearchCompletion(aResults) { + for (let i = 0; i < timesUsedSamples; i++) { + Assert.equal( + parseInt(aResults.getValueAt(i).substr(5), 10), + --lastFound + ); + } + run_next_test(); + }, + }); +}); + +add_test(function test7() { + do_log_info('Check search result ordering with "v"'); + + let lastFound = timesUsedSamples; + fac.autoCompleteSearchAsync("field2", "v", null, null, null, { + onSearchCompletion(aResults) { + for (let i = 0; i < timesUsedSamples; i++) { + Assert.equal( + parseInt(aResults.getValueAt(i).substr(5), 10), + --lastFound + ); + } + run_next_test(); + }, + }); +}); + +add_test(function test8() { + do_log_info( + 'Check that "senior citizen" entries get a bonus (browser.formfill.agedBonus)' + ); + + let agedDate = + 1000 * (Date.now() - getFormExpiryDays() * 24 * 60 * 60 * 1000); + + let changes = []; + changes.push({ + op: "add", + fieldname: "field3", + value: "old but not senior", + timesUsed: 100, + firstUsed: agedDate + 60 * 1000 * 1000, + lastUsed: now, + }); + changes.push({ + op: "add", + fieldname: "field3", + value: "senior citizen", + timesUsed: 100, + firstUsed: agedDate - 60 * 1000 * 1000, + lastUsed: now, + }); + updateFormHistory(changes, run_next_test); +}); + +add_test(function test9() { + fac.autoCompleteSearchAsync("field3", "", null, null, null, { + onSearchCompletion(aResults) { + Assert.equal(aResults.getValueAt(0), "senior citizen"); + Assert.equal(aResults.getValueAt(1), "old but not senior"); + run_next_test(); + }, + }); +}); + +add_test(function test10() { + do_log_info("Check entries that are really old or in the future"); + + let changes = []; + changes.push({ + op: "add", + fieldname: "field4", + value: "date of 0", + timesUsed: 1, + firstUsed: 0, + lastUsed: 0, + }); + changes.push({ + op: "add", + fieldname: "field4", + value: "in the future 1", + timesUsed: 1, + firstUsed: 0, + lastUsed: now * 2, + }); + changes.push({ + op: "add", + fieldname: "field4", + value: "in the future 2", + timesUsed: 1, + firstUsed: now * 2, + lastUsed: now * 2, + }); + updateFormHistory(changes, run_next_test); +}); + +add_test(function test11() { + fac.autoCompleteSearchAsync("field4", "", null, null, null, { + onSearchCompletion(aResults) { + Assert.equal(aResults.matchCount, 3); + run_next_test(); + }, + }); +}); + +var syncValues = ["sync1", "sync1a", "sync2", "sync3"]; + +add_test(function test12() { + do_log_info("Check old synchronous api"); + + let changes = []; + for (let value of syncValues) { + changes.push({ op: "add", fieldname: "field5", value }); + } + updateFormHistory(changes, run_next_test); +}); + +add_test(function test_token_limit_DB() { + function test_token_limit_previousResult(previousResult) { + do_log_info( + "Check that the number of tokens used in a search is not capped to " + + "MAX_SEARCH_TOKENS when using a previousResult" + ); + // This provide more accuracy since performance is less of an issue. + // Search for a string where the first 10 tokens match the previous value but the 11th does not + // when re-using a previous result. + fac.autoCompleteSearchAsync( + "field_token_cap", + "a b c d e f g h i j .", + null, + previousResult, + null, + { + onSearchCompletion(aResults) { + Assert.equal( + aResults.matchCount, + 0, + "All search tokens should be used with previous results" + ); + run_next_test(); + }, + } + ); + } + + do_log_info( + "Check that the number of tokens used in a search is capped to MAX_SEARCH_TOKENS " + + "for performance when querying the DB" + ); + let changes = []; + changes.push({ + op: "add", + fieldname: "field_token_cap", + // value with 15 unique tokens + value: "a b c d e f g h i j k l m n o", + timesUsed: 1, + firstUsed: 0, + lastUsed: 0, + }); + updateFormHistory(changes, () => { + // Search for a string where the first 10 tokens match the value above but the 11th does not + // (which would prevent the result from being returned if the 11th term was used). + fac.autoCompleteSearchAsync( + "field_token_cap", + "a b c d e f g h i j .", + null, + null, + null, + { + onSearchCompletion(aResults) { + Assert.equal( + aResults.matchCount, + 1, + "Only the first MAX_SEARCH_TOKENS tokens " + + "should be used for DB queries" + ); + test_token_limit_previousResult(aResults); + }, + } + ); + }); +}); + +add_test(async function can_search_escape_marker() { + await promiseUpdate({ + op: "add", + fieldname: "field1", + value: "/* Further reading */ test", + timesUsed: 1, + firstUsed: now, + lastUsed: now, + }); + + fac.autoCompleteSearchAsync( + "field1", + "/* Further reading */ t", + null, + null, + null, + { + onSearchCompletion(aResults) { + Assert.equal(1, aResults.matchCount); + run_next_test(); + }, + } + ); +}); diff --git a/toolkit/components/satchel/test/unit/test_db_corrupt.js b/toolkit/components/satchel/test/unit/test_db_corrupt.js new file mode 100644 index 0000000000..b53b5cd6d0 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_db_corrupt.js @@ -0,0 +1,80 @@ +/* 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 bakFile; + +function run_test() { + // ===== test init ===== + let testfile = do_get_file("formhistory_CORRUPT.sqlite"); + let profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile); + + // Cleanup from any previous tests or failures. + let destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + if (destFile.exists()) { + destFile.remove(false); + } + + bakFile = profileDir.clone(); + bakFile.append("formhistory.sqlite.corrupt"); + if (bakFile.exists()) { + bakFile.remove(false); + } + + testfile.copyTo(profileDir, "formhistory.sqlite"); + run_next_test(); +} + +add_test(function test_corruptFormHistoryDB_lazyCorruptInit1() { + do_log_info("ensure FormHistory backs up a corrupt DB on initialization."); + + // DB init is done lazily so the DB shouldn't be created yet. + Assert.ok(!bakFile.exists()); + // Doing any request to the DB should create it. + countEntries(null, null, run_next_test); +}); + +add_test(function test_corruptFormHistoryDB_lazyCorruptInit2() { + Assert.ok(bakFile.exists()); + bakFile.remove(false); + run_next_test(); +}); + +add_test(function test_corruptFormHistoryDB_emptyInit() { + do_log_info( + "test that FormHistory initializes an empty DB in place of corrupt DB." + ); + + (async function () { + let count = await FormHistory.count({}); + Assert.equal(count, 0); + count = await FormHistory.count({ fieldname: "name-A", value: "value-A" }); + Assert.equal(count, 0); + run_next_test(); + })().catch(error => { + do_throw("DB initialized after reading a corrupt DB file is not empty."); + }); +}); + +add_test(function test_corruptFormHistoryDB_addEntry() { + do_log_info("test adding an entry to the empty DB."); + + updateEntry("add", "name-A", "value-A", function () { + countEntries("name-A", "value-A", function (count) { + Assert.ok(count == 1); + run_next_test(); + }); + }); +}); + +add_test(function test_corruptFormHistoryDB_removeEntry() { + do_log_info("test removing an entry to the empty DB."); + + updateEntry("remove", "name-A", "value-A", function () { + countEntries("name-A", "value-A", function (count) { + Assert.ok(count == 0); + run_next_test(); + }); + }); +}); diff --git a/toolkit/components/satchel/test/unit/test_db_update_v4.js b/toolkit/components/satchel/test/unit/test_db_update_v4.js new file mode 100644 index 0000000000..e55890a830 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_db_update_v4.js @@ -0,0 +1,52 @@ +/* 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/. */ + +add_task(async function () { + let testnum = 0; + + try { + // ===== test init ===== + let testfile = do_get_file("formhistory_v3.sqlite"); + let profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile); + + // Cleanup from any previous tests or failures. + let destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + if (destFile.exists()) { + destFile.remove(false); + } + + testfile.copyTo(profileDir, "formhistory.sqlite"); + Assert.equal(3, getDBVersion(testfile)); + + Assert.ok(destFile.exists()); + + // ===== 1 ===== + testnum++; + + destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + let dbConnection = Services.storage.openUnsharedDatabase(destFile); + + // Do something that will cause FormHistory to access and upgrade the + // database + await FormHistory.count({}); + + // check for upgraded schema. + Assert.equal(CURRENT_SCHEMA, getDBVersion(destFile)); + + // Check that the index was added + Assert.ok(dbConnection.tableExists("moz_deleted_formhistory")); + dbConnection.close(); + + // check for upgraded schema. + Assert.equal(CURRENT_SCHEMA, getDBVersion(destFile)); + + // check that an entry still exists + let num = await promiseCountEntries("name-A", "value-A"); + Assert.ok(num > 0); + } catch (e) { + throw new Error(`FAILED in test #${testnum} -- ${e}`); + } +}); diff --git a/toolkit/components/satchel/test/unit/test_db_update_v4b.js b/toolkit/components/satchel/test/unit/test_db_update_v4b.js new file mode 100644 index 0000000000..83fdf4a072 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_db_update_v4b.js @@ -0,0 +1,46 @@ +/* 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/. */ + +add_task(async function () { + let testnum = 0; + + try { + // ===== test init ===== + let testfile = do_get_file("formhistory_v3v4.sqlite"); + let profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile); + + // Cleanup from any previous tests or failures. + let destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + if (destFile.exists()) { + destFile.remove(false); + } + + testfile.copyTo(profileDir, "formhistory.sqlite"); + Assert.equal(3, getDBVersion(testfile)); + + // ===== 1 ===== + testnum++; + + destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + let dbConnection = Services.storage.openUnsharedDatabase(destFile); + + // Do something that will cause FormHistory to access and upgrade the + // database + await FormHistory.count({}); + + // check for upgraded schema. + Assert.equal(CURRENT_SCHEMA, getDBVersion(destFile)); + + // Check that the index was added + Assert.ok(dbConnection.tableExists("moz_deleted_formhistory")); + dbConnection.close(); + + // check that an entry still exists + Assert.ok((await promiseCountEntries("name-A", "value-A")) > 0); + } catch (e) { + throw new Error(`FAILED in test #${testnum} -- ${e}`); + } +}); diff --git a/toolkit/components/satchel/test/unit/test_db_update_v5.js b/toolkit/components/satchel/test/unit/test_db_update_v5.js new file mode 100644 index 0000000000..f546d4a0f5 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_db_update_v5.js @@ -0,0 +1,29 @@ +/* Any copyright is dedicated to the Public Domain. + * https://creativecommons.org/publicdomain/zero/1.0/ */ + +add_task(async function () { + let destPath = await copyToProfile( + "formhistory_v3.sqlite", + "formhistory.sqlite" + ); + Assert.equal(3, await getDBSchemaVersion(destPath)); + + // Do something that will cause FormHistory to access and upgrade the + // database + await FormHistory.count({}); + + // check for upgraded schema. + Assert.equal(CURRENT_SCHEMA, await getDBSchemaVersion(destPath)); + + // Check that the source tables were added. + let db = await Sqlite.openConnection({ path: destPath }); + try { + Assert.ok(db.tableExists("moz_sources")); + Assert.ok(db.tableExists("moz_sources_to_history")); + } finally { + await db.close(); + } + // check that an entry still exists + let num = await promiseCountEntries("name-A", "value-A"); + Assert.ok(num > 0); +}); diff --git a/toolkit/components/satchel/test/unit/test_db_update_v999a.js b/toolkit/components/satchel/test/unit/test_db_update_v999a.js new file mode 100644 index 0000000000..5bb151e33b --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_db_update_v999a.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/. */ + +/* + * This test uses a formhistory.sqlite with schema version set to 999 (a + * future version). This exercies the code that allows using a future schema + * version as long as the expected columns are present. + * + * Part A tests this when the columns do match, so the DB is used. + * Part B tests this when the columns do *not* match, so the DB is reset. + */ + +add_task(async function () { + let testnum = 0; + + try { + // ===== test init ===== + let testfile = do_get_file("formhistory_v999a.sqlite"); + let profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile); + + // Cleanup from any previous tests or failures. + let destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + if (destFile.exists()) { + destFile.remove(false); + } + + testfile.copyTo(profileDir, "formhistory.sqlite"); + Assert.equal(999, getDBVersion(testfile)); + + // ===== 1 ===== + testnum++; + // Check for expected contents. + Assert.ok((await promiseCountEntries(null, null)) > 0); + Assert.equal(1, await promiseCountEntries("name-A", "value-A")); + Assert.equal(1, await promiseCountEntries("name-B", "value-B")); + Assert.equal(1, await promiseCountEntries("name-C", "value-C1")); + Assert.equal(1, await promiseCountEntries("name-C", "value-C2")); + Assert.equal(1, await promiseCountEntries("name-E", "value-E")); + + // check for downgraded schema. + Assert.equal(CURRENT_SCHEMA, getDBVersion(destFile)); + + // ===== 2 ===== + testnum++; + // Exercise adding and removing a name/value pair + Assert.equal(0, await promiseCountEntries("name-D", "value-D")); + await promiseUpdateEntry("add", "name-D", "value-D"); + Assert.equal(1, await promiseCountEntries("name-D", "value-D")); + await promiseUpdateEntry("remove", "name-D", "value-D"); + Assert.equal(0, await promiseCountEntries("name-D", "value-D")); + } catch (e) { + throw new Error(`FAILED in test #${testnum} -- ${e}`); + } +}); diff --git a/toolkit/components/satchel/test/unit/test_db_update_v999b.js b/toolkit/components/satchel/test/unit/test_db_update_v999b.js new file mode 100644 index 0000000000..d33996c204 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_db_update_v999b.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/. */ + +/* + * This test uses a formhistory.sqlite with schema version set to 999 (a + * future version). This exercies the code that allows using a future schema + * version as long as the expected columns are present. + * + * Part A tests this when the columns do match, so the DB is used. + * Part B tests this when the columns do *not* match, so the DB is reset. + */ + +add_task(async function () { + let testnum = 0; + + try { + // ===== test init ===== + let testfile = do_get_file("formhistory_v999b.sqlite"); + let profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile); + + // Cleanup from any previous tests or failures. + let destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + if (destFile.exists()) { + destFile.remove(false); + } + + let bakFile = profileDir.clone(); + bakFile.append("formhistory.sqlite.corrupt"); + if (bakFile.exists()) { + bakFile.remove(false); + } + + testfile.copyTo(profileDir, "formhistory.sqlite"); + Assert.equal(999, getDBVersion(destFile)); + + // ===== 1 ===== + testnum++; + + // Open the DB, ensure that a backup of the corrupt DB is made. + // DB init is done lazily so the DB shouldn't be created yet. + Assert.ok(!bakFile.exists()); + // Doing any request to the DB should create it. + await promiseCountEntries("", ""); + + Assert.ok(bakFile.exists()); + bakFile.remove(false); + + // ===== 2 ===== + testnum++; + // File should be empty + Assert.ok(!(await promiseCountEntries(null, null))); + Assert.equal(0, await promiseCountEntries("name-A", "value-A")); + // check for current schema. + Assert.equal(CURRENT_SCHEMA, getDBVersion(destFile)); + + // ===== 3 ===== + testnum++; + // Try adding an entry + await promiseUpdateEntry("add", "name-A", "value-A"); + Assert.equal(1, await promiseCountEntries(null, null)); + Assert.equal(1, await promiseCountEntries("name-A", "value-A")); + + // ===== 4 ===== + testnum++; + // Try removing an entry + await promiseUpdateEntry("remove", "name-A", "value-A"); + Assert.equal(0, await promiseCountEntries(null, null)); + Assert.equal(0, await promiseCountEntries("name-A", "value-A")); + } catch (e) { + throw new Error(`FAILED in test #${testnum} -- ${e}`); + } +}); diff --git a/toolkit/components/satchel/test/unit/test_history_api.js b/toolkit/components/satchel/test/unit/test_history_api.js new file mode 100644 index 0000000000..e02d4e54f6 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_history_api.js @@ -0,0 +1,518 @@ +/* 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 testnum = 0; +var dbConnection; // used for deleted table tests + +const { PromiseUtils } = ChromeUtils.importESModule( + "resource://gre/modules/PromiseUtils.sys.mjs" +); + +function countDeletedEntries(expected) { + return new Promise((resolve, reject) => { + let stmt = dbConnection.createAsyncStatement( + "SELECT COUNT(*) AS numEntries FROM moz_deleted_formhistory" + ); + stmt.executeAsync({ + handleResult(resultSet) { + Assert.equal( + expected, + resultSet.getNextRow().getResultByName("numEntries") + ); + resolve(); + }, + handleError(error) { + do_throw("Error occurred counting deleted entries: " + error); + reject(); + }, + handleCompletion() { + stmt.finalize(); + }, + }); + }); +} + +function checkTimeDeleted(guid, checkFunction) { + return new Promise((resolve, reject) => { + let stmt = dbConnection.createAsyncStatement( + "SELECT timeDeleted FROM moz_deleted_formhistory WHERE guid = :guid" + ); + stmt.params.guid = guid; + stmt.executeAsync({ + handleResult(resultSet) { + checkFunction(resultSet.getNextRow().getResultByName("timeDeleted")); + resolve(); + }, + handleError(error) { + do_throw("Error occurred getting deleted entries: " + error); + reject(); + }, + handleCompletion() { + stmt.finalize(); + }, + }); + }); +} + +function promiseUpdateEntry(op, name, value) { + let change = { op }; + if (name !== null) { + change.fieldname = name; + } + if (value !== null) { + change.value = value; + } + return promiseUpdate(change); +} + +add_task(async function () { + let oldSupportsDeletedTable = FormHistory._supportsDeletedTable; + FormHistory._supportsDeletedTable = true; + + try { + // ===== test init ===== + let testfile = do_get_file("formhistory_apitest.sqlite"); + let profileDir = Services.dirsvc.get("ProfD", Ci.nsIFile); + + // Cleanup from any previous tests or failures. + let destFile = profileDir.clone(); + destFile.append("formhistory.sqlite"); + if (destFile.exists()) { + destFile.remove(false); + } + + testfile.copyTo(profileDir, "formhistory.sqlite"); + + function checkExists(num) { + Assert.ok(num > 0); + } + function checkNotExists(num) { + Assert.ok(num == 0); + } + + // ===== 1 ===== + // Check initial state is as expected + testnum++; + await promiseCountEntries("name-A", null, checkExists); + await promiseCountEntries("name-B", null, checkExists); + await promiseCountEntries("name-C", null, checkExists); + await promiseCountEntries("name-D", null, checkExists); + await promiseCountEntries("name-A", "value-A", checkExists); + await promiseCountEntries("name-B", "value-B1", checkExists); + await promiseCountEntries("name-B", "value-B2", checkExists); + await promiseCountEntries("name-C", "value-C", checkExists); + await promiseCountEntries("name-D", "value-D", checkExists); + // time-A/B/C/D checked below. + + // Delete anything from the deleted table + let dbFile = Services.dirsvc.get("ProfD", Ci.nsIFile).clone(); + dbFile.append("formhistory.sqlite"); + dbConnection = Services.storage.openUnsharedDatabase(dbFile); + + let deferred = PromiseUtils.defer(); + + let stmt = dbConnection.createAsyncStatement( + "DELETE FROM moz_deleted_formhistory" + ); + stmt.executeAsync({ + handleResult(resultSet) {}, + handleError(error) { + do_throw("Error occurred counting deleted all entries: " + error); + }, + handleCompletion() { + stmt.finalize(); + deferred.resolve(); + }, + }); + await deferred.promise; + + // ===== 2 ===== + // Test looking for nonexistent / bogus data. + testnum++; + await promiseCountEntries("blah", null, checkNotExists); + await promiseCountEntries("", null, checkNotExists); + await promiseCountEntries("name-A", "blah", checkNotExists); + await promiseCountEntries("name-A", "", checkNotExists); + await promiseCountEntries("name-A", null, checkExists); + await promiseCountEntries("blah", "value-A", checkNotExists); + await promiseCountEntries("", "value-A", checkNotExists); + await promiseCountEntries(null, "value-A", checkExists); + + // Cannot use promiseCountEntries when name and value are null + // because it treats null values as not set + // and here a search should be done explicity for null. + let count = await FormHistory.count({ fieldname: null, value: null }); + checkNotExists(count); + + // ===== 3 ===== + // Test removeEntriesForName with a single matching value + testnum++; + await promiseUpdateEntry("remove", "name-A", null); + + await promiseCountEntries("name-A", "value-A", checkNotExists); + await promiseCountEntries("name-B", "value-B1", checkExists); + await promiseCountEntries("name-B", "value-B2", checkExists); + await promiseCountEntries("name-C", "value-C", checkExists); + await promiseCountEntries("name-D", "value-D", checkExists); + await countDeletedEntries(1); + + // ===== 4 ===== + // Test removeEntriesForName with multiple matching values + testnum++; + await promiseUpdateEntry("remove", "name-B", null); + + await promiseCountEntries("name-A", "value-A", checkNotExists); + await promiseCountEntries("name-B", "value-B1", checkNotExists); + await promiseCountEntries("name-B", "value-B2", checkNotExists); + await promiseCountEntries("name-C", "value-C", checkExists); + await promiseCountEntries("name-D", "value-D", checkExists); + await countDeletedEntries(3); + + // ===== 5 ===== + // Test removing by time range (single entry, not surrounding entries) + testnum++; + await promiseCountEntries("time-A", null, checkExists); // firstUsed=1000, lastUsed=1000 + await promiseCountEntries("time-B", null, checkExists); // firstUsed=1000, lastUsed=1099 + await promiseCountEntries("time-C", null, checkExists); // firstUsed=1099, lastUsed=1099 + await promiseCountEntries("time-D", null, checkExists); // firstUsed=2001, lastUsed=2001 + await promiseUpdate({ + op: "remove", + firstUsedStart: 1050, + firstUsedEnd: 2000, + }); + + await promiseCountEntries("time-A", null, checkExists); + await promiseCountEntries("time-B", null, checkExists); + await promiseCountEntries("time-C", null, checkNotExists); + await promiseCountEntries("time-D", null, checkExists); + await countDeletedEntries(4); + + // ===== 6 ===== + // Test removing by time range (multiple entries) + testnum++; + await promiseUpdate({ + op: "remove", + firstUsedStart: 1000, + firstUsedEnd: 2000, + }); + + await promiseCountEntries("time-A", null, checkNotExists); + await promiseCountEntries("time-B", null, checkNotExists); + await promiseCountEntries("time-C", null, checkNotExists); + await promiseCountEntries("time-D", null, checkExists); + await countDeletedEntries(6); + + // ===== 7 ===== + // test removeAllEntries + testnum++; + await promiseUpdateEntry("remove", null, null); + + await promiseCountEntries("name-C", null, checkNotExists); + await promiseCountEntries("name-D", null, checkNotExists); + await promiseCountEntries("name-C", "value-C", checkNotExists); + await promiseCountEntries("name-D", "value-D", checkNotExists); + + await promiseCountEntries(null, null, checkNotExists); + await countDeletedEntries(6); + + // ===== 8 ===== + // Add a single entry back + testnum++; + await promiseUpdateEntry("add", "newname-A", "newvalue-A"); + await promiseCountEntries("newname-A", "newvalue-A", checkExists); + + // ===== 9 ===== + // Remove the single entry + testnum++; + await promiseUpdateEntry("remove", "newname-A", "newvalue-A"); + await promiseCountEntries("newname-A", "newvalue-A", checkNotExists); + + // ===== 10 ===== + // Add a single entry + testnum++; + await promiseUpdateEntry("add", "field1", "value1"); + await promiseCountEntries("field1", "value1", checkExists); + + let processFirstResult = function processResults(results) { + // Only handle the first result + if (results.length) { + let result = results[0]; + return [ + result.timesUsed, + result.firstUsed, + result.lastUsed, + result.guid, + ]; + } + return undefined; + }; + + let results = await FormHistory.search( + ["timesUsed", "firstUsed", "lastUsed"], + { fieldname: "field1", value: "value1" } + ); + let [timesUsed, firstUsed, lastUsed] = processFirstResult(results); + Assert.equal(1, timesUsed); + Assert.ok(firstUsed > 0); + Assert.ok(lastUsed > 0); + await promiseCountEntries(null, null, num => Assert.equal(num, 1)); + + // ===== 11 ===== + // Add another single entry + testnum++; + await promiseUpdateEntry("add", "field1", "value1b"); + await promiseCountEntries("field1", "value1", checkExists); + await promiseCountEntries("field1", "value1b", checkExists); + await promiseCountEntries(null, null, num => Assert.equal(num, 2)); + + // ===== 12 ===== + // Update a single entry + testnum++; + + results = await FormHistory.search(["guid"], { + fieldname: "field1", + value: "value1", + }); + let guid = processFirstResult(results)[3]; + + await promiseUpdate({ op: "update", guid, value: "modifiedValue" }); + await promiseCountEntries("field1", "modifiedValue", checkExists); + await promiseCountEntries("field1", "value1", checkNotExists); + await promiseCountEntries("field1", "value1b", checkExists); + await promiseCountEntries(null, null, num => Assert.equal(num, 2)); + + // ===== 13 ===== + // Add a single entry with times + testnum++; + await promiseUpdate({ + op: "add", + fieldname: "field2", + value: "value2", + timesUsed: 20, + firstUsed: 100, + lastUsed: 500, + }); + + results = await FormHistory.search(["timesUsed", "firstUsed", "lastUsed"], { + fieldname: "field2", + value: "value2", + }); + [timesUsed, firstUsed, lastUsed] = processFirstResult(results); + + Assert.equal(20, timesUsed); + Assert.equal(100, firstUsed); + Assert.equal(500, lastUsed); + await promiseCountEntries(null, null, num => Assert.equal(num, 3)); + + // ===== 14 ===== + // Bump an entry, which updates its lastUsed field + testnum++; + await promiseUpdate({ + op: "bump", + fieldname: "field2", + value: "value2", + timesUsed: 20, + firstUsed: 100, + lastUsed: 500, + }); + results = await FormHistory.search(["timesUsed", "firstUsed", "lastUsed"], { + fieldname: "field2", + value: "value2", + }); + [timesUsed, firstUsed, lastUsed] = processFirstResult(results); + Assert.equal(21, timesUsed); + Assert.equal(100, firstUsed); + Assert.ok(lastUsed > 500); + await promiseCountEntries(null, null, num => Assert.equal(num, 3)); + + // ===== 15 ===== + // Bump an entry that does not exist + testnum++; + await promiseUpdate({ + op: "bump", + fieldname: "field3", + value: "value3", + timesUsed: 10, + firstUsed: 50, + lastUsed: 400, + }); + results = await FormHistory.search(["timesUsed", "firstUsed", "lastUsed"], { + fieldname: "field3", + value: "value3", + }); + [timesUsed, firstUsed, lastUsed] = processFirstResult(results); + Assert.equal(10, timesUsed); + Assert.equal(50, firstUsed); + Assert.equal(400, lastUsed); + await promiseCountEntries(null, null, num => Assert.equal(num, 4)); + + // ===== 16 ===== + // Bump an entry with a guid + testnum++; + results = await FormHistory.search(["guid"], { + fieldname: "field3", + value: "value3", + }); + guid = processFirstResult(results)[3]; + await promiseUpdate({ + op: "bump", + guid, + timesUsed: 20, + firstUsed: 55, + lastUsed: 400, + }); + results = await FormHistory.search(["timesUsed", "firstUsed", "lastUsed"], { + fieldname: "field3", + value: "value3", + }); + [timesUsed, firstUsed, lastUsed] = processFirstResult(results); + Assert.equal(11, timesUsed); + Assert.equal(50, firstUsed); + Assert.ok(lastUsed > 400); + await promiseCountEntries(null, null, num => Assert.equal(num, 4)); + + // ===== 17 ===== + // Remove an entry + testnum++; + await countDeletedEntries(7); + + results = await FormHistory.search(["guid"], { + fieldname: "field1", + value: "value1b", + }); + guid = processFirstResult(results)[3]; + + await promiseUpdate({ op: "remove", guid }); + await promiseCountEntries("field1", "modifiedValue", checkExists); + await promiseCountEntries("field1", "value1b", checkNotExists); + await promiseCountEntries(null, null, num => Assert.equal(num, 3)); + + await countDeletedEntries(8); + await checkTimeDeleted(guid, timeDeleted => Assert.ok(timeDeleted > 10000)); + + // ===== 18 ===== + // Add yet another single entry + testnum++; + await promiseUpdate({ + op: "add", + fieldname: "field4", + value: "value4", + timesUsed: 5, + firstUsed: 230, + lastUsed: 600, + }); + await promiseCountEntries(null, null, num => Assert.equal(num, 4)); + + // ===== 19 ===== + // Remove an entry by time + testnum++; + await promiseUpdate({ + op: "remove", + firstUsedStart: 60, + firstUsedEnd: 250, + }); + await promiseCountEntries("field1", "modifiedValue", checkExists); + await promiseCountEntries("field2", "value2", checkNotExists); + await promiseCountEntries("field3", "value3", checkExists); + await promiseCountEntries("field4", "value4", checkNotExists); + await promiseCountEntries(null, null, num => Assert.equal(num, 2)); + await countDeletedEntries(10); + + // ===== 20 ===== + // Bump multiple existing entries at once + testnum++; + + await promiseUpdate([ + { + op: "add", + fieldname: "field5", + value: "value5", + timesUsed: 5, + firstUsed: 230, + lastUsed: 600, + }, + { + op: "add", + fieldname: "field6", + value: "value6", + timesUsed: 12, + firstUsed: 430, + lastUsed: 700, + }, + ]); + await promiseCountEntries(null, null, num => Assert.equal(num, 4)); + + await promiseUpdate([ + { op: "bump", fieldname: "field5", value: "value5" }, + { op: "bump", fieldname: "field6", value: "value6" }, + ]); + results = await FormHistory.search( + ["fieldname", "timesUsed", "firstUsed", "lastUsed"], + {} + ); + + Assert.equal(6, results[2].timesUsed); + Assert.equal(13, results[3].timesUsed); + Assert.equal(230, results[2].firstUsed); + Assert.equal(430, results[3].firstUsed); + Assert.ok(results[2].lastUsed > 600); + Assert.ok(results[3].lastUsed > 700); + + await promiseCountEntries(null, null, num => Assert.equal(num, 4)); + + // ===== 21 ===== + // Check update fails if form history is disabled and the operation is not a + // pure removal. + testnum++; + Services.prefs.setBoolPref("browser.formfill.enable", false); + + // Cannot use arrow functions, see bug 1237961. + await Assert.rejects( + promiseUpdate({ op: "bump", fieldname: "field5", value: "value5" }), + /Form history is disabled, only remove operations are allowed/, + "bumping when form history is disabled should fail" + ); + await Assert.rejects( + promiseUpdate({ op: "add", fieldname: "field5", value: "value5" }), + /Form history is disabled, only remove operations are allowed/, + "Adding when form history is disabled should fail" + ); + await Assert.rejects( + promiseUpdate([ + { op: "update", fieldname: "field5", value: "value5" }, + { op: "remove", fieldname: "field5", value: "value5" }, + ]), + /Form history is disabled, only remove operations are allowed/, + "mixed operations when form history is disabled should fail" + ); + await Assert.rejects( + promiseUpdate([ + null, + undefined, + "", + 1, + {}, + { op: "remove", fieldname: "field5", value: "value5" }, + ]), + /Form history is disabled, only remove operations are allowed/, + "Invalid entries when form history is disabled should fail" + ); + + // Remove should work though. + await promiseUpdate([ + { op: "remove", fieldname: "field5", value: null }, + { op: "remove", fieldname: null, value: null }, + ]); + Services.prefs.clearUserPref("browser.formfill.enable"); + } catch (e) { + throw new Error(`FAILED in test #${testnum} -- ${e}`); + } finally { + FormHistory._supportsDeletedTable = oldSupportsDeletedTable; + dbConnection.asyncClose(do_test_finished); + } +}); + +function run_test() { + return run_next_test(); +} diff --git a/toolkit/components/satchel/test/unit/test_history_sources.js b/toolkit/components/satchel/test/unit/test_history_sources.js new file mode 100644 index 0000000000..a598a457be --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_history_sources.js @@ -0,0 +1,88 @@ +/* Any copyright is dedicated to the Public Domain. + * https://creativecommons.org/publicdomain/zero/1.0/ */ + +// Tests source usage in the form history API. + +add_task(async function () { + // Shorthands to improve test readability. + const count = FormHistoryTestUtils.count.bind(FormHistoryTestUtils); + async function search(fieldname, filters) { + let results1 = (await FormHistoryTestUtils.search(fieldname, filters)).map( + f => f.value + ); + // Check autocomplete returns the same value. + let results2 = ( + await FormHistoryTestUtils.autocomplete("va", fieldname, filters) + ).map(f => f.text); + Assert.deepEqual(results1, results2); + return results1; + } + + info("Sanity checks"); + Assert.equal(await count("field-A"), 0); + Assert.equal(await count("field-B"), 0); + await FormHistoryTestUtils.add("field-A", [{ value: "value-A" }]); + Assert.equal(await FormHistoryTestUtils.count("field-A"), 1); + Assert.deepEqual(await search("field-A"), ["value-A"]); + await FormHistoryTestUtils.remove("field-A", [{ value: "value-A" }]); + Assert.equal(await count("field-A"), 0); + + info("Test source for field-A"); + await FormHistoryTestUtils.add("field-A", [ + { value: "value-A", source: "test" }, + ]); + Assert.equal(await count("field-A"), 1); + Assert.deepEqual(await search("field-A"), ["value-A"]); + Assert.equal(await count("field-A", { source: "test" }), 1); + Assert.deepEqual(await search("field-A", { source: "test" }), ["value-A"]); + Assert.equal(await count("field-A", { source: "test2" }), 0); + Assert.deepEqual(await search("field-A", { source: "test2" }), []); + + info("Test source for field-B"); + await FormHistoryTestUtils.add("field-B", [ + { value: "value-B", source: "test" }, + ]); + Assert.equal(await count("field-B", { source: "test" }), 1); + Assert.equal(await count("field-B", { source: "test2" }), 0); + + info("Remove source"); + await FormHistoryTestUtils.add("field-B", [ + { value: "value-B", source: "test2" }, + ]); + Assert.equal(await count("field-B", { source: "test2" }), 1); + Assert.deepEqual(await search("field-B", { source: "test2" }), ["value-B"]); + await FormHistoryTestUtils.remove("field-B", [{ source: "test2" }]); + Assert.equal(await count("field-B", { source: "test2" }), 0); + Assert.deepEqual(await search("field-B", { source: "test2" }), []); + Assert.equal(await count("field-A"), 1); + Assert.deepEqual(await search("field-A"), ["value-A"]); + Assert.deepEqual(await search("field-A", { source: "test" }), ["value-A"]); + info("The other source should be untouched"); + Assert.equal(await count("field-B", { source: "test" }), 1); + Assert.deepEqual(await search("field-B", { source: "test" }), ["value-B"]); + Assert.equal(await count("field-B"), 1); + Assert.deepEqual(await search("field-B"), ["value-B"]); + + info("Clear field-A"); + await FormHistoryTestUtils.clear("field-A"); + Assert.equal(await count("field-A", { source: "test" }), 0); + Assert.equal(await count("field-A", { source: "test2" }), 0); + Assert.equal(await count("field-A"), 0); + Assert.equal(await count("field-B", { source: "test" }), 1); + Assert.equal(await count("field-B", { source: "test2" }), 0); + Assert.equal(await count("field-B"), 1); + + info("Clear All"); + await FormHistoryTestUtils.clear(); + Assert.equal(await count("field-B", { source: "test" }), 0); + Assert.equal(await count("field-B"), 0); + Assert.deepEqual(await search("field-A"), []); + Assert.deepEqual(await search("field-A", { source: "test" }), []); + Assert.deepEqual(await search("field-B"), []); + Assert.deepEqual(await search("field-B", { source: "test" }), []); + + info("Check there's no orphan sources"); + let db = await FormHistory.db; + let rows = await db.execute(`SELECT count(*) FROM moz_sources`); + Assert.equal(rows[0].getResultByIndex(0), 0, "There should be no orphans"); +}); diff --git a/toolkit/components/satchel/test/unit/test_notify.js b/toolkit/components/satchel/test/unit/test_notify.js new file mode 100644 index 0000000000..94be56f3f5 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_notify.js @@ -0,0 +1,171 @@ +/* + * Test suite for satchel notifications + * + * Tests notifications dispatched when modifying form history. + * + */ + +ChromeUtils.defineESModuleGetters(this, { + Preferences: "resource://gre/modules/Preferences.sys.mjs", + setTimeout: "resource://gre/modules/Timer.sys.mjs", +}); + +const TestObserver = { + observed: [], + QueryInterface: ChromeUtils.generateQI([ + "nsIObserver", + "nsISupportsWeakReference", + ]), + observe(subject, topic, data) { + if (subject instanceof Ci.nsISupportsString) { + subject = subject.toString(); + } + this.observed.push({ subject, topic, data }); + }, + reset() { + this.observed = []; + }, +}; + +const entry1 = ["entry1", "value1"]; +const entry2 = ["entry2", "value2"]; +const entry3 = ["entry3", "value3"]; + +add_setup(async () => { + await promiseUpdateEntry("remove", null, null); + const count = await promiseCountEntries(null, null); + Assert.ok(!count, "Checking initial DB is empty"); + + // Add the observer + Services.obs.addObserver(TestObserver, "satchel-storage-changed"); +}); + +add_task(async function addAndUpdateEntry() { + // Add + await promiseUpdateEntry("add", entry1[0], entry1[1]); + Assert.equal(TestObserver.observed.length, 1); + let { subject, data } = TestObserver.observed[0]; + Assert.equal(data, "formhistory-add"); + Assert.ok(isGUID.test(subject)); + + let count = await promiseCountEntries(entry1[0], entry1[1]); + Assert.equal(count, 1); + + // Update + TestObserver.reset(); + + await promiseUpdateEntry("update", entry1[0], entry1[1]); + Assert.equal(TestObserver.observed.length, 1); + ({ subject, data } = TestObserver.observed[0]); + Assert.equal(data, "formhistory-update"); + Assert.ok(isGUID.test(subject)); + + count = await promiseCountEntries(entry1[0], entry1[1]); + Assert.equal(count, 1); + + // Clean-up + await promiseUpdateEntry("remove", null, null); +}); + +add_task(async function removeEntry() { + TestObserver.reset(); + await promiseUpdateEntry("add", entry1[0], entry1[1]); + const guid = TestObserver.observed[0].subject; + TestObserver.reset(); + + await FormHistory.update({ + op: "remove", + fieldname: entry1[0], + value: entry1[1], + guid, + }); + Assert.equal(TestObserver.observed.length, 1); + const { subject, data } = TestObserver.observed[0]; + Assert.equal(data, "formhistory-remove"); + Assert.ok(isGUID.test(subject)); + + const count = await promiseCountEntries(entry1[0], entry1[1]); + Assert.equal(count, 0, "doesn't exist after remove"); +}); + +add_task(async function removeAllEntries() { + await promiseAddEntry(entry1[0], entry1[1]); + await promiseAddEntry(entry2[0], entry2[1]); + await promiseAddEntry(entry3[0], entry3[1]); + TestObserver.reset(); + + await promiseUpdateEntry("remove", null, null); + Assert.equal(TestObserver.observed.length, 3); + for (const notification of TestObserver.observed) { + const { subject, data } = notification; + Assert.equal(data, "formhistory-remove"); + Assert.ok(isGUID.test(subject)); + } + + const count = await promiseCountEntries(null, null); + Assert.equal(count, 0); +}); + +add_task(async function removeEntriesForName() { + await promiseAddEntry(entry1[0], entry1[1]); + await promiseAddEntry(entry2[0], entry2[1]); + await promiseAddEntry(entry3[0], entry3[1]); + TestObserver.reset(); + + await promiseUpdateEntry("remove", entry2[0], null); + Assert.equal(TestObserver.observed.length, 1); + const { subject, data } = TestObserver.observed[0]; + Assert.equal(data, "formhistory-remove"); + Assert.ok(isGUID.test(subject)); + + let count = await promiseCountEntries(entry2[0], entry2[1]); + Assert.equal(count, 0); + + count = await promiseCountEntries(null, null); + Assert.equal(count, 2, "the other entries are still there"); + + // Clean-up + await promiseUpdateEntry("remove", null, null); +}); + +add_task(async function removeEntriesByTimeframe() { + let timerPrecision = Preferences.get("privacy.reduceTimerPrecision"); + Preferences.set("privacy.reduceTimerPrecision", false); + + registerCleanupFunction(function () { + Preferences.set("privacy.reduceTimerPrecision", timerPrecision); + }); + + await promiseAddEntry(entry1[0], entry1[1]); + await promiseAddEntry(entry2[0], entry2[1]); + + const cutoffDate = Date.now(); + // eslint-disable-next-line mozilla/no-arbitrary-setTimeout + await new Promise(res => setTimeout(res, 10)); + + await promiseAddEntry(entry3[0], entry3[1]); + TestObserver.reset(); + + await FormHistory.update({ + op: "remove", + firstUsedStart: 10, + firstUsedEnd: cutoffDate * 1000, + }); + Assert.equal(TestObserver.observed.length, 2); + for (const notification of TestObserver.observed) { + const { subject, data } = notification; + Assert.equal(data, "formhistory-remove"); + Assert.ok(isGUID.test(subject)); + } + + const count = await promiseCountEntries(null, null); + Assert.equal(count, 1, "entry2 should still be there"); + + // Clean-up + await promiseUpdateEntry("remove", null, null); +}); + +add_task(async function teardown() { + await promiseUpdateEntry("remove", null, null); + Services.obs.removeObserver(TestObserver, "satchel-storage-changed"); +}); diff --git a/toolkit/components/satchel/test/unit/test_previous_result.js b/toolkit/components/satchel/test/unit/test_previous_result.js new file mode 100644 index 0000000000..a782832db7 --- /dev/null +++ b/toolkit/components/satchel/test/unit/test_previous_result.js @@ -0,0 +1,25 @@ +/* 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 aaaListener = { + onSearchResult(search, result) { + Assert.equal(result.searchString, "aaa"); + do_test_finished(); + }, +}; + +var aaListener = { + onSearchResult(search, result) { + Assert.equal(result.searchString, "aa"); + search.startSearch("aaa", "", result, aaaListener); + }, +}; + +function run_test() { + do_test_pending(); + let search = Cc[ + "@mozilla.org/autocomplete/search;1?name=form-history" + ].getService(Ci.nsIAutoCompleteSearch); + search.startSearch("aa", "", null, aaListener); +} diff --git a/toolkit/components/satchel/test/unit/xpcshell.ini b/toolkit/components/satchel/test/unit/xpcshell.ini new file mode 100644 index 0000000000..98d63dee25 --- /dev/null +++ b/toolkit/components/satchel/test/unit/xpcshell.ini @@ -0,0 +1,28 @@ +[DEFAULT] +head = head_satchel.js +tags = condprof +skip-if = toolkit == 'android' +support-files = + asyncformhistory_expire.sqlite + formhistory_1000.sqlite + formhistory_CORRUPT.sqlite + formhistory_apitest.sqlite + formhistory_autocomplete.sqlite + formhistory_v3.sqlite + formhistory_v3v4.sqlite + formhistory_v999a.sqlite + formhistory_v999b.sqlite + +[test_async_expire.js] +[test_autocomplete.js] +[test_db_corrupt.js] +[test_db_update_v4.js] +[test_db_update_v4b.js] +[test_db_update_v5.js] +skip-if = condprof # Bug 1769154 - not supported +[test_db_update_v999a.js] +[test_db_update_v999b.js] +[test_history_api.js] +[test_history_sources.js] +[test_notify.js] +[test_previous_result.js] diff --git a/toolkit/components/satchel/towel b/toolkit/components/satchel/towel new file mode 100644 index 0000000000..c26c7a8b28 --- /dev/null +++ b/toolkit/components/satchel/towel @@ -0,0 +1,5 @@ +"Any man who can hitch the length and breadth of the galaxy, rough it, +slum it, struggle against terrible odds, win through, and still knows +where his towel is is clearly a man to be reckoned with." + + - Douglas Adams |