diff options
Diffstat (limited to 'components/satchel/nsFormAutoComplete.js')
| -rw-r--r-- | components/satchel/nsFormAutoComplete.js | 623 |
1 files changed, 623 insertions, 0 deletions
diff --git a/components/satchel/nsFormAutoComplete.js b/components/satchel/nsFormAutoComplete.js new file mode 100644 index 000000000..41f7425bb --- /dev/null +++ b/components/satchel/nsFormAutoComplete.js @@ -0,0 +1,623 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "BrowserUtils", + "resource://gre/modules/BrowserUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Deprecated", + "resource://gre/modules/Deprecated.jsm"); + +function isAutocompleteDisabled(aField) { + if (aField.autocomplete !== "") { + return aField.autocomplete === "off"; + } + + return aField.form && 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 with the following properties: + * + * formField (DOM node): + * A DOM node that we're requesting form history for. + * + * inputName (string): + * 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. + */ +function FormHistoryClient({ formField, inputName }) { + if (formField && inputName != this.SEARCHBAR_ID) { + let window = formField.ownerDocument.defaultView; + let topDocShell = window.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDocShell) + .sameTypeRootTreeItem + .QueryInterface(Ci.nsIDocShell); + this.mm = topDocShell.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIContentFrameMessageManager); + } else { + if (inputName == this.SEARCHBAR_ID) { + if (formField) { + throw new Error("FormHistoryClient constructed with both a " + + "formField and an inputName. This is not " + + "supported, and only empty results will be " + + "returned."); + } + } + this.mm = Services.cpmm; + } + + this.inputName = inputName; + this.id = FormHistoryClient.nextRequestID++; +} + +FormHistoryClient.prototype = { + SEARCHBAR_ID: "searchbar-history", + + // It is assumed that nsFormAutoComplete only uses / cares about + // one FormHistoryClient at a time, and won't attempt to have + // multiple in-flight searches occurring with the same FormHistoryClient. + // We use an ID number per instantiated FormHistoryClient to make + // sure we only respond to messages that were meant for us. + id: 0, + callback: null, + inputName: "", + mm: null, + + /** + * Query FormHistory for some results. + * + * @param searchString (string) + * The string to search FormHistory for. See + * FormHistory.getAutoCompleteResults. + * @param params (object) + * An Object with search properties. See + * FormHistory.getAutoCompleteResults. + * @param callback + * A callback function that will take a single + * argument (the found entries). + */ + requestAutoCompleteResults(searchString, params, callback) { + this.mm.sendAsyncMessage("FormHistory:AutoCompleteSearchAsync", { + id: this.id, + searchString, + params, + }); + + this.mm.addMessageListener("FormHistory:AutoCompleteSearchResults", + this); + this.callback = callback; + }, + + /** + * Cancel an in-flight results request. This ensures that the + * callback that requestAutoCompleteResults was passed is never + * called from this FormHistoryClient. + */ + cancel() { + this.clearListeners(); + }, + + /** + * Remove an item from FormHistory. + * + * @param value (string) + * + * The value to remove for this particular + * field. + */ + remove(value) { + this.mm.sendAsyncMessage("FormHistory:RemoveEntry", { + inputName: this.inputName, + value, + }); + }, + + // Private methods + + receiveMessage(msg) { + let { id, results } = msg.data; + if (id != this.id) { + return; + } + if (!this.callback) { + Cu.reportError("FormHistoryClient received message with no " + + "callback"); + return; + } + this.callback(results); + this.clearListeners(); + }, + + clearListeners() { + this.mm.removeMessageListener("FormHistory:AutoCompleteSearchResults", + this); + this.callback = null; + }, +}; + +FormHistoryClient.nextRequestID = 1; + + +function FormAutoComplete() { + this.init(); +} + +/** + * FormAutoComplete + * + * Implements the nsIFormAutoComplete interface in the main process. + */ +FormAutoComplete.prototype = { + classID : Components.ID("{c11c21b2-71c9-4f87-a0f8-5e13f50495fd}"), + QueryInterface : XPCOMUtils.generateQI([Ci.nsIFormAutoComplete, Ci.nsISupportsWeakReference]), + + _prefBranch : null, + _debug : true, // mirrors browser.formfill.debug + _enabled : true, // mirrors browser.formfill.enable preference + _agedWeight : 2, + _bucketSize : 1, + _maxTimeGroupings : 25, + _timeGroupingSize : 7 * 24 * 60 * 60 * 1000 * 1000, + _expireDays : null, + _boundaryWeight : 25, + _prefixWeight : 5, + + // 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, + + init : function() { + // 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"); + this._agedWeight = this._prefBranch.getIntPref("agedWeight"); + this._bucketSize = this._prefBranch.getIntPref("bucketSize"); + this._maxTimeGroupings = this._prefBranch.getIntPref("maxTimeGroupings"); + this._timeGroupingSize = this._prefBranch.getIntPref("timeGroupingSize") * 1000 * 1000; + this._expireDays = this._prefBranch.getIntPref("expire_days"); + }, + + observer : { + _self : null, + + QueryInterface : XPCOMUtils.generateQI([Ci.nsIObserver, + Ci.nsISupportsWeakReference]), + + observe : function (subject, topic, data) { + let self = this._self; + if (topic == "nsPref:changed") { + let prefName = data; + self.log("got change to " + prefName + " preference"); + + switch (prefName) { + case "agedWeight": + self._agedWeight = self._prefBranch.getIntPref(prefName); + break; + case "debug": + self._debug = self._prefBranch.getBoolPref(prefName); + break; + case "enable": + self._enabled = self._prefBranch.getBoolPref(prefName); + break; + case "maxTimeGroupings": + self._maxTimeGroupings = self._prefBranch.getIntPref(prefName); + break; + case "timeGroupingSize": + self._timeGroupingSize = self._prefBranch.getIntPref(prefName) * 1000 * 1000; + break; + case "bucketSize": + self._bucketSize = self._prefBranch.getIntPref(prefName); + break; + case "boundaryWeight": + self._boundaryWeight = self._prefBranch.getIntPref(prefName); + break; + case "prefixWeight": + self._prefixWeight = self._prefBranch.getIntPref(prefName); + break; + default: + self.log("Oops! Pref not handled, change ignored."); + } + } + } + }, + + // 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 : function (message) { + if (!this._debug) + return; + dump("FormAutoComplete: " + message + "\n"); + Services.console.logStringMessage("FormAutoComplete: " + message); + }, + + /* + * autoCompleteSearchAsync + * + * aInputName -- |name| attribute from the form input being autocompleted. + * aUntrimmedSearchString -- current value of the input + * aField -- nsIDOMHTMLInputElement 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. + */ + autoCompleteSearchAsync : function (aInputName, + aUntrimmedSearchString, + aField, + aPreviousResult, + aDatalistResult, + aListener) { + function sortBytotalScore (a, b) { + return b.totalScore - a.totalScore; + } + + // Guard against void DOM strings filtering into this code. + if (typeof aInputName === "object") { + aInputName = ""; + } + if (typeof aUntrimmedSearchString === "object") { + aUntrimmedSearchString = ""; + } + + let client = new FormHistoryClient({ formField: aField, inputName: aInputName }); + + // If we have datalist results, they become our "empty" result. + let emptyResult = aDatalistResult || + new FormAutoCompleteResult(client, [], + aInputName, + aUntrimmedSearchString, + null); + if (!this._enabled) { + if (aListener) { + aListener.onSearchCompletion(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'); + if (aListener) { + aListener.onSearchCompletion(emptyResult); + } + return; + } + + if (aField && isAutocompleteDisabled(aField)) { + this.log('autoCompleteSearch not allowed due to autcomplete=off'); + if (aListener) { + aListener.onSearchCompletion(emptyResult); + } + return; + } + + this.log("AutoCompleteSearch invoked. Search is: " + aUntrimmedSearchString); + let 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 + if (aPreviousResult && aPreviousResult.searchString.trim().length > 1 && + searchString.indexOf(aPreviousResult.searchString.trim().toLowerCase()) >= 0) { + this.log("Using previous autocomplete result"); + let result = aPreviousResult; + let 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._values and only the results from + // form history in wrappedResult.entries. + // First, grab the entire list of old results. + let allResults = wrappedResult._labels; + let datalistResults, datalistLabels; + 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> + let oldLabels = allResults.slice(wrappedResult.entries.length); + let oldValues = wrappedResult._values.slice(wrappedResult.entries.length); + + datalistLabels = []; + datalistResults = []; + for (let i = 0; i < oldLabels.length; ++i) { + if (oldLabels[i].toLowerCase().includes(searchString)) { + datalistLabels.push(oldLabels[i]); + datalistResults.push(oldValues[i]); + } + } + } + + let 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 entries = wrappedResult.entries; + let filteredEntries = []; + for (let i = 0; i < entries.length; i++) { + let entry = entries[i]; + // 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.indexOf(tok) < 0)) + continue; + this._calculateScore(entry, searchString, searchTokens); + this.log("Reusing autocomplete entry '" + entry.text + + "' (" + entry.frecency +" / " + entry.totalScore + ")"); + filteredEntries.push(entry); + } + filteredEntries.sort(sortBytotalScore); + wrappedResult.entries = filteredEntries; + + // If we had datalistResults, re-merge them back into the filtered + // entries. + if (datalistResults) { + filteredEntries = filteredEntries.map(elt => elt.text); + + let comments = new Array(filteredEntries.length + datalistResults.length).fill(""); + comments[filteredEntries.length] = "separator"; + + // History entries don't have labels (their labels would be read + // from their values). Pad out the labels array so the datalist + // results (which do have separate values and labels) line up. + datalistLabels = new Array(filteredEntries.length).fill("").concat(datalistLabels); + wrappedResult._values = filteredEntries.concat(datalistResults); + wrappedResult._labels = datalistLabels; + wrappedResult._comments = comments; + } + + if (aListener) { + aListener.onSearchCompletion(result); + } + } else { + this.log("Creating new autocomplete search result."); + + // Start with an empty list. + let result = aDatalistResult ? + new FormAutoCompleteResult(client, [], aInputName, aUntrimmedSearchString, null) : + emptyResult; + + let processEntry = (aEntries) => { + if (aField && aField.maxLength > -1) { + result.entries = + aEntries.filter(function (el) { return el.text.length <= aField.maxLength; }); + } else { + result.entries = aEntries; + } + + if (aDatalistResult && aDatalistResult.matchCount > 0) { + result = this.mergeResults(result, aDatalistResult); + } + + if (aListener) { + aListener.onSearchCompletion(result); + } + } + + this.getAutoCompleteValues(client, aInputName, searchString, processEntry); + } + }, + + mergeResults(historyResult, datalistResult) { + let values = datalistResult.wrappedJSObject._values; + let labels = datalistResult.wrappedJSObject._labels; + let comments = new Array(values.length).fill(""); + + // historyResult will be null if form autocomplete is disabled. We + // still want the list values to display. + let entries = historyResult.wrappedJSObject.entries; + let historyResults = entries.map(entry => entry.text); + let historyComments = new Array(entries.length).fill(""); + + // now put the history results above the datalist suggestions + let finalValues = historyResults.concat(values); + let finalLabels = historyResults.concat(labels); + let finalComments = historyComments.concat(comments); + + // 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. + let {FormAutoCompleteResult} = Cu.import("resource://gre/modules/nsFormAutoCompleteResult.jsm", {}); + return new FormAutoCompleteResult(datalistResult.searchString, + Ci.nsIAutoCompleteResult.RESULT_SUCCESS, + 0, "", finalValues, finalLabels, + finalComments, historyResult); + }, + + stopAutoCompleteSearch : function () { + 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 + * 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 : function (client, fieldName, searchString, callback) { + let params = { + agedWeight: this._agedWeight, + bucketSize: this._bucketSize, + expiryDate: 1000 * (Date.now() - this._expireDays * 24 * 60 * 60 * 1000), + fieldname: fieldName, + maxTimeGroupings: this._maxTimeGroupings, + timeGroupingSize: this._timeGroupingSize, + prefixWeight: this._prefixWeight, + boundaryWeight: this._boundaryWeight + } + + 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 : function (entry, aSearchString, searchTokens) { + let boundaryCalc = 0; + // for each word, calculate word boundary weights + for (let token of searchTokens) { + boundaryCalc += (entry.textLowerCase.indexOf(token) == 0); + boundaryCalc += (entry.textLowerCase.indexOf(" " + token) >= 0); + } + boundaryCalc = boundaryCalc * this._boundaryWeight; + // now add more weight if we have a traditional prefix match and + // multiply boundary bonuses by boundary weight + boundaryCalc += this._prefixWeight * + (entry.textLowerCase. + indexOf(aSearchString) == 0); + entry.totalScore = Math.round(entry.frecency * Math.max(1, boundaryCalc)); + } + +}; // end of FormAutoComplete implementation + +// nsIAutoCompleteResult implementation +function FormAutoCompleteResult(client, + entries, + fieldName, + searchString, + messageManager) { + this.client = client; + this.entries = entries; + this.fieldName = fieldName; + this.searchString = searchString; + this.messageManager = messageManager; +} + +FormAutoCompleteResult.prototype = { + QueryInterface : XPCOMUtils.generateQI([Ci.nsIAutoCompleteResult, + Ci.nsISupportsWeakReference]), + + // private + client : null, + entries : null, + fieldName : null, + + _checkIndexBounds : function (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 == 0) + return -1; + return 0; + }, + get searchResult() { + if (this.entries.length == 0) + return Ci.nsIAutoCompleteResult.RESULT_NOMATCH; + return Ci.nsIAutoCompleteResult.RESULT_SUCCESS; + }, + get matchCount() { + return this.entries.length; + }, + + getValueAt : function (index) { + this._checkIndexBounds(index); + return this.entries[index].text; + }, + + getLabelAt: function(index) { + return this.getValueAt(index); + }, + + getCommentAt : function (index) { + this._checkIndexBounds(index); + return ""; + }, + + getStyleAt : function (index) { + this._checkIndexBounds(index); + return ""; + }, + + getImageAt : function (index) { + this._checkIndexBounds(index); + return ""; + }, + + getFinalCompleteValueAt : function (index) { + return this.getValueAt(index); + }, + + removeValueAt : function (index, removeFromDB) { + this._checkIndexBounds(index); + + let [removedEntry] = this.entries.splice(index, 1); + + if (removeFromDB) { + this.client.remove(removedEntry.text); + } + } +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([FormAutoComplete]); |