forked from mirrors/gecko-dev
a3b0a1fd4c
This removes `UrlbarProvider.pickResult()` and `blockResult()` in favor of handling picks and dismissals through `onEngagement()`. A number of providers use those two methods, so this revision touches a lot of files. Handling dismissals through `onEngagement()` means `UrlbarInput.pickResult()` can no longer tell whether a result is successfully dismissed, so it can't remove the result anymore. (Maybe `onEngagement()` could return some value indicating it dismissed the result, but I don't want to go down that road.) Instead, I split `UrlbarController.handleDeleteEntry()` into two methods: a public one that removes the result and notifies listeners, and a private one that handles dismissing the selected result internally in UrlbarController. Providers that have dismissable results should now implement `onEngagement()` and call `controller.removeResult()`. I made some other improvements to engagement handling. There's still room for more but this patch is big enough already. Other notable changes: Include the engaged result in engagement notifications so providers have easy access to it and can respond to clicks and dismissals more easily. That also lets us stop passing `selIndex` and `provider` to `engagementEvent.record()` since now it can compute those from the passed-in result. Add the concept of `isSessionOngoing` to engagement notifications so providers can tell whether an engagement ended the search session. Right now, providers like quick suggest that record a bunch of provider-specific legacy telemetry assume that `onEngagement()` ends the session, but that's no longer true. Unify result buttons and result menu commands by setting `element.dataset.command` on buttons (hopefully we can remove buttons soon, at least the ones that aren't tip buttons) Make sure we always notify providers on engagement even on dismissals or when skipping legacy telemetry Move dismissal of restyled search suggestions and history results from `UrlbarController.handleDeleteEntry()` to the Places provider Move dismissal of form history results from `UrlbarController.handleDeleteEntry()` to the search suggestions provider In the Places provider, remove the unused `_addSearchEngineMatch()` method. Also remove the code in the "searchengine" case that creates a non-search-history result. This code is unreached because the only time the provider creates a "searchengine" match it also sets `isSearchHistory` to true. In `UrlbarTestUtils.promiseAutocompleteResultPopup()`, change the default value of the `fireInputEvent` param from false to true. This is necessary because without a starting input event, the start event info in `engagementEvent` will be null, so when `engagementEvent.record()` is called at the end of the engagement, it will bail, and providers will not be notified of the engagement. IMO true is a better default value anyway because input events will typically be fired when the user performs a search. Differential Revision: https://phabricator.services.mozilla.com/D174941
1534 lines
51 KiB
JavaScript
1534 lines
51 KiB
JavaScript
/* -*- 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 &&
|
|
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();
|