262 lines
9 KiB
JavaScript
262 lines
9 KiB
JavaScript
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/**
|
|
* This module exports a provider that offers input history (aka adaptive
|
|
* history) results. These results map typed search strings to Urlbar results.
|
|
* That way, a user can find a particular result again by typing the same
|
|
* string.
|
|
*/
|
|
|
|
import {
|
|
UrlbarProvider,
|
|
UrlbarUtils,
|
|
} from "resource:///modules/UrlbarUtils.sys.mjs";
|
|
|
|
const lazy = {};
|
|
|
|
ChromeUtils.defineESModuleGetters(lazy, {
|
|
PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
|
|
UrlbarPrefs: "resource:///modules/UrlbarPrefs.sys.mjs",
|
|
UrlbarProviderOpenTabs: "resource:///modules/UrlbarProviderOpenTabs.sys.mjs",
|
|
UrlbarResult: "resource:///modules/UrlbarResult.sys.mjs",
|
|
});
|
|
|
|
ChromeUtils.defineLazyGetter(lazy, "SQL_ADAPTIVE_QUERY", () => {
|
|
// Constants to support an alternative frecency algorithm.
|
|
const PAGES_USE_ALT_FRECENCY =
|
|
lazy.PlacesUtils.history.isAlternativeFrecencyEnabled;
|
|
const PAGES_FRECENCY_FIELD = PAGES_USE_ALT_FRECENCY
|
|
? "alt_frecency"
|
|
: "frecency";
|
|
return `/* do not warn (bug 487789) */
|
|
SELECT h.url,
|
|
h.title,
|
|
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 bookmark_title,
|
|
( SELECT GROUP_CONCAT(t.title ORDER BY 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,
|
|
t.open_count,
|
|
t.userContextId,
|
|
h.last_visit_date
|
|
FROM (
|
|
SELECT ROUND(MAX(use_count) * (1 + (input = :search_string)), 1) AS rank,
|
|
place_id
|
|
FROM moz_inputhistory
|
|
WHERE input BETWEEN :search_string AND :search_string || X'FFFF'
|
|
GROUP BY place_id
|
|
) AS i
|
|
JOIN moz_places h ON h.id = i.place_id
|
|
LEFT JOIN moz_openpages_temp t
|
|
ON t.url = h.url
|
|
AND (t.userContextId = :userContextId OR (t.userContextId <> -1 AND :userContextId IS NULL))
|
|
WHERE AUTOCOMPLETE_MATCH(NULL, h.url,
|
|
IFNULL(bookmark_title, h.title), tags,
|
|
h.visit_count, h.typed, bookmarked,
|
|
t.open_count,
|
|
:matchBehavior, :searchBehavior,
|
|
NULL)
|
|
ORDER BY rank DESC, ${PAGES_FRECENCY_FIELD} DESC
|
|
LIMIT :maxResults`;
|
|
});
|
|
|
|
/**
|
|
* Class used to create the provider.
|
|
*/
|
|
class ProviderInputHistory extends UrlbarProvider {
|
|
/**
|
|
* Unique name for the provider, used by the context to filter on providers.
|
|
*
|
|
* @returns {string}
|
|
*/
|
|
get name() {
|
|
return "InputHistory";
|
|
}
|
|
|
|
/**
|
|
* @returns {Values<typeof UrlbarUtils.PROVIDER_TYPE>}
|
|
*/
|
|
get type() {
|
|
return UrlbarUtils.PROVIDER_TYPE.PROFILE;
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
async isActive(queryContext) {
|
|
return (
|
|
(lazy.UrlbarPrefs.get("suggest.history") ||
|
|
lazy.UrlbarPrefs.get("suggest.bookmark") ||
|
|
lazy.UrlbarPrefs.get("suggest.openpage")) &&
|
|
!queryContext.searchMode
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Starts querying. Extended classes should return a Promise resolved when the
|
|
* provider is done searching AND returning results.
|
|
*
|
|
* @param {UrlbarQueryContext} queryContext The query context object
|
|
* @param {Function} addCallback Callback invoked by the provider to add a new
|
|
* result. A UrlbarResult should be passed to it.
|
|
* @returns {Promise}
|
|
*/
|
|
async startQuery(queryContext, addCallback) {
|
|
let instance = this.queryInstance;
|
|
|
|
let conn = await lazy.PlacesUtils.promiseLargeCacheDBConnection();
|
|
if (instance != this.queryInstance) {
|
|
return;
|
|
}
|
|
|
|
let [query, params] = this._getAdaptiveQuery(queryContext);
|
|
let rows = await conn.executeCached(query, params);
|
|
if (instance != this.queryInstance) {
|
|
return;
|
|
}
|
|
|
|
for (let row of rows) {
|
|
const url = row.getResultByName("url");
|
|
const openPageCount = row.getResultByName("open_count") || 0;
|
|
const historyTitle = row.getResultByName("title") || "";
|
|
const bookmarked = row.getResultByName("bookmarked");
|
|
const bookmarkTitle = bookmarked
|
|
? row.getResultByName("bookmark_title")
|
|
: null;
|
|
const tags = row.getResultByName("tags") || "";
|
|
let lastVisitPRTime = row.getResultByName("last_visit_date");
|
|
let lastVisit = lastVisitPRTime
|
|
? lazy.PlacesUtils.toDate(lastVisitPRTime).getTime()
|
|
: undefined;
|
|
|
|
let resultTitle = historyTitle;
|
|
if (openPageCount > 0 && lazy.UrlbarPrefs.get("suggest.openpage")) {
|
|
if (url == queryContext.currentPage) {
|
|
// Don't suggest switching to the current page.
|
|
continue;
|
|
}
|
|
let userContextId = row.getResultByName("userContextId") || 0;
|
|
let payload = lazy.UrlbarResult.payloadAndSimpleHighlights(
|
|
queryContext.tokens,
|
|
{
|
|
url: [url, UrlbarUtils.HIGHLIGHT.TYPED],
|
|
title: [resultTitle, UrlbarUtils.HIGHLIGHT.TYPED],
|
|
icon: UrlbarUtils.getIconForUrl(url),
|
|
userContextId,
|
|
lastVisit,
|
|
}
|
|
);
|
|
if (lazy.UrlbarPrefs.get("secondaryActions.switchToTab")) {
|
|
payload[0].action =
|
|
UrlbarUtils.createTabSwitchSecondaryAction(userContextId);
|
|
}
|
|
let result = new lazy.UrlbarResult(
|
|
UrlbarUtils.RESULT_TYPE.TAB_SWITCH,
|
|
UrlbarUtils.RESULT_SOURCE.TABS,
|
|
...payload
|
|
);
|
|
addCallback(this, result);
|
|
continue;
|
|
}
|
|
|
|
let resultSource;
|
|
if (bookmarked && lazy.UrlbarPrefs.get("suggest.bookmark")) {
|
|
resultSource = UrlbarUtils.RESULT_SOURCE.BOOKMARKS;
|
|
resultTitle = bookmarkTitle || historyTitle;
|
|
} else if (lazy.UrlbarPrefs.get("suggest.history")) {
|
|
resultSource = UrlbarUtils.RESULT_SOURCE.HISTORY;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
let resultTags = tags.split(",").filter(tag => {
|
|
let lowerCaseTag = tag.toLocaleLowerCase();
|
|
return queryContext.tokens.some(token =>
|
|
lowerCaseTag.includes(token.lowerCaseValue)
|
|
);
|
|
});
|
|
|
|
let isBlockable = resultSource == UrlbarUtils.RESULT_SOURCE.HISTORY;
|
|
|
|
let result = new lazy.UrlbarResult(
|
|
UrlbarUtils.RESULT_TYPE.URL,
|
|
resultSource,
|
|
...lazy.UrlbarResult.payloadAndSimpleHighlights(queryContext.tokens, {
|
|
url: [url, UrlbarUtils.HIGHLIGHT.TYPED],
|
|
title: [resultTitle, UrlbarUtils.HIGHLIGHT.TYPED],
|
|
tags: [resultTags, UrlbarUtils.HIGHLIGHT.TYPED],
|
|
icon: UrlbarUtils.getIconForUrl(url),
|
|
isBlockable,
|
|
blockL10n: isBlockable
|
|
? { id: "urlbar-result-menu-remove-from-history" }
|
|
: undefined,
|
|
helpUrl: isBlockable
|
|
? Services.urlFormatter.formatURLPref("app.support.baseURL") +
|
|
"awesome-bar-result-menu"
|
|
: undefined,
|
|
lastVisit,
|
|
})
|
|
);
|
|
|
|
addCallback(this, result);
|
|
}
|
|
}
|
|
|
|
onEngagement(queryContext, controller, details) {
|
|
let { result } = details;
|
|
if (
|
|
details.selType == "dismiss" &&
|
|
result.type == UrlbarUtils.RESULT_TYPE.URL
|
|
) {
|
|
// Even if removing history normally also removes input history, that
|
|
// doesn't happen if the page is bookmarked, so we do remove input history
|
|
// regardless for this specific search term.
|
|
UrlbarUtils.removeInputHistory(
|
|
result.payload.url,
|
|
queryContext.searchString
|
|
).catch(console.error);
|
|
// Remove browsing history for the page.
|
|
lazy.PlacesUtils.history.remove(result.payload.url).catch(console.error);
|
|
controller.removeResult(result);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obtains the query to search for adaptive results.
|
|
*
|
|
* @param {UrlbarQueryContext} queryContext
|
|
* The current queryContext.
|
|
* @returns {Array} Contains the optimized query with which to search the
|
|
* database and an object containing the params to bound.
|
|
*/
|
|
_getAdaptiveQuery(queryContext) {
|
|
return [
|
|
lazy.SQL_ADAPTIVE_QUERY,
|
|
{
|
|
parent: lazy.PlacesUtils.tagsFolderId,
|
|
search_string: queryContext.lowerCaseSearchString,
|
|
matchBehavior: Ci.mozIPlacesAutoComplete.MATCH_ANYWHERE,
|
|
searchBehavior: lazy.UrlbarPrefs.get("defaultBehavior"),
|
|
userContextId: lazy.UrlbarPrefs.get("switchTabs.searchAllContainers")
|
|
? lazy.UrlbarProviderOpenTabs.getUserContextIdForOpenPagesTable(
|
|
null,
|
|
queryContext.isPrivate
|
|
)
|
|
: queryContext.userContextId,
|
|
maxResults: queryContext.maxResults,
|
|
},
|
|
];
|
|
}
|
|
}
|
|
|
|
export var UrlbarProviderInputHistory = new ProviderInputHistory();
|