Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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
new 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
new 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
new 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
new 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
new 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
new 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
new 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
new 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