summaryrefslogtreecommitdiffstats
path: root/browser/components/urlbar/UrlbarProviderPlaces.sys.mjs
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--browser/components/urlbar/UrlbarProviderPlaces.sys.mjs1536
1 files changed, 1536 insertions, 0 deletions
diff --git a/browser/components/urlbar/UrlbarProviderPlaces.sys.mjs b/browser/components/urlbar/UrlbarProviderPlaces.sys.mjs
new file mode 100644
index 0000000000..0504d1ebe4
--- /dev/null
+++ b/browser/components/urlbar/UrlbarProviderPlaces.sys.mjs
@@ -0,0 +1,1536 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 sts=2 expandtab
+ * 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 complexity: ["error", 53] */
+
+/**
+ * This module exports a provider that provides results from the Places
+ * database, including history, bookmarks, and open tabs.
+ */
+// Constants
+
+// AutoComplete query type constants.
+// Describes the various types of queries that we can process rows for.
+const QUERYTYPE_FILTERED = 0;
+
+// The default frecency value used when inserting matches with unknown frecency.
+const FRECENCY_DEFAULT = 1000;
+
+// The result is notified on a delay, to avoid rebuilding the panel at every match.
+const NOTIFYRESULT_DELAY_MS = 16;
+
+// Sqlite result row index constants.
+const QUERYINDEX_QUERYTYPE = 0;
+const QUERYINDEX_URL = 1;
+const QUERYINDEX_TITLE = 2;
+const QUERYINDEX_BOOKMARKED = 3;
+const QUERYINDEX_BOOKMARKTITLE = 4;
+const QUERYINDEX_TAGS = 5;
+// QUERYINDEX_VISITCOUNT = 6;
+// QUERYINDEX_TYPED = 7;
+const QUERYINDEX_PLACEID = 8;
+const QUERYINDEX_SWITCHTAB = 9;
+const QUERYINDEX_FRECENCY = 10;
+
+// This SQL query fragment provides the following:
+// - whether the entry is bookmarked (QUERYINDEX_BOOKMARKED)
+// - the bookmark title, if it is a bookmark (QUERYINDEX_BOOKMARKTITLE)
+// - the tags associated with a bookmarked entry (QUERYINDEX_TAGS)
+const SQL_BOOKMARK_TAGS_FRAGMENT = `EXISTS(SELECT 1 FROM moz_bookmarks WHERE fk = h.id) AS bookmarked,
+ ( SELECT title FROM moz_bookmarks WHERE fk = h.id AND title NOTNULL
+ ORDER BY lastModified DESC LIMIT 1
+ ) AS btitle,
+ ( SELECT GROUP_CONCAT(t.title, ', ')
+ FROM moz_bookmarks b
+ JOIN moz_bookmarks t ON t.id = +b.parent AND t.parent = :parent
+ WHERE b.fk = h.id
+ ) AS tags`;
+
+// TODO bug 412736: in case of a frecency tie, we might break it with h.typed
+// and h.visit_count. That is slower though, so not doing it yet...
+// NB: as a slight performance optimization, we only evaluate the "bookmarked"
+// condition once, and avoid evaluating "btitle" and "tags" when it is false.
+function defaultQuery(conditions = "") {
+ let query = `SELECT :query_type, h.url, h.title, ${SQL_BOOKMARK_TAGS_FRAGMENT},
+ h.visit_count, h.typed, h.id, t.open_count, h.frecency
+ FROM moz_places h
+ LEFT JOIN moz_openpages_temp t
+ ON t.url = h.url
+ AND t.userContextId = :userContextId
+ WHERE h.frecency <> 0
+ AND CASE WHEN bookmarked
+ THEN
+ AUTOCOMPLETE_MATCH(:searchString, h.url,
+ IFNULL(btitle, h.title), tags,
+ h.visit_count, h.typed,
+ 1, t.open_count,
+ :matchBehavior, :searchBehavior, NULL)
+ ELSE
+ AUTOCOMPLETE_MATCH(:searchString, h.url,
+ h.title, '',
+ h.visit_count, h.typed,
+ 0, t.open_count,
+ :matchBehavior, :searchBehavior, NULL)
+ END
+ ${conditions ? "AND" : ""} ${conditions}
+ ORDER BY h.frecency DESC, h.id DESC
+ LIMIT :maxResults`;
+ return query;
+}
+
+const SQL_SWITCHTAB_QUERY = `SELECT :query_type, t.url, t.url, NULL, NULL, NULL, NULL, NULL, NULL,
+ t.open_count, NULL
+ FROM moz_openpages_temp t
+ LEFT JOIN moz_places h ON h.url_hash = hash(t.url) AND h.url = t.url
+ WHERE h.id IS NULL
+ AND t.userContextId = :userContextId
+ AND AUTOCOMPLETE_MATCH(:searchString, t.url, t.url, NULL,
+ NULL, NULL, NULL, t.open_count,
+ :matchBehavior, :searchBehavior, NULL)
+ ORDER BY t.ROWID DESC
+ LIMIT :maxResults`;
+
+// Getters
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+import {
+ UrlbarProvider,
+ UrlbarUtils,
+} from "resource:///modules/UrlbarUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ KeywordUtils: "resource://gre/modules/KeywordUtils.sys.mjs",
+ PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
+ PromiseUtils: "resource://gre/modules/PromiseUtils.sys.mjs",
+ Sqlite: "resource://gre/modules/Sqlite.sys.mjs",
+ UrlbarPrefs: "resource:///modules/UrlbarPrefs.sys.mjs",
+ UrlbarProviderOpenTabs: "resource:///modules/UrlbarProviderOpenTabs.sys.mjs",
+ UrlbarProvidersManager: "resource:///modules/UrlbarProvidersManager.sys.mjs",
+ UrlbarResult: "resource:///modules/UrlbarResult.sys.mjs",
+ UrlbarSearchUtils: "resource:///modules/UrlbarSearchUtils.sys.mjs",
+ UrlbarTokenizer: "resource:///modules/UrlbarTokenizer.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+ ObjectUtils: "resource://gre/modules/ObjectUtils.jsm",
+});
+
+function setTimeout(callback, ms) {
+ let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+ timer.initWithCallback(callback, ms, timer.TYPE_ONE_SHOT);
+ return timer;
+}
+
+// Maps restriction character types to textual behaviors.
+XPCOMUtils.defineLazyGetter(lazy, "typeToBehaviorMap", () => {
+ return new Map([
+ [lazy.UrlbarTokenizer.TYPE.RESTRICT_HISTORY, "history"],
+ [lazy.UrlbarTokenizer.TYPE.RESTRICT_BOOKMARK, "bookmark"],
+ [lazy.UrlbarTokenizer.TYPE.RESTRICT_TAG, "tag"],
+ [lazy.UrlbarTokenizer.TYPE.RESTRICT_OPENPAGE, "openpage"],
+ [lazy.UrlbarTokenizer.TYPE.RESTRICT_SEARCH, "search"],
+ [lazy.UrlbarTokenizer.TYPE.RESTRICT_TITLE, "title"],
+ [lazy.UrlbarTokenizer.TYPE.RESTRICT_URL, "url"],
+ ]);
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "sourceToBehaviorMap", () => {
+ return new Map([
+ [UrlbarUtils.RESULT_SOURCE.HISTORY, "history"],
+ [UrlbarUtils.RESULT_SOURCE.BOOKMARKS, "bookmark"],
+ [UrlbarUtils.RESULT_SOURCE.TABS, "openpage"],
+ [UrlbarUtils.RESULT_SOURCE.SEARCH, "search"],
+ ]);
+});
+
+// Helper functions
+
+/**
+ * Returns the key to be used for a match in a map for the purposes of removing
+ * duplicate entries - any 2 matches that should be considered the same should
+ * return the same key. The type of the returned key depends on the type of the
+ * match, so don't assume you can compare keys using ==. Instead, use
+ * ObjectUtils.deepEqual().
+ *
+ * @param {object} match
+ * The match object.
+ * @returns {value} Some opaque key object. Use ObjectUtils.deepEqual() to
+ * compare keys.
+ */
+function makeKeyForMatch(match) {
+ let key, prefix;
+ let action = lazy.PlacesUtils.parseActionUrl(match.value);
+ if (!action) {
+ [key, prefix] = UrlbarUtils.stripPrefixAndTrim(match.value, {
+ stripHttp: true,
+ stripHttps: true,
+ stripWww: true,
+ trimSlash: true,
+ trimEmptyQuery: true,
+ trimEmptyHash: true,
+ });
+ return [key, prefix, null];
+ }
+
+ switch (action.type) {
+ case "searchengine":
+ // We want to exclude search suggestion matches that simply echo back the
+ // query string in the heuristic result. For example, if the user types
+ // "@engine test", we want to exclude a "test" suggestion match.
+ key = [
+ action.type,
+ action.params.engineName,
+ (
+ action.params.searchSuggestion || action.params.searchQuery
+ ).toLocaleLowerCase(),
+ ];
+ break;
+ default:
+ [key, prefix] = UrlbarUtils.stripPrefixAndTrim(
+ action.params.url || match.value,
+ {
+ stripHttp: true,
+ stripHttps: true,
+ stripWww: true,
+ trimEmptyQuery: true,
+ trimSlash: true,
+ }
+ );
+ break;
+ }
+
+ return [key, prefix, action];
+}
+
+/**
+ * Makes a moz-action url for the given action and set of parameters.
+ *
+ * @param {string} type
+ * The action type.
+ * @param {object} params
+ * A JS object of action params.
+ * @returns {string} A moz-action url as a string.
+ */
+function makeActionUrl(type, params) {
+ let encodedParams = {};
+ for (let key in params) {
+ // Strip null or undefined.
+ // Regardless, don't encode them or they would be converted to a string.
+ if (params[key] === null || params[key] === undefined) {
+ continue;
+ }
+ encodedParams[key] = encodeURIComponent(params[key]);
+ }
+ return `moz-action:${type},${JSON.stringify(encodedParams)}`;
+}
+
+/**
+ * Converts an array of legacy match objects into UrlbarResults.
+ * Note that at every call we get the full set of results, included the
+ * previously returned ones, and new results may be inserted in the middle.
+ * This means we could sort these wrongly, the muxer should take care of it.
+ *
+ * @param {UrlbarQueryContext} context the query context.
+ * @param {Array} matches The match objects.
+ * @param {set} urls a Set containing all the found urls, used to discard
+ * already added results.
+ * @returns {Array} converted results
+ */
+function convertLegacyMatches(context, matches, urls) {
+ let results = [];
+ for (let match of matches) {
+ // First, let's check if we already added this result.
+ // `matches` always contains all of the results, includes ones
+ // we may have added already. This means we'll end up adding things in the
+ // wrong order here, but that's a task for the UrlbarMuxer.
+ let url = match.finalCompleteValue || match.value;
+ if (urls.has(url)) {
+ continue;
+ }
+ urls.add(url);
+ let result = makeUrlbarResult(context.tokens, {
+ url,
+ // `match.icon` is an empty string if there is no icon. Use undefined
+ // instead so that tests can be simplified by not including `icon: ""` in
+ // all their payloads.
+ icon: match.icon || undefined,
+ style: match.style,
+ comment: match.comment,
+ firstToken: context.tokens[0],
+ });
+ // Should not happen, but better safe than sorry.
+ if (!result) {
+ continue;
+ }
+
+ results.push(result);
+ }
+ return results;
+}
+
+/**
+ * Creates a new UrlbarResult from the provided data.
+ *
+ * @param {Array} tokens the search tokens.
+ * @param {object} info includes properties from the legacy result.
+ * @returns {object} an UrlbarResult
+ */
+function makeUrlbarResult(tokens, info) {
+ let action = lazy.PlacesUtils.parseActionUrl(info.url);
+ if (action) {
+ switch (action.type) {
+ case "searchengine":
+ // Return a form history result.
+ return new lazy.UrlbarResult(
+ UrlbarUtils.RESULT_TYPE.SEARCH,
+ UrlbarUtils.RESULT_SOURCE.HISTORY,
+ ...lazy.UrlbarResult.payloadAndSimpleHighlights(tokens, {
+ engine: action.params.engineName,
+ suggestion: [
+ action.params.searchSuggestion,
+ UrlbarUtils.HIGHLIGHT.SUGGESTED,
+ ],
+ lowerCaseSuggestion:
+ action.params.searchSuggestion.toLocaleLowerCase(),
+ })
+ );
+ case "switchtab":
+ return new lazy.UrlbarResult(
+ UrlbarUtils.RESULT_TYPE.TAB_SWITCH,
+ UrlbarUtils.RESULT_SOURCE.TABS,
+ ...lazy.UrlbarResult.payloadAndSimpleHighlights(tokens, {
+ url: [action.params.url, UrlbarUtils.HIGHLIGHT.TYPED],
+ title: [info.comment, UrlbarUtils.HIGHLIGHT.TYPED],
+ icon: info.icon,
+ })
+ );
+ case "visiturl":
+ return new lazy.UrlbarResult(
+ UrlbarUtils.RESULT_TYPE.URL,
+ UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
+ ...lazy.UrlbarResult.payloadAndSimpleHighlights(tokens, {
+ title: [info.comment, UrlbarUtils.HIGHLIGHT.TYPED],
+ url: [action.params.url, UrlbarUtils.HIGHLIGHT.TYPED],
+ icon: info.icon,
+ })
+ );
+ default:
+ console.error(`Unexpected action type: ${action.type}`);
+ return null;
+ }
+ }
+
+ // This is a normal url/title tuple.
+ let source;
+ let tags = [];
+ let comment = info.comment;
+
+ // The legacy autocomplete result may return "bookmark", "bookmark-tag" or
+ // "tag". In the last case it should not be considered a bookmark, but an
+ // history item with tags. We don't show tags for non bookmarked items though.
+ if (info.style.includes("bookmark")) {
+ source = UrlbarUtils.RESULT_SOURCE.BOOKMARKS;
+ } else {
+ source = UrlbarUtils.RESULT_SOURCE.HISTORY;
+ }
+
+ // If the style indicates that the result is tagged, then the tags are
+ // included in the title, and we must extract them.
+ if (info.style.includes("tag")) {
+ [comment, tags] = info.comment.split(UrlbarUtils.TITLE_TAGS_SEPARATOR);
+
+ // However, as mentioned above, we don't want to show tags for non-
+ // bookmarked items, so we include tags in the final result only if it's
+ // bookmarked, and we drop the tags otherwise.
+ if (source != UrlbarUtils.RESULT_SOURCE.BOOKMARKS) {
+ tags = "";
+ }
+
+ // Tags are separated by a comma and in a random order.
+ // We should also just include tags that match the searchString.
+ tags = tags
+ .split(",")
+ .map(t => t.trim())
+ .filter(tag => {
+ let lowerCaseTag = tag.toLocaleLowerCase();
+ return tokens.some(token =>
+ lowerCaseTag.includes(token.lowerCaseValue)
+ );
+ })
+ .sort();
+ }
+
+ return new lazy.UrlbarResult(
+ UrlbarUtils.RESULT_TYPE.URL,
+ source,
+ ...lazy.UrlbarResult.payloadAndSimpleHighlights(tokens, {
+ url: [info.url, UrlbarUtils.HIGHLIGHT.TYPED],
+ icon: info.icon,
+ title: [comment, UrlbarUtils.HIGHLIGHT.TYPED],
+ tags: [tags, UrlbarUtils.HIGHLIGHT.TYPED],
+ })
+ );
+}
+
+const MATCH_TYPE = {
+ HEURISTIC: "heuristic",
+ GENERAL: "general",
+ SUGGESTION: "suggestion",
+ EXTENSION: "extension",
+};
+
+/**
+ * Manages a single instance of a Places search.
+ *
+ * @param {UrlbarQueryContext} queryContext
+ * The query context.
+ * @param {Function} listener
+ * Called as: `listener(matches, searchOngoing)`
+ * @param {PlacesProvider} provider
+ * The singleton that contains Places information
+ */
+function Search(queryContext, listener, provider) {
+ // We want to store the original string for case sensitive searches.
+ this._originalSearchString = queryContext.searchString;
+ this._trimmedOriginalSearchString = queryContext.trimmedSearchString;
+ let unescapedSearchString = UrlbarUtils.unEscapeURIForUI(
+ this._trimmedOriginalSearchString
+ );
+ // We want to make sure "about:" is not stripped as a prefix so that the
+ // about pages provider will run and ultimately only suggest about pages when
+ // a user types "about:" into the address bar.
+ let prefix, suffix;
+ if (unescapedSearchString.startsWith("about:")) {
+ prefix = "";
+ suffix = unescapedSearchString;
+ } else {
+ [prefix, suffix] = UrlbarUtils.stripURLPrefix(unescapedSearchString);
+ }
+ this._searchString = suffix;
+ this._strippedPrefix = prefix.toLowerCase();
+
+ this._matchBehavior = Ci.mozIPlacesAutoComplete.MATCH_BOUNDARY;
+ // Set the default behavior for this search.
+ this._behavior = this._searchString
+ ? lazy.UrlbarPrefs.get("defaultBehavior")
+ : this._emptySearchDefaultBehavior;
+
+ this._inPrivateWindow = queryContext.isPrivate;
+ this._prohibitAutoFill = !queryContext.allowAutofill;
+ this._maxResults = queryContext.maxResults;
+ this._userContextId = queryContext.userContextId;
+ this._currentPage = queryContext.currentPage;
+ this._searchModeEngine = queryContext.searchMode?.engineName;
+ this._searchMode = queryContext.searchMode;
+ if (this._searchModeEngine) {
+ // Filter Places results on host.
+ let engine = Services.search.getEngineByName(this._searchModeEngine);
+ this._filterOnHost = engine.searchUrlDomain;
+ }
+
+ this._userContextId =
+ lazy.UrlbarProviderOpenTabs.getUserContextIdForOpenPagesTable(
+ this._userContextId,
+ this._inPrivateWindow
+ );
+
+ // Use the original string here, not the stripped one, so the tokenizer can
+ // properly recognize token types.
+ let { tokens } = lazy.UrlbarTokenizer.tokenize({
+ searchString: unescapedSearchString,
+ trimmedSearchString: unescapedSearchString.trim(),
+ });
+
+ // This allows to handle leading or trailing restriction characters specially.
+ this._leadingRestrictionToken = null;
+ if (tokens.length) {
+ if (
+ lazy.UrlbarTokenizer.isRestrictionToken(tokens[0]) &&
+ (tokens.length > 1 ||
+ tokens[0].type == lazy.UrlbarTokenizer.TYPE.RESTRICT_SEARCH)
+ ) {
+ this._leadingRestrictionToken = tokens[0].value;
+ }
+
+ // Check if the first token has a strippable prefix other than "about:"
+ // and remove it, but don't create an empty token. We preserve "about:"
+ // so that the about pages provider will run and ultimately only suggest
+ // about pages when a user types "about:" into the address bar.
+ if (
+ prefix &&
+ prefix != "about:" &&
+ tokens[0].value.length > prefix.length
+ ) {
+ tokens[0].value = tokens[0].value.substring(prefix.length);
+ }
+ }
+
+ // Eventually filter restriction tokens. In general it's a good idea, but if
+ // the consumer requested search mode, we should use the full string to avoid
+ // ignoring valid tokens.
+ this._searchTokens =
+ !queryContext || queryContext.restrictToken
+ ? this.filterTokens(tokens)
+ : tokens;
+
+ // The behavior can be set through:
+ // 1. a specific restrictSource in the QueryContext
+ // 2. typed restriction tokens
+ if (
+ queryContext &&
+ queryContext.restrictSource &&
+ lazy.sourceToBehaviorMap.has(queryContext.restrictSource)
+ ) {
+ this._behavior = 0;
+ this.setBehavior("restrict");
+ let behavior = lazy.sourceToBehaviorMap.get(queryContext.restrictSource);
+ this.setBehavior(behavior);
+
+ // When we are in restrict mode, all the tokens are valid for searching, so
+ // there is no _heuristicToken.
+ this._heuristicToken = null;
+ } else {
+ // The heuristic token is the first filtered search token, but only when it's
+ // actually the first thing in the search string. If a prefix or restriction
+ // character occurs first, then the heurstic token is null. We use the
+ // heuristic token to help determine the heuristic result.
+ let firstToken = !!this._searchTokens.length && this._searchTokens[0].value;
+ this._heuristicToken =
+ firstToken && this._trimmedOriginalSearchString.startsWith(firstToken)
+ ? firstToken
+ : null;
+ }
+
+ // Set the right JavaScript behavior based on our preference. Note that the
+ // preference is whether or not we should filter JavaScript, and the
+ // behavior is if we should search it or not.
+ if (!lazy.UrlbarPrefs.get("filter.javascript")) {
+ this.setBehavior("javascript");
+ }
+
+ this._listener = listener;
+ this._provider = provider;
+ this._matches = [];
+
+ // These are used to avoid adding duplicate entries to the results.
+ this._usedURLs = [];
+ this._usedPlaceIds = new Set();
+
+ // Counters for the number of results per MATCH_TYPE.
+ this._counts = Object.values(MATCH_TYPE).reduce((o, p) => {
+ o[p] = 0;
+ return o;
+ }, {});
+}
+
+Search.prototype = {
+ /**
+ * Enables the desired AutoComplete behavior.
+ *
+ * @param {string} type
+ * The behavior type to set.
+ */
+ setBehavior(type) {
+ type = type.toUpperCase();
+ this._behavior |= Ci.mozIPlacesAutoComplete["BEHAVIOR_" + type];
+ },
+
+ /**
+ * Determines if the specified AutoComplete behavior is set.
+ *
+ * @param {string} type
+ * The behavior type to test for.
+ * @returns {boolean} true if the behavior is set, false otherwise.
+ */
+ hasBehavior(type) {
+ let behavior = Ci.mozIPlacesAutoComplete["BEHAVIOR_" + type.toUpperCase()];
+ return this._behavior & behavior;
+ },
+
+ /**
+ * Given an array of tokens, this function determines which query should be
+ * ran. It also removes any special search tokens.
+ *
+ * @param {Array} tokens
+ * An array of search tokens.
+ * @returns {Array} A new, filtered array of tokens.
+ */
+ filterTokens(tokens) {
+ let foundToken = false;
+ // Set the proper behavior while filtering tokens.
+ let filtered = [];
+ for (let token of tokens) {
+ if (!lazy.UrlbarTokenizer.isRestrictionToken(token)) {
+ filtered.push(token);
+ continue;
+ }
+ let behavior = lazy.typeToBehaviorMap.get(token.type);
+ if (!behavior) {
+ throw new Error(`Unknown token type ${token.type}`);
+ }
+ // Don't use the suggest preferences if it is a token search and
+ // set the restrict bit to 1 (to intersect the search results).
+ if (!foundToken) {
+ foundToken = true;
+ // Do not take into account previous behavior (e.g.: history, bookmark)
+ this._behavior = 0;
+ this.setBehavior("restrict");
+ }
+ this.setBehavior(behavior);
+ // We return tags only for bookmarks, thus when tags are enforced, we
+ // must also set the bookmark behavior.
+ if (behavior == "tag") {
+ this.setBehavior("bookmark");
+ }
+ }
+ return filtered;
+ },
+
+ /**
+ * Stop this search.
+ * After invoking this method, we won't run any more searches or heuristics,
+ * and no new matches may be added to the current result.
+ */
+ stop() {
+ // Avoid multiple calls or re-entrance.
+ if (!this.pending) {
+ return;
+ }
+ if (this._notifyTimer) {
+ this._notifyTimer.cancel();
+ }
+ this._notifyDelaysCount = 0;
+ if (typeof this.interrupt == "function") {
+ this.interrupt();
+ }
+ this.pending = false;
+ },
+
+ /**
+ * Whether this search is active.
+ */
+ pending: true,
+
+ /**
+ * Execute the search and populate results.
+ *
+ * @param {mozIStorageAsyncConnection} conn
+ * The Sqlite connection.
+ */
+ async execute(conn) {
+ // A search might be canceled before it starts.
+ if (!this.pending) {
+ return;
+ }
+
+ // Used by stop() to interrupt an eventual running statement.
+ this.interrupt = () => {
+ // Interrupt any ongoing statement to run the search sooner.
+ if (!lazy.UrlbarProvidersManager.interruptLevel) {
+ conn.interrupt();
+ }
+ };
+
+ // For any given search, we run these queries:
+ // 1) open pages not supported by history (this._switchToTabQuery)
+ // 2) query based on match behavior
+
+ // If the query is simply "@" and we have tokenAliasEngines then return
+ // early. UrlbarProviderTokenAliasEngines will add engine results.
+ let tokenAliasEngines = await lazy.UrlbarSearchUtils.tokenAliasEngines();
+ if (this._trimmedOriginalSearchString == "@" && tokenAliasEngines.length) {
+ this._provider.finishSearch(true);
+ return;
+ }
+
+ // Check if the first token is an action. If it is, we should set a flag
+ // so we don't include it in our searches.
+ this._firstTokenIsKeyword =
+ this._firstTokenIsKeyword || (await this._checkIfFirstTokenIsKeyword());
+ if (!this.pending) {
+ return;
+ }
+
+ if (this._trimmedOriginalSearchString) {
+ // If the user typed the search restriction char or we're in
+ // search-restriction mode, then we're done.
+ // UrlbarProviderSearchSuggestions will handle suggestions, if any.
+ let emptySearchRestriction =
+ this._trimmedOriginalSearchString.length <= 3 &&
+ this._leadingRestrictionToken == lazy.UrlbarTokenizer.RESTRICT.SEARCH &&
+ /\s*\S?$/.test(this._trimmedOriginalSearchString);
+ if (
+ emptySearchRestriction ||
+ (tokenAliasEngines.length &&
+ this._trimmedOriginalSearchString.startsWith("@")) ||
+ (this.hasBehavior("search") && this.hasBehavior("restrict"))
+ ) {
+ this._provider.finishSearch(true);
+ return;
+ }
+ }
+
+ // Run our standard Places query.
+ let queries = [];
+ // "openpage" behavior is supported by the default query.
+ // _switchToTabQuery instead returns only pages not supported by history.
+ if (this.hasBehavior("openpage")) {
+ queries.push(this._switchToTabQuery);
+ }
+ queries.push(this._searchQuery);
+ for (let [query, params] of queries) {
+ await conn.executeCached(query, params, this._onResultRow.bind(this));
+ if (!this.pending) {
+ return;
+ }
+ }
+
+ // If we do not have enough matches search again with MATCH_ANYWHERE, to
+ // get more matches.
+ let count = this._counts[MATCH_TYPE.GENERAL];
+ if (count < this._maxResults) {
+ this._matchBehavior = Ci.mozIPlacesAutoComplete.MATCH_ANYWHERE;
+ queries = [this._searchQuery];
+ if (this.hasBehavior("openpage")) {
+ queries.unshift(this._switchToTabQuery);
+ }
+ for (let [query, params] of queries) {
+ await conn.executeCached(query, params, this._onResultRow.bind(this));
+ if (!this.pending) {
+ return;
+ }
+ }
+ }
+ },
+
+ async _checkIfFirstTokenIsKeyword() {
+ if (!this._heuristicToken) {
+ return false;
+ }
+
+ let aliasEngine = await lazy.UrlbarSearchUtils.engineForAlias(
+ this._heuristicToken,
+ this._originalSearchString
+ );
+
+ if (aliasEngine) {
+ return true;
+ }
+
+ let { entry } = await lazy.KeywordUtils.getBindableKeyword(
+ this._heuristicToken,
+ this._originalSearchString
+ );
+ if (entry) {
+ this._filterOnHost = entry.url.host;
+ return true;
+ }
+
+ return false;
+ },
+
+ _onResultRow(row, cancel) {
+ let queryType = row.getResultByIndex(QUERYINDEX_QUERYTYPE);
+ switch (queryType) {
+ case QUERYTYPE_FILTERED:
+ this._addFilteredQueryMatch(row);
+ break;
+ }
+ // If the search has been canceled by the user or by _addMatch, or we
+ // fetched enough results, we can stop the underlying Sqlite query.
+ let count = this._counts[MATCH_TYPE.GENERAL];
+ if (!this.pending || count >= this._maxResults) {
+ cancel();
+ }
+ },
+
+ /**
+ * Maybe restyle a SERP in history as a search-type result. To do this,
+ * we extract the search term from the SERP in history then generate a search
+ * URL with that search term. We restyle the SERP in history if its query
+ * parameters are a subset of those of the generated SERP. We check for a
+ * subset instead of exact equivalence since the generated URL may contain
+ * attribution parameters while a SERP in history from an organic search would
+ * not. We don't allow extra params in the history URL since they might
+ * indicate the search is not a first-page web SERP (as opposed to a image or
+ * other non-web SERP).
+ *
+ * Note: We will mistakenly dedupe SERPs for engines that have the same
+ * hostname as another engine. One example is if the user installed a
+ * Google Image Search engine. That engine's search URLs might only be
+ * distinguished by query params from search URLs from the default Google
+ * engine.
+ *
+ * @param {object} match
+ * The match to maybe restyle.
+ * @returns {boolean} True if the match can be restyled, false otherwise.
+ */
+ _maybeRestyleSearchMatch(match) {
+ // Return if the URL does not represent a search result.
+ let historyUrl = match.value;
+ let parseResult = Services.search.parseSubmissionURL(historyUrl);
+ if (!parseResult?.engine) {
+ return false;
+ }
+
+ // Here we check that the user typed all or part of the search string in the
+ // search history result.
+ let terms = parseResult.terms.toLowerCase();
+ if (
+ this._searchTokens.length &&
+ this._searchTokens.every(token => !terms.includes(token.value))
+ ) {
+ return false;
+ }
+
+ // The URL for the search suggestion formed by the user's typed query.
+ let [generatedSuggestionUrl] = UrlbarUtils.getSearchQueryUrl(
+ parseResult.engine,
+ this._searchTokens.map(t => t.value).join(" ")
+ );
+
+ // We ignore termsParameterName when checking for a subset because we
+ // already checked that the typed query is a subset of the search history
+ // query above with this._searchTokens.every(...).
+ if (
+ !lazy.UrlbarSearchUtils.serpsAreEquivalent(
+ historyUrl,
+ generatedSuggestionUrl,
+ [parseResult.termsParameterName]
+ )
+ ) {
+ return false;
+ }
+
+ // Turn the match into a searchengine action with a favicon.
+ match.value = makeActionUrl("searchengine", {
+ engineName: parseResult.engine.name,
+ input: parseResult.terms,
+ searchSuggestion: parseResult.terms,
+ searchQuery: parseResult.terms,
+ isSearchHistory: true,
+ });
+ match.comment = parseResult.engine.name;
+ match.icon = match.icon || match.iconUrl;
+ match.style = "action searchengine favicon suggestion";
+ return true;
+ },
+
+ _addMatch(match) {
+ if (typeof match.frecency != "number") {
+ throw new Error("Frecency not provided");
+ }
+
+ if (typeof match.type != "string") {
+ match.type = MATCH_TYPE.GENERAL;
+ }
+
+ // A search could be canceled between a query start and its completion,
+ // in such a case ensure we won't notify any result for it.
+ if (!this.pending) {
+ return;
+ }
+
+ match.style = match.style || "favicon";
+
+ // Restyle past searches, unless they are bookmarks or special results.
+ if (
+ match.style == "favicon" &&
+ (lazy.UrlbarPrefs.get("restyleSearches") || this._searchModeEngine)
+ ) {
+ let restyled = this._maybeRestyleSearchMatch(match);
+ if (
+ restyled &&
+ lazy.UrlbarPrefs.get("maxHistoricalSearchSuggestions") == 0
+ ) {
+ // The user doesn't want search history.
+ return;
+ }
+ }
+
+ match.icon = match.icon || "";
+ match.finalCompleteValue = match.finalCompleteValue || "";
+
+ let { index, replace } = this._getInsertIndexForMatch(match);
+ if (index == -1) {
+ return;
+ }
+ if (replace) {
+ // Replacing an existing match from the previous search.
+ this._matches.splice(index, 1);
+ }
+ this._matches.splice(index, 0, match);
+ this._counts[match.type]++;
+
+ this.notifyResult(true);
+ },
+
+ /**
+ * @typedef {object} MatchPositionInformation
+ * @property {number} index
+ * The index the match should take in the results. Return -1 if the match
+ * should be discarded.
+ * @property {boolean} replace
+ * True if the match should replace the result already at
+ * matchPosition.index.
+ */
+
+ /**
+ * Check for duplicates and either discard the duplicate or replace the
+ * original match, in case the new one is more specific. For example,
+ * a Remote Tab wins over History, and a Switch to Tab wins over a Remote Tab.
+ * We must check both id and url for duplication, because keywords may change
+ * the url by replacing the %s placeholder.
+ *
+ * @param {object} match
+ * The match to insert.
+ * @returns {MatchPositionInformation}
+ */
+ _getInsertIndexForMatch(match) {
+ let [urlMapKey, prefix, action] = makeKeyForMatch(match);
+ if (
+ (match.placeId && this._usedPlaceIds.has(match.placeId)) ||
+ this._usedURLs.some(e => lazy.ObjectUtils.deepEqual(e.key, urlMapKey))
+ ) {
+ let isDupe = true;
+ if (action && ["switchtab", "remotetab"].includes(action.type)) {
+ // The new entry is a switch/remote tab entry, look for the duplicate
+ // among current matches.
+ for (let i = 0; i < this._usedURLs.length; ++i) {
+ let { key: matchKey, action: matchAction } = this._usedURLs[i];
+ if (lazy.ObjectUtils.deepEqual(matchKey, urlMapKey)) {
+ isDupe = true;
+ if (!matchAction || action.type == "switchtab") {
+ this._usedURLs[i] = {
+ key: urlMapKey,
+ action,
+ type: match.type,
+ prefix,
+ comment: match.comment,
+ };
+ return { index: i, replace: true };
+ }
+ break; // Found the duplicate, no reason to continue.
+ }
+ }
+ } else {
+ // Dedupe with this flow:
+ // 1. If the two URLs are the same, dedupe the newer one.
+ // 2. If they both contain www. or both do not contain it, prefer https.
+ // 3. If they differ by www., send both results to the Muxer and allow
+ // it to decide based on results from other providers.
+ let prefixRank = UrlbarUtils.getPrefixRank(prefix);
+ for (let i = 0; i < this._usedURLs.length; ++i) {
+ if (!this._usedURLs[i]) {
+ // This is true when the result at [i] is a searchengine result.
+ continue;
+ }
+
+ let { key: existingKey, prefix: existingPrefix } = this._usedURLs[i];
+
+ let existingPrefixRank = UrlbarUtils.getPrefixRank(existingPrefix);
+ if (lazy.ObjectUtils.deepEqual(existingKey, urlMapKey)) {
+ isDupe = true;
+
+ if (prefix == existingPrefix) {
+ // The URLs are identical. Throw out the new result.
+ break;
+ }
+
+ if (prefix.endsWith("www.") == existingPrefix.endsWith("www.")) {
+ // The results differ only by protocol.
+ if (prefixRank <= existingPrefixRank) {
+ break; // Replace match.
+ } else {
+ this._usedURLs[i] = {
+ key: urlMapKey,
+ action,
+ type: match.type,
+ prefix,
+ comment: match.comment,
+ };
+ return { index: i, replace: true };
+ }
+ } else {
+ // We have two identical URLs that differ only by www. We need to
+ // be sure what the heuristic result is before deciding how we
+ // should dedupe. We mark these as non-duplicates and let the
+ // muxer handle it.
+ isDupe = false;
+ continue;
+ }
+ }
+ }
+ }
+
+ // Discard the duplicate.
+ if (isDupe) {
+ return { index: -1, replace: false };
+ }
+ }
+
+ // Add this to our internal tracker to ensure duplicates do not end up in
+ // the result.
+ // Not all entries have a place id, thus we fallback to the url for them.
+ // We cannot use only the url since keywords entries are modified to
+ // include the search string, and would be returned multiple times. Ids
+ // are faster too.
+ if (match.placeId) {
+ this._usedPlaceIds.add(match.placeId);
+ }
+
+ let index = 0;
+ if (!this._groups) {
+ this._groups = [];
+ this._makeGroups(lazy.UrlbarPrefs.resultGroups, this._maxResults);
+ }
+
+ let replace = 0;
+ for (let group of this._groups) {
+ // Move to the next group if the match type is incompatible, or if there
+ // is no available space or if the frecency is below the threshold.
+ if (match.type != group.type || !group.available) {
+ index += group.count;
+ continue;
+ }
+
+ index += group.insertIndex;
+ group.available--;
+ if (group.insertIndex < group.count) {
+ replace = true;
+ } else {
+ group.count++;
+ }
+ group.insertIndex++;
+ break;
+ }
+ this._usedURLs[index] = {
+ key: urlMapKey,
+ action,
+ type: match.type,
+ prefix,
+ comment: match.comment || "",
+ };
+ return { index, replace };
+ },
+
+ _makeGroups(resultGroup, maxResultCount) {
+ if (!resultGroup.children) {
+ let type;
+ switch (resultGroup.group) {
+ case UrlbarUtils.RESULT_GROUP.FORM_HISTORY:
+ case UrlbarUtils.RESULT_GROUP.REMOTE_SUGGESTION:
+ case UrlbarUtils.RESULT_GROUP.TAIL_SUGGESTION:
+ type = MATCH_TYPE.SUGGESTION;
+ break;
+ case UrlbarUtils.RESULT_GROUP.HEURISTIC_AUTOFILL:
+ case UrlbarUtils.RESULT_GROUP.HEURISTIC_EXTENSION:
+ case UrlbarUtils.RESULT_GROUP.HEURISTIC_FALLBACK:
+ case UrlbarUtils.RESULT_GROUP.HEURISTIC_OMNIBOX:
+ case UrlbarUtils.RESULT_GROUP.HEURISTIC_SEARCH_TIP:
+ case UrlbarUtils.RESULT_GROUP.HEURISTIC_TEST:
+ case UrlbarUtils.RESULT_GROUP.HEURISTIC_TOKEN_ALIAS_ENGINE:
+ type = MATCH_TYPE.HEURISTIC;
+ break;
+ case UrlbarUtils.RESULT_GROUP.OMNIBOX:
+ type = MATCH_TYPE.EXTENSION;
+ break;
+ default:
+ type = MATCH_TYPE.GENERAL;
+ break;
+ }
+ if (this._groups.length) {
+ let last = this._groups[this._groups.length - 1];
+ if (last.type == type) {
+ return;
+ }
+ }
+ // - `available` is the number of available slots in the group
+ // - `insertIndex` is the index of the first available slot in the group
+ // - `count` is the number of matches in the group, note that it also
+ // accounts for matches from the previous search, while `available` and
+ // `insertIndex` don't.
+ this._groups.push({
+ type,
+ available: maxResultCount,
+ insertIndex: 0,
+ count: 0,
+ });
+ return;
+ }
+
+ let initialMaxResultCount;
+ if (typeof resultGroup.maxResultCount == "number") {
+ initialMaxResultCount = resultGroup.maxResultCount;
+ } else if (typeof resultGroup.availableSpan == "number") {
+ initialMaxResultCount = resultGroup.availableSpan;
+ } else {
+ initialMaxResultCount = this._maxResults;
+ }
+ let childMaxResultCount = Math.min(initialMaxResultCount, maxResultCount);
+ for (let child of resultGroup.children) {
+ this._makeGroups(child, childMaxResultCount);
+ }
+ },
+
+ _addFilteredQueryMatch(row) {
+ let placeId = row.getResultByIndex(QUERYINDEX_PLACEID);
+ let url = row.getResultByIndex(QUERYINDEX_URL);
+ let openPageCount = row.getResultByIndex(QUERYINDEX_SWITCHTAB) || 0;
+ let historyTitle = row.getResultByIndex(QUERYINDEX_TITLE) || "";
+ let bookmarked = row.getResultByIndex(QUERYINDEX_BOOKMARKED);
+ let bookmarkTitle = bookmarked
+ ? row.getResultByIndex(QUERYINDEX_BOOKMARKTITLE)
+ : null;
+ let tags = row.getResultByIndex(QUERYINDEX_TAGS) || "";
+ let frecency = row.getResultByIndex(QUERYINDEX_FRECENCY);
+
+ let match = {
+ placeId,
+ value: url,
+ comment: bookmarkTitle || historyTitle,
+ icon: UrlbarUtils.getIconForUrl(url),
+ frecency: frecency || FRECENCY_DEFAULT,
+ };
+
+ if (openPageCount > 0 && this.hasBehavior("openpage")) {
+ if (this._currentPage == match.value) {
+ // Don't suggest switching to the current tab.
+ return;
+ }
+ // Actions are enabled and the page is open. Add a switch-to-tab result.
+ match.value = makeActionUrl("switchtab", { url: match.value });
+ match.style = "action switchtab";
+ } else if (
+ this.hasBehavior("history") &&
+ !this.hasBehavior("bookmark") &&
+ !tags
+ ) {
+ // The consumer wants only history and not bookmarks and there are no
+ // tags. We'll act as if the page is not bookmarked.
+ match.style = "favicon";
+ } else if (tags) {
+ // Store the tags in the title. It's up to the consumer to extract them.
+ match.comment += UrlbarUtils.TITLE_TAGS_SEPARATOR + tags;
+ // If we're not suggesting bookmarks, then this shouldn't display as one.
+ match.style = this.hasBehavior("bookmark") ? "bookmark-tag" : "tag";
+ } else if (bookmarked) {
+ match.style = "bookmark";
+ }
+
+ this._addMatch(match);
+ },
+
+ /**
+ * @returns {string}
+ * A string consisting of the search query to be used based on the previously
+ * set urlbar suggestion preferences.
+ */
+ get _suggestionPrefQuery() {
+ let conditions = [];
+ if (this._filterOnHost) {
+ conditions.push("h.rev_host = get_unreversed_host(:host || '.') || '.'");
+ // When filtering on a host we are in some sort of site specific search,
+ // thus we want a cleaner set of results, compared to a general search.
+ // This means removing less interesting urls, like redirects or
+ // non-bookmarked title-less pages.
+
+ if (lazy.UrlbarPrefs.get("restyleSearches") || this._searchModeEngine) {
+ // If restyle is enabled, we want to filter out redirect targets,
+ // because sources are urls built using search engines definitions that
+ // we can reverse-parse.
+ // In this case we can't filter on title-less pages because redirect
+ // sources likely don't have a title and recognizing sources is costly.
+ // Bug 468710 may help with this.
+ conditions.push(`NOT EXISTS (
+ WITH visits(type) AS (
+ SELECT visit_type
+ FROM moz_historyvisits
+ WHERE place_id = h.id
+ ORDER BY visit_date DESC
+ LIMIT 10 /* limit to the last 10 visits */
+ )
+ SELECT 1 FROM visits
+ WHERE type IN (5,6)
+ )`);
+ } else {
+ // If instead restyle is disabled, we want to keep redirect targets,
+ // because sources are often unreadable title-less urls.
+ conditions.push(`NOT EXISTS (
+ WITH visits(id) AS (
+ SELECT id
+ FROM moz_historyvisits
+ WHERE place_id = h.id
+ ORDER BY visit_date DESC
+ LIMIT 10 /* limit to the last 10 visits */
+ )
+ SELECT 1
+ FROM visits src
+ JOIN moz_historyvisits dest ON src.id = dest.from_visit
+ WHERE dest.visit_type IN (5,6)
+ )`);
+ // Filter out empty-titled pages, they could be redirect sources that
+ // we can't recognize anymore because their target was wrongly expired
+ // due to Bug 1664252.
+ conditions.push("(h.foreign_count > 0 OR h.title NOTNULL)");
+ }
+ }
+
+ if (
+ this.hasBehavior("restrict") ||
+ (!this.hasBehavior("openpage") &&
+ (!this.hasBehavior("history") || !this.hasBehavior("bookmark")))
+ ) {
+ if (this.hasBehavior("history")) {
+ // Enforce ignoring the visit_count index, since the frecency one is much
+ // faster in this case. ANALYZE helps the query planner to figure out the
+ // faster path, but it may not have up-to-date information yet.
+ conditions.push("+h.visit_count > 0");
+ }
+ if (this.hasBehavior("bookmark")) {
+ conditions.push("bookmarked");
+ }
+ if (this.hasBehavior("tag")) {
+ conditions.push("tags NOTNULL");
+ }
+ }
+
+ return defaultQuery(conditions.join(" AND "));
+ },
+
+ get _emptySearchDefaultBehavior() {
+ // Further restrictions to apply for "empty searches" (searching for
+ // ""). The empty behavior is typed history, if history is enabled.
+ // Otherwise, it is bookmarks, if they are enabled. If both history and
+ // bookmarks are disabled, it defaults to open pages.
+ let val = Ci.mozIPlacesAutoComplete.BEHAVIOR_RESTRICT;
+ if (lazy.UrlbarPrefs.get("suggest.history")) {
+ val |= Ci.mozIPlacesAutoComplete.BEHAVIOR_HISTORY;
+ } else if (lazy.UrlbarPrefs.get("suggest.bookmark")) {
+ val |= Ci.mozIPlacesAutoComplete.BEHAVIOR_BOOKMARK;
+ } else {
+ val |= Ci.mozIPlacesAutoComplete.BEHAVIOR_OPENPAGE;
+ }
+ return val;
+ },
+
+ /**
+ * If the user-provided string starts with a keyword that gave a heuristic
+ * result, this will strip it.
+ *
+ * @returns {string} The filtered search string.
+ */
+ get _keywordFilteredSearchString() {
+ let tokens = this._searchTokens.map(t => t.value);
+ if (this._firstTokenIsKeyword) {
+ tokens = tokens.slice(1);
+ }
+ return tokens.join(" ");
+ },
+
+ /**
+ * Obtains the search query to be used based on the previously set search
+ * preferences (accessed by this.hasBehavior).
+ *
+ * @returns {Array}
+ * An array consisting of the correctly optimized query to search the
+ * database with and an object containing the params to bound.
+ */
+ get _searchQuery() {
+ let params = {
+ parent: lazy.PlacesUtils.tagsFolderId,
+ query_type: QUERYTYPE_FILTERED,
+ matchBehavior: this._matchBehavior,
+ searchBehavior: this._behavior,
+ // We only want to search the tokens that we are left with - not the
+ // original search string.
+ searchString: this._keywordFilteredSearchString,
+ userContextId: this._userContextId,
+ // Limit the query to the the maximum number of desired results.
+ // This way we can avoid doing more work than needed.
+ maxResults: this._maxResults,
+ };
+ if (this._filterOnHost) {
+ params.host = this._filterOnHost;
+ }
+ return [this._suggestionPrefQuery, params];
+ },
+
+ /**
+ * Obtains the query to search for switch-to-tab entries.
+ *
+ * @returns {Array}
+ * An array consisting of the correctly optimized query to search the
+ * database with and an object containing the params to bound.
+ */
+ get _switchToTabQuery() {
+ return [
+ SQL_SWITCHTAB_QUERY,
+ {
+ query_type: QUERYTYPE_FILTERED,
+ matchBehavior: this._matchBehavior,
+ searchBehavior: this._behavior,
+ // We only want to search the tokens that we are left with - not the
+ // original search string.
+ searchString: this._keywordFilteredSearchString,
+ userContextId: this._userContextId,
+ maxResults: this._maxResults,
+ },
+ ];
+ },
+
+ // The result is notified to the search listener on a timer, to chunk multiple
+ // match updates together and avoid rebuilding the popup at every new match.
+ _notifyTimer: null,
+
+ /**
+ * Notifies the current result to the listener.
+ *
+ * @param searchOngoing
+ * Indicates whether the search result should be marked as ongoing.
+ */
+ _notifyDelaysCount: 0,
+ notifyResult(searchOngoing) {
+ let notify = () => {
+ if (!this.pending) {
+ return;
+ }
+ this._notifyDelaysCount = 0;
+ this._listener(this._matches, searchOngoing);
+ if (!searchOngoing) {
+ // Break possible cycles.
+ this._listener = null;
+ this._provider = null;
+ this.stop();
+ }
+ };
+ if (this._notifyTimer) {
+ this._notifyTimer.cancel();
+ }
+ // In the worst case, we may get evenly spaced matches that would end up
+ // delaying the UI by N_MATCHES * NOTIFYRESULT_DELAY_MS. Thus, we clamp the
+ // number of times we may delay matches.
+ if (this._notifyDelaysCount > 3) {
+ notify();
+ } else {
+ this._notifyDelaysCount++;
+ this._notifyTimer = setTimeout(notify, NOTIFYRESULT_DELAY_MS);
+ }
+ },
+};
+
+/**
+ * Class used to create the provider.
+ */
+class ProviderPlaces extends UrlbarProvider {
+ // Promise resolved when the database initialization has completed, or null
+ // if it has never been requested.
+ _promiseDatabase = null;
+
+ /**
+ * Returns the name of this provider.
+ *
+ * @returns {string} the name of this provider.
+ */
+ get name() {
+ return "Places";
+ }
+
+ /**
+ * Returns the type of this provider.
+ *
+ * @returns {integer} one of the types from UrlbarUtils.PROVIDER_TYPE.*
+ */
+ get type() {
+ return UrlbarUtils.PROVIDER_TYPE.PROFILE;
+ }
+
+ /**
+ * Gets a Sqlite database handle.
+ *
+ * @returns {Promise<OpenedConnection>}
+ * A connection to the Sqlite database handle (according to {@link Sqlite.sys.mjs}).
+ * @throws A javascript exception
+ */
+ getDatabaseHandle() {
+ if (!this._promiseDatabase) {
+ this._promiseDatabase = (async () => {
+ let conn = await lazy.PlacesUtils.promiseLargeCacheDBConnection();
+
+ // We don't catch exceptions here as it is too late to block shutdown.
+ lazy.Sqlite.shutdown.addBlocker("UrlbarProviderPlaces closing", () => {
+ // Break a possible cycle through the
+ // previous result, the controller and
+ // ourselves.
+ this._currentSearch = null;
+ });
+
+ return conn;
+ })().catch(ex => {
+ dump("Couldn't get database handle: " + ex + "\n");
+ this.logger.error(ex);
+ });
+ }
+ return this._promiseDatabase;
+ }
+
+ /**
+ * Whether this provider should be invoked for the given context.
+ * If this method returns false, the providers manager won't start a query
+ * with this provider, to save on resources.
+ *
+ * @param {UrlbarQueryContext} queryContext The query context object
+ * @returns {boolean} Whether this provider should be invoked for the search.
+ */
+ isActive(queryContext) {
+ if (
+ !queryContext.trimmedSearchString &&
+ queryContext.searchMode?.engineName &&
+ lazy.UrlbarPrefs.get("update2.emptySearchBehavior") < 2
+ ) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Starts querying.
+ *
+ * @param {object} queryContext The query context object
+ * @param {Function} addCallback Callback invoked by the provider to add a new
+ * result.
+ * @returns {Promise} resolved when the query stops.
+ */
+ startQuery(queryContext, addCallback) {
+ let instance = this.queryInstance;
+ let urls = new Set();
+ this._startLegacyQuery(queryContext, matches => {
+ if (instance != this.queryInstance) {
+ return;
+ }
+ let results = convertLegacyMatches(queryContext, matches, urls);
+ for (let result of results) {
+ addCallback(this, result);
+ }
+ });
+ return this._deferred.promise;
+ }
+
+ /**
+ * Cancels a running query.
+ *
+ * @param {object} queryContext The query context object
+ */
+ cancelQuery(queryContext) {
+ if (this._currentSearch) {
+ this._currentSearch.stop();
+ }
+ if (this._deferred) {
+ this._deferred.resolve();
+ }
+ // Don't notify since we are canceling this search. This also means we
+ // won't fire onSearchComplete for this search.
+ this.finishSearch();
+ }
+
+ /**
+ * Properly cleans up when searching is completed.
+ *
+ * @param {boolean} [notify]
+ * Indicates if we should notify the AutoComplete listener about our
+ * results or not. Default false.
+ */
+ finishSearch(notify = false) {
+ // Clear state now to avoid race conditions, see below.
+ let search = this._currentSearch;
+ if (!search) {
+ return;
+ }
+ this._lastLowResultsSearchSuggestion =
+ search._lastLowResultsSearchSuggestion;
+
+ if (!notify || !search.pending) {
+ return;
+ }
+
+ // There is a possible race condition here.
+ // When a search completes it calls finishSearch that notifies results
+ // here. When the controller gets the last result it fires
+ // onSearchComplete.
+ // If onSearchComplete immediately starts a new search it will set a new
+ // _currentSearch, and on return the execution will continue here, after
+ // notifyResult.
+ // Thus, ensure that notifyResult is the last call in this method,
+ // otherwise you might be touching the wrong search.
+ search.notifyResult(false);
+ }
+
+ onEngagement(isPrivate, state, queryContext, details) {
+ let { result } = details;
+ if (result?.providerName != this.name) {
+ return;
+ }
+
+ if (details.selType == "dismiss") {
+ switch (result.type) {
+ case UrlbarUtils.RESULT_TYPE.SEARCH:
+ // URL restyled as a search suggestion. Generate the URL and remove it
+ // from browsing history.
+ let { url } = UrlbarUtils.getUrlFromResult(result);
+ lazy.PlacesUtils.history.remove(url).catch(console.error);
+ queryContext.view.controller.removeResult(result);
+ break;
+ case UrlbarUtils.RESULT_TYPE.URL:
+ // Remove browsing history entries from Places.
+ lazy.PlacesUtils.history
+ .remove(result.payload.url)
+ .catch(console.error);
+ queryContext.view.controller.removeResult(result);
+ break;
+ }
+ }
+ }
+
+ _startLegacyQuery(queryContext, callback) {
+ let deferred = lazy.PromiseUtils.defer();
+ let listener = (matches, searchOngoing) => {
+ callback(matches);
+ if (!searchOngoing) {
+ deferred.resolve();
+ }
+ };
+ this._startSearch(queryContext.searchString, listener, queryContext);
+ this._deferred = deferred;
+ }
+
+ _startSearch(searchString, listener, queryContext) {
+ // Stop the search in case the controller has not taken care of it.
+ if (this._currentSearch) {
+ this.cancelQuery();
+ }
+
+ let search = (this._currentSearch = new Search(
+ queryContext,
+ listener,
+ this
+ ));
+ this.getDatabaseHandle()
+ .then(conn => search.execute(conn))
+ .catch(ex => {
+ dump(`Query failed: ${ex}\n`);
+ this.logger.error(ex);
+ })
+ .then(() => {
+ if (search == this._currentSearch) {
+ this.finishSearch(true);
+ }
+ });
+ }
+}
+
+export var UrlbarProviderPlaces = new ProviderPlaces();