mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-07 13:53:33 +00:00
272 lines
8.4 KiB
JavaScript
272 lines
8.4 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/. */
|
|
|
|
/* global XPCOMUtils, Services, BinarySearch, PlacesUtils, gPrincipal, EventEmitter */
|
|
/* global gLinks */
|
|
/* exported PlacesProvider */
|
|
|
|
"use strict";
|
|
|
|
this.EXPORTED_SYMBOLS = ["PlacesProvider"];
|
|
|
|
const {interfaces: Ci, utils: Cu} = Components;
|
|
Cu.import("resource://gre/modules/Services.jsm");
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "BinarySearch",
|
|
"resource://gre/modules/BinarySearch.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",
|
|
"resource://gre/modules/PlacesUtils.jsm");
|
|
|
|
XPCOMUtils.defineLazyGetter(this, "EventEmitter", function() {
|
|
const {EventEmitter} = Cu.import("resource://devtools/shared/event-emitter.js", {});
|
|
return EventEmitter;
|
|
});
|
|
|
|
XPCOMUtils.defineLazyGetter(this, "gPrincipal", function() {
|
|
let uri = Services.io.newURI("about:newtab", null, null);
|
|
return Services.scriptSecurityManager.getNoAppCodebasePrincipal(uri);
|
|
});
|
|
|
|
// The maximum number of results PlacesProvider retrieves from history.
|
|
const HISTORY_RESULTS_LIMIT = 100;
|
|
|
|
/**
|
|
* Singleton that checks if a given link should be displayed on about:newtab
|
|
* or if we should rather not do it for security reasons. URIs that inherit
|
|
* their caller's principal will be filtered.
|
|
*/
|
|
let LinkChecker = {
|
|
_cache: new Map(),
|
|
|
|
get flags() {
|
|
return Ci.nsIScriptSecurityManager.DISALLOW_INHERIT_PRINCIPAL |
|
|
Ci.nsIScriptSecurityManager.DONT_REPORT_ERRORS;
|
|
},
|
|
|
|
checkLoadURI: function LinkChecker_checkLoadURI(aURI) {
|
|
if (!this._cache.has(aURI)) {
|
|
this._cache.set(aURI, this._doCheckLoadURI(aURI));
|
|
}
|
|
|
|
return this._cache.get(aURI);
|
|
},
|
|
|
|
_doCheckLoadURI: function LinkChecker_doCheckLoadURI(aURI) {
|
|
let result = false;
|
|
try {
|
|
Services.scriptSecurityManager.
|
|
checkLoadURIStrWithPrincipal(gPrincipal, aURI, this.flags);
|
|
result = true;
|
|
} catch (e) {
|
|
// We got a weird URI or one that would inherit the caller's principal.
|
|
Cu.reportError(e);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Singleton that provides utility functions for links.
|
|
* A link is a plain object that looks like this:
|
|
*
|
|
* {
|
|
* url: "http://www.mozilla.org/",
|
|
* title: "Mozilla",
|
|
* frecency: 1337,
|
|
* lastVisitDate: 1394678824766431,
|
|
* }
|
|
*/
|
|
const LinkUtils = {
|
|
_sortProperties: [
|
|
"frecency",
|
|
"lastVisitDate",
|
|
"url",
|
|
],
|
|
|
|
/**
|
|
* Compares two links.
|
|
*
|
|
* @param {String} aLink1 The first link.
|
|
* @param {String} aLink2 The second link.
|
|
* @return {Number} A negative number if aLink1 is ordered before aLink2, zero if
|
|
* aLink1 and aLink2 have the same ordering, or a positive number if
|
|
* aLink1 is ordered after aLink2.
|
|
* Order is ascending.
|
|
*/
|
|
compareLinks: function LinkUtils_compareLinks(aLink1, aLink2) {
|
|
for (let prop of LinkUtils._sortProperties) {
|
|
if (!aLink1.hasOwnProperty(prop) || !aLink2.hasOwnProperty(prop)) {
|
|
throw new Error("Comparable link missing required property: " + prop);
|
|
}
|
|
}
|
|
return aLink2.frecency - aLink1.frecency ||
|
|
aLink2.lastVisitDate - aLink1.lastVisitDate ||
|
|
aLink1.url.localeCompare(aLink2.url);
|
|
},
|
|
};
|
|
|
|
/* Queries history to retrieve the most visited sites. Emits events when the
|
|
* history changes.
|
|
* Implements the EventEmitter interface.
|
|
*/
|
|
let Links = function Links() {
|
|
EventEmitter.decorate(this);
|
|
};
|
|
|
|
Links.prototype = {
|
|
/**
|
|
* Set this to change the maximum number of links the provider will provide.
|
|
*/
|
|
get maxNumLinks() {
|
|
// getter, so it can't be replaced dynamically
|
|
return HISTORY_RESULTS_LIMIT;
|
|
},
|
|
|
|
/**
|
|
* A set of functions called by @mozilla.org/browser/nav-historyservice
|
|
* All history events are emitted from this object.
|
|
*/
|
|
historyObserver: {
|
|
onDeleteURI: function historyObserver_onDeleteURI(aURI) {
|
|
// let observers remove sensetive data associated with deleted visit
|
|
gLinks.emit("deleteURI", {
|
|
url: aURI.spec,
|
|
});
|
|
},
|
|
|
|
onClearHistory: function historyObserver_onClearHistory() {
|
|
gLinks.emit("clearHistory");
|
|
},
|
|
|
|
onFrecencyChanged: function historyObserver_onFrecencyChanged(aURI,
|
|
aNewFrecency, aGUID, aHidden, aLastVisitDate) { // jshint ignore:line
|
|
// The implementation of the query in getLinks excludes hidden and
|
|
// unvisited pages, so it's important to exclude them here, too.
|
|
if (!aHidden && aLastVisitDate) {
|
|
gLinks.emit("linkChanged", {
|
|
url: aURI.spec,
|
|
frecency: aNewFrecency,
|
|
lastVisitDate: aLastVisitDate,
|
|
type: "history",
|
|
});
|
|
}
|
|
},
|
|
|
|
onManyFrecenciesChanged: function historyObserver_onManyFrecenciesChanged() {
|
|
// Called when frecencies are invalidated and also when clearHistory is called
|
|
// See toolkit/components/places/tests/unit/test_frecency_observers.js
|
|
gLinks.emit("manyLinksChanged");
|
|
},
|
|
|
|
onTitleChanged: function historyObserver_onTitleChanged(aURI, aNewTitle) {
|
|
gLinks.emit("linkChanged", {
|
|
url: aURI.spec,
|
|
title: aNewTitle
|
|
});
|
|
},
|
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver,
|
|
Ci.nsISupportsWeakReference])
|
|
},
|
|
|
|
/**
|
|
* Must be called before the provider is used.
|
|
* Makes it easy to disable under pref
|
|
*/
|
|
init: function PlacesProvider_init() {
|
|
PlacesUtils.history.addObserver(this.historyObserver, true);
|
|
},
|
|
|
|
/**
|
|
* Must be called before the provider is unloaded.
|
|
*/
|
|
destroy: function PlacesProvider_destroy() {
|
|
PlacesUtils.history.removeObserver(this.historyObserver);
|
|
},
|
|
|
|
/**
|
|
* Gets the current set of links delivered by this provider.
|
|
*
|
|
* @returns {Promise} Returns a promise with the array of links as payload.
|
|
*/
|
|
getLinks: function PlacesProvider_getLinks() {
|
|
let getLinksPromise = new Promise((resolve, reject) => {
|
|
let options = PlacesUtils.history.getNewQueryOptions();
|
|
options.maxResults = this.maxNumLinks;
|
|
|
|
// Sort by frecency, descending.
|
|
options.sortingMode = Ci.nsINavHistoryQueryOptions
|
|
.SORT_BY_FRECENCY_DESCENDING;
|
|
|
|
let links = [];
|
|
|
|
let queryHandlers = {
|
|
handleResult: function(aResultSet) {
|
|
for (let row = aResultSet.getNextRow(); row; row = aResultSet.getNextRow()) {
|
|
let url = row.getResultByIndex(1);
|
|
if (LinkChecker.checkLoadURI(url)) {
|
|
let link = {
|
|
url: url,
|
|
title: row.getResultByIndex(2),
|
|
frecency: row.getResultByIndex(12),
|
|
lastVisitDate: row.getResultByIndex(5),
|
|
type: "history",
|
|
};
|
|
links.push(link);
|
|
}
|
|
}
|
|
},
|
|
|
|
handleError: function(aError) {
|
|
reject(aError);
|
|
},
|
|
|
|
handleCompletion: function(aReason) { // jshint ignore:line
|
|
// The Places query breaks ties in frecency by place ID descending, but
|
|
// that's different from how Links.compareLinks breaks ties, because
|
|
// compareLinks doesn't have access to place IDs. It's very important
|
|
// that the initial list of links is sorted in the same order imposed by
|
|
// compareLinks, because Links uses compareLinks to perform binary
|
|
// searches on the list. So, ensure the list is so ordered.
|
|
let i = 1;
|
|
let outOfOrder = [];
|
|
while (i < links.length) {
|
|
if (LinkUtils.compareLinks(links[i - 1], links[i]) > 0) {
|
|
outOfOrder.push(links.splice(i, 1)[0]);
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
for (let link of outOfOrder) {
|
|
i = BinarySearch.insertionIndexOf(LinkUtils.compareLinks, links, link);
|
|
links.splice(i, 0, link);
|
|
}
|
|
|
|
resolve(links);
|
|
}
|
|
};
|
|
|
|
// Execute the query.
|
|
let query = PlacesUtils.history.getNewQuery();
|
|
let db = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase);
|
|
db.asyncExecuteLegacyQueries([query], 1, options, queryHandlers);
|
|
});
|
|
|
|
return getLinksPromise;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Singleton that serves as the default link provider for the grid.
|
|
*/
|
|
const gLinks = new Links(); // jshint ignore:line
|
|
|
|
let PlacesProvider = {
|
|
LinkChecker: LinkChecker,
|
|
LinkUtils: LinkUtils,
|
|
links: gLinks,
|
|
};
|