diff options
Diffstat (limited to '')
| -rw-r--r-- | browser/components/urlbar/UrlbarProviderTopSites.sys.mjs | 384 |
1 files changed, 384 insertions, 0 deletions
diff --git a/browser/components/urlbar/UrlbarProviderTopSites.sys.mjs b/browser/components/urlbar/UrlbarProviderTopSites.sys.mjs new file mode 100644 index 0000000000..50b3233695 --- /dev/null +++ b/browser/components/urlbar/UrlbarProviderTopSites.sys.mjs @@ -0,0 +1,384 @@ +/* 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 returning the user's newtab Top Sites. + */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +import { + UrlbarProvider, + UrlbarUtils, +} from "resource:///modules/UrlbarUtils.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + CONTEXTUAL_SERVICES_PING_TYPES: + "resource:///modules/PartnerLinkAttribution.sys.mjs", + PartnerLinkAttribution: "resource:///modules/PartnerLinkAttribution.sys.mjs", + PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs", + TOP_SITES_DEFAULT_ROWS: "resource://activity-stream/common/Reducers.sys.mjs", + TOP_SITES_MAX_SITES_PER_ROW: + "resource://activity-stream/common/Reducers.sys.mjs", + UrlbarPrefs: "resource:///modules/UrlbarPrefs.sys.mjs", + UrlbarProviderOpenTabs: "resource:///modules/UrlbarProviderOpenTabs.sys.mjs", + UrlbarResult: "resource:///modules/UrlbarResult.sys.mjs", + UrlbarSearchUtils: "resource:///modules/UrlbarSearchUtils.sys.mjs", +}); + +XPCOMUtils.defineLazyModuleGetters(lazy, { + AboutNewTab: "resource:///modules/AboutNewTab.jsm", +}); + +// The scalar category of TopSites impression for Contextual Services +const SCALAR_CATEGORY_TOPSITES = "contextual.services.topsites.impression"; + +// These prefs must be true for the provider to return results. They are assumed +// to be booleans. We check `system.topsites` because if it is disabled we would +// get stale or empty top sites data. +const TOP_SITES_ENABLED_PREFS = [ + "browser.urlbar.suggest.topsites", + "browser.newtabpage.activity-stream.feeds.system.topsites", +]; + +/** + * A provider that returns the Top Sites shown on about:newtab. + */ +class ProviderTopSites extends UrlbarProvider { + constructor() { + super(); + + this._topSitesListeners = []; + let callListeners = () => this._callTopSitesListeners(); + Services.obs.addObserver(callListeners, "newtab-top-sites-changed"); + for (let pref of TOP_SITES_ENABLED_PREFS) { + Services.prefs.addObserver(pref, callListeners); + } + } + + get PRIORITY() { + // Top sites are prioritized over the UrlbarProviderPlaces provider. + return 1; + } + + /** + * Unique name for the provider, used by the context to filter on providers. + * Not using a unique name will cause the newest registration to win. + * + * @returns {string} + */ + get name() { + return "UrlbarProviderTopSites"; + } + + /** + * The type of the provider. + * + * @returns {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 + * @returns {boolean} Whether this provider should be invoked for the search. + */ + isActive(queryContext) { + return ( + !queryContext.restrictSource && + !queryContext.searchString && + !queryContext.searchMode + ); + } + + /** + * Gets the provider's priority. + * + * @param {UrlbarQueryContext} queryContext The query context object + * @returns {number} The provider's priority for the given query. + */ + getPriority(queryContext) { + return this.PRIORITY; + } + + /** + * 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) { + // Bail if Top Sites are not enabled. We check this condition here instead + // of in isActive because we still want this provider to be restricting even + // if this is not true. If it wasn't restricting, we would show the results + // from UrlbarProviderPlaces's empty search behaviour. We aren't interested + // in those since they are very similar to Top Sites and thus might be + // confusing, especially since users can configure Top Sites but cannot + // configure the default empty search results. See bug 1623666. + let enabled = TOP_SITES_ENABLED_PREFS.every(p => + Services.prefs.getBoolPref(p, false) + ); + if (!enabled) { + return; + } + + let sites = lazy.AboutNewTab.getTopSites(); + + let instance = this.queryInstance; + + // Filter out empty values. Site is empty when there's a gap between tiles + // on about:newtab. + sites = sites.filter(site => site); + + if (!lazy.UrlbarPrefs.get("sponsoredTopSites")) { + sites = sites.filter(site => !site.sponsored_position); + } + + // This is done here, rather than in the global scope, because + // TOP_SITES_DEFAULT_ROWS causes the import of Reducers.jsm, and we want to + // do that only when actually querying for Top Sites. + if (this.topSitesRows === undefined) { + XPCOMUtils.defineLazyPreferenceGetter( + this, + "topSitesRows", + "browser.newtabpage.activity-stream.topSitesRows", + lazy.TOP_SITES_DEFAULT_ROWS + ); + } + + // We usually respect maxRichResults, though we never show a number of Top + // Sites greater than what is visible in the New Tab Page, because the + // additional ones couldn't be managed from the page. + let numTopSites = Math.min( + lazy.UrlbarPrefs.get("maxRichResults"), + lazy.TOP_SITES_MAX_SITES_PER_ROW * this.topSitesRows + ); + sites = sites.slice(0, numTopSites); + + let sponsoredSites = []; + let index = 1; + sites = sites.map(link => { + let site = { + type: link.searchTopSite ? "search" : "url", + url: link.url_urlbar || link.url, + isPinned: !!link.isPinned, + isSponsored: !!link.sponsored_position, + // The newtab page allows the user to set custom site titles, which + // are stored in `label`, so prefer it. Search top sites currently + // don't have titles but `hostname` instead. + title: link.label || link.title || link.hostname || "", + favicon: link.smallFavicon || link.favicon || undefined, + sendAttributionRequest: !!link.sendAttributionRequest, + }; + if (site.isSponsored) { + let { + sponsored_tile_id, + sponsored_impression_url, + sponsored_click_url, + } = link; + site = { + ...site, + sponsoredTileId: sponsored_tile_id, + sponsoredImpressionUrl: sponsored_impression_url, + sponsoredClickUrl: sponsored_click_url, + position: index, + }; + sponsoredSites.push(site); + } + index++; + return site; + }); + + // Store Sponsored Top Sites so we can use it in `onEngagement` + if (sponsoredSites.length) { + this.sponsoredSites = sponsoredSites; + } + + for (let site of sites) { + switch (site.type) { + case "url": { + let payload = { + title: site.title, + url: site.url, + icon: site.favicon, + isPinned: site.isPinned, + isSponsored: site.isSponsored, + sendAttributionRequest: site.sendAttributionRequest, + }; + if (site.isSponsored) { + payload = { + ...payload, + sponsoredTileId: site.sponsoredTileId, + sponsoredClickUrl: site.sponsoredClickUrl, + }; + } + let result = new lazy.UrlbarResult( + UrlbarUtils.RESULT_TYPE.URL, + UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL, + ...lazy.UrlbarResult.payloadAndSimpleHighlights( + queryContext.tokens, + payload + ) + ); + + let tabs; + if (lazy.UrlbarPrefs.get("suggest.openpage")) { + tabs = lazy.UrlbarProviderOpenTabs.getOpenTabs( + queryContext.userContextId || 0, + queryContext.isPrivate + ); + } + + if (tabs && tabs.includes(site.url.replace(/#.*$/, ""))) { + result.type = UrlbarUtils.RESULT_TYPE.TAB_SWITCH; + result.source = UrlbarUtils.RESULT_SOURCE.TABS; + } else if (lazy.UrlbarPrefs.get("suggest.bookmark")) { + let bookmark = await lazy.PlacesUtils.bookmarks.fetch({ + url: new URL(result.payload.url), + }); + if (bookmark) { + result.source = UrlbarUtils.RESULT_SOURCE.BOOKMARKS; + } + } + + // Our query has been cancelled. + if (instance != this.queryInstance) { + break; + } + + addCallback(this, result); + break; + } + case "search": { + let engine = await lazy.UrlbarSearchUtils.engineForAlias(site.title); + + if (!engine && site.url) { + // Look up the engine by its domain. + let host; + try { + host = new URL(site.url).hostname; + } catch (err) {} + if (host) { + engine = ( + await lazy.UrlbarSearchUtils.enginesForDomainPrefix(host) + )[0]; + } + } + + if (!engine) { + // No engine found. We skip this Top Site. + break; + } + + if (instance != this.queryInstance) { + break; + } + + let result = new lazy.UrlbarResult( + UrlbarUtils.RESULT_TYPE.SEARCH, + UrlbarUtils.RESULT_SOURCE.SEARCH, + ...lazy.UrlbarResult.payloadAndSimpleHighlights( + queryContext.tokens, + { + title: site.title, + keyword: site.title, + providesSearchMode: true, + engine: engine.name, + query: "", + icon: site.favicon, + isPinned: site.isPinned, + } + ) + ); + addCallback(this, result); + break; + } + default: + this.logger.error(`Unknown Top Site type: ${site.type}`); + break; + } + } + } + + /** + * Called when the user starts and ends an engagement with the urlbar. We send + * the impression ping for the sponsored TopSites, the impression scalar is + * recorded as well. + * + * Note: + * No telemetry recording in private browsing mode + * The impression is only recorded for the "engagement" and "abandonment" + * states + * + * @param {boolean} isPrivate True if the engagement is in a private context. + * @param {string} state The state of the engagement, one of: start, + * engagement, abandonment, discard. + */ + onEngagement(isPrivate, state) { + if ( + !isPrivate && + this.sponsoredSites && + ["engagement", "abandonment"].includes(state) + ) { + for (let site of this.sponsoredSites) { + Services.telemetry.keyedScalarAdd( + SCALAR_CATEGORY_TOPSITES, + `urlbar_${site.position}`, + 1 + ); + lazy.PartnerLinkAttribution.sendContextualServicesPing( + { + source: "urlbar", + tile_id: site.sponsoredTileId || -1, + position: site.position, + reporting_url: site.sponsoredImpressionUrl, + advertiser: site.title.toLocaleLowerCase(), + }, + lazy.CONTEXTUAL_SERVICES_PING_TYPES.TOPSITES_IMPRESSION + ); + } + } + + this.sponsoredSites = null; + } + + /** + * Adds a listener function that will be called when the top sites change or + * they are enabled/disabled. This class will hold a weak reference to the + * listener, so you do not need to unregister it, but you or someone else must + * keep a strong reference to it to keep it from being immediately garbage + * collected. + * + * @param {Function} callback + * The listener function. This class will hold a weak reference to it. + */ + addTopSitesListener(callback) { + this._topSitesListeners.push(Cu.getWeakReference(callback)); + } + + _callTopSitesListeners() { + for (let i = 0; i < this._topSitesListeners.length; ) { + let listener = this._topSitesListeners[i].get(); + if (!listener) { + // The listener has been GC'ed, so remove it from our list. + this._topSitesListeners.splice(i, 1); + } else { + listener(); + ++i; + } + } + } +} + +export var UrlbarProviderTopSites = new ProviderTopSites(); |