diff options
Diffstat (limited to '')
| -rw-r--r-- | toolkit/components/places/PlacesUtils.sys.mjs | 3083 |
1 files changed, 3083 insertions, 0 deletions
diff --git a/toolkit/components/places/PlacesUtils.sys.mjs b/toolkit/components/places/PlacesUtils.sys.mjs new file mode 100644 index 0000000000..f840566f1f --- /dev/null +++ b/toolkit/components/places/PlacesUtils.sys.mjs @@ -0,0 +1,3083 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; + +import { PromiseUtils } from "resource://gre/modules/PromiseUtils.sys.mjs"; +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + Bookmarks: "resource://gre/modules/Bookmarks.sys.mjs", + History: "resource://gre/modules/History.sys.mjs", + Log: "resource://gre/modules/Log.sys.mjs", + PlacesSyncUtils: "resource://gre/modules/PlacesSyncUtils.sys.mjs", + Sqlite: "resource://gre/modules/Sqlite.sys.mjs", +}); + +XPCOMUtils.defineLazyGetter(lazy, "MOZ_ACTION_REGEX", () => { + return /^moz-action:([^,]+),(.*)$/; +}); + +XPCOMUtils.defineLazyGetter(lazy, "gCryptoHash", () => { + return Cc["@mozilla.org/security/hash;1"].createInstance(Ci.nsICryptoHash); +}); + +// On Mac OSX, the transferable system converts "\r\n" to "\n\n", where +// we really just want "\n". On other platforms, the transferable system +// converts "\r\n" to "\n". +const NEWLINE = AppConstants.platform == "macosx" ? "\n" : "\r\n"; + +// Timers resolution is not always good, it can have a 16ms precision on Win. +const TIMERS_RESOLUTION_SKEW_MS = 16; + +function QI_node(aNode, aIID) { + try { + return aNode.QueryInterface(aIID); + } catch (ex) {} + return null; +} +function asContainer(aNode) { + return QI_node(aNode, Ci.nsINavHistoryContainerResultNode); +} +function asQuery(aNode) { + return QI_node(aNode, Ci.nsINavHistoryQueryResultNode); +} + +/** + * Sends a keyword change notification. + * + * @param url + * the url to notify about. + * @param keyword + * The keyword to notify, or empty string if a keyword was removed. + */ +async function notifyKeywordChange(url, keyword, source) { + // Notify bookmarks about the removal. + let bookmarks = []; + await PlacesUtils.bookmarks.fetch({ url }, b => bookmarks.push(b)); + for (let bookmark of bookmarks) { + let ids = await PlacesUtils.promiseManyItemIds([ + bookmark.guid, + bookmark.parentGuid, + ]); + bookmark.id = ids.get(bookmark.guid); + bookmark.parentId = ids.get(bookmark.parentGuid); + } + + const notifications = bookmarks.map( + bookmark => + new PlacesBookmarkKeyword({ + id: bookmark.id, + itemType: bookmark.type, + url, + guid: bookmark.guid, + parentGuid: bookmark.parentGuid, + keyword, + lastModified: bookmark.lastModified, + source, + isTagging: false, + }) + ); + if (notifications.length) { + PlacesObservers.notifyListeners(notifications); + } +} + +/** + * Serializes the given node in JSON format. + * + * @param aNode + * An nsINavHistoryResultNode + */ +function serializeNode(aNode) { + let data = {}; + + data.title = aNode.title; + // The id is no longer used for copying within the same instance/session of + // Firefox as of at least 61. However, we keep the id for now to maintain + // backwards compat of drag and drop with older Firefox versions. + data.id = aNode.itemId; + data.itemGuid = aNode.bookmarkGuid; + // Add an instanceId so we can tell which instance of an FF session the data + // is coming from. + data.instanceId = PlacesUtils.instanceId; + + let guid = aNode.bookmarkGuid; + + // Some nodes, e.g. the unfiled/menu/toolbar ones can have a virtual guid, so + // we ignore any that are a folder shortcut. These will be handled below. + if ( + guid && + !PlacesUtils.bookmarks.isVirtualRootItem(guid) && + !PlacesUtils.isVirtualLeftPaneItem(guid) + ) { + if (aNode.parent) { + data.parent = aNode.parent.itemId; + data.parentGuid = aNode.parent.bookmarkGuid; + } + + data.dateAdded = aNode.dateAdded; + data.lastModified = aNode.lastModified; + } + + if (PlacesUtils.nodeIsURI(aNode)) { + // Check for url validity. + new URL(aNode.uri); + data.type = PlacesUtils.TYPE_X_MOZ_PLACE; + data.uri = aNode.uri; + if (aNode.tags) { + data.tags = aNode.tags; + } + } else if (PlacesUtils.nodeIsFolder(aNode)) { + if (aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER_SHORTCUT) { + data.type = PlacesUtils.TYPE_X_MOZ_PLACE; + data.uri = aNode.uri; + data.concreteGuid = PlacesUtils.getConcreteItemGuid(aNode); + } else { + data.type = PlacesUtils.TYPE_X_MOZ_PLACE_CONTAINER; + } + } else if (PlacesUtils.nodeIsQuery(aNode)) { + data.type = PlacesUtils.TYPE_X_MOZ_PLACE; + data.uri = aNode.uri; + } else if (PlacesUtils.nodeIsSeparator(aNode)) { + data.type = PlacesUtils.TYPE_X_MOZ_PLACE_SEPARATOR; + } + + return JSON.stringify(data); +} + +// Imposed to limit database size. +const DB_URL_LENGTH_MAX = 65536; +const DB_TITLE_LENGTH_MAX = 4096; +const DB_DESCRIPTION_LENGTH_MAX = 256; +const DB_SITENAME_LENGTH_MAX = 50; + +/** + * Executes a boolean validate function, throwing if it returns false. + * + * @param boolValidateFn + * A boolean validate function. + * @return the input value. + * @throws if input doesn't pass the validate function. + */ +function simpleValidateFunc(boolValidateFn) { + return (v, input) => { + if (!boolValidateFn(v, input)) { + throw new Error("Invalid value"); + } + return v; + }; +} + +/** + * List of bookmark object validators, one per each known property. + * Validators must throw if the property value is invalid and return a fixed up + * version of the value, if needed. + */ +const BOOKMARK_VALIDATORS = Object.freeze({ + guid: simpleValidateFunc(v => PlacesUtils.isValidGuid(v)), + parentGuid: simpleValidateFunc(v => PlacesUtils.isValidGuid(v)), + guidPrefix: simpleValidateFunc(v => PlacesUtils.isValidGuidPrefix(v)), + index: simpleValidateFunc( + v => Number.isInteger(v) && v >= PlacesUtils.bookmarks.DEFAULT_INDEX + ), + dateAdded: simpleValidateFunc(v => v.constructor.name == "Date" && !isNaN(v)), + lastModified: simpleValidateFunc( + v => v.constructor.name == "Date" && !isNaN(v) + ), + type: simpleValidateFunc( + v => + Number.isInteger(v) && + [ + PlacesUtils.bookmarks.TYPE_BOOKMARK, + PlacesUtils.bookmarks.TYPE_FOLDER, + PlacesUtils.bookmarks.TYPE_SEPARATOR, + ].includes(v) + ), + title: v => { + if (v === null) { + return ""; + } + if (typeof v == "string") { + return v.slice(0, DB_TITLE_LENGTH_MAX); + } + throw new Error("Invalid title"); + }, + url: v => { + simpleValidateFunc( + val => + (typeof val == "string" && val.length <= DB_URL_LENGTH_MAX) || + (val instanceof Ci.nsIURI && val.spec.length <= DB_URL_LENGTH_MAX) || + (URL.isInstance(val) && val.href.length <= DB_URL_LENGTH_MAX) + )(v); + if (typeof v === "string") { + return new URL(v); + } + if (v instanceof Ci.nsIURI) { + return URL.fromURI(v); + } + return v; + }, + source: simpleValidateFunc( + v => + Number.isInteger(v) && + Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) + ), + keyword: simpleValidateFunc(v => typeof v == "string" && v.length), + charset: simpleValidateFunc(v => typeof v == "string" && v.length), + postData: simpleValidateFunc(v => typeof v == "string" && v.length), + tags: simpleValidateFunc( + v => + Array.isArray(v) && + v.length && + v.every(item => item && typeof item == "string") + ), +}); + +// Sync bookmark records can contain additional properties. +const SYNC_BOOKMARK_VALIDATORS = Object.freeze({ + // Sync uses Places GUIDs for all records except roots. + recordId: simpleValidateFunc( + v => + typeof v == "string" && + (lazy.PlacesSyncUtils.bookmarks.ROOTS.includes(v) || + PlacesUtils.isValidGuid(v)) + ), + parentRecordId: v => SYNC_BOOKMARK_VALIDATORS.recordId(v), + // Sync uses kinds instead of types. + kind: simpleValidateFunc( + v => + typeof v == "string" && + Object.values(lazy.PlacesSyncUtils.bookmarks.KINDS).includes(v) + ), + query: simpleValidateFunc(v => v === null || (typeof v == "string" && v)), + folder: simpleValidateFunc( + v => + typeof v == "string" && + v && + v.length <= PlacesUtils.bookmarks.MAX_TAG_LENGTH + ), + tags: v => { + if (v === null) { + return []; + } + if (!Array.isArray(v)) { + throw new Error("Invalid tag array"); + } + for (let tag of v) { + if ( + typeof tag != "string" || + !tag || + tag.length > PlacesUtils.bookmarks.MAX_TAG_LENGTH + ) { + throw new Error(`Invalid tag: ${tag}`); + } + } + return v; + }, + keyword: simpleValidateFunc(v => v === null || typeof v == "string"), + dateAdded: simpleValidateFunc( + v => + typeof v === "number" && + v > lazy.PlacesSyncUtils.bookmarks.EARLIEST_BOOKMARK_TIMESTAMP + ), + feed: v => (v === null ? v : BOOKMARK_VALIDATORS.url(v)), + site: v => (v === null ? v : BOOKMARK_VALIDATORS.url(v)), + title: BOOKMARK_VALIDATORS.title, + url: BOOKMARK_VALIDATORS.url, +}); + +// Sync change records are passed between `PlacesSyncUtils` and the Sync +// bookmarks engine, and are used to update an item's sync status and change +// counter at the end of a sync. +const SYNC_CHANGE_RECORD_VALIDATORS = Object.freeze({ + modified: simpleValidateFunc(v => typeof v == "number" && v >= 0), + counter: simpleValidateFunc(v => typeof v == "number" && v >= 0), + status: simpleValidateFunc( + v => + typeof v == "number" && + Object.values(PlacesUtils.bookmarks.SYNC_STATUS).includes(v) + ), + tombstone: simpleValidateFunc(v => v === true || v === false), + synced: simpleValidateFunc(v => v === true || v === false), +}); +/** + * List PageInfo bookmark object validators. + */ +const PAGEINFO_VALIDATORS = Object.freeze({ + guid: BOOKMARK_VALIDATORS.guid, + url: BOOKMARK_VALIDATORS.url, + title: v => { + if (v == null || v == undefined) { + return undefined; + } else if (typeof v === "string") { + return v; + } + throw new TypeError( + `title property of PageInfo object: ${v} must be a string if provided` + ); + }, + previewImageURL: v => { + if (!v) { + return null; + } + return BOOKMARK_VALIDATORS.url(v); + }, + description: v => { + if (typeof v === "string" || v === null) { + return v ? v.slice(0, DB_DESCRIPTION_LENGTH_MAX) : null; + } + throw new TypeError( + `description property of pageInfo object: ${v} must be either a string or null if provided` + ); + }, + siteName: v => { + if (typeof v === "string" || v === null) { + return v ? v.slice(0, DB_SITENAME_LENGTH_MAX) : null; + } + throw new TypeError( + `siteName property of pageInfo object: ${v} must be either a string or null if provided` + ); + }, + annotations: v => { + if (typeof v != "object" || v.constructor.name != "Map") { + throw new TypeError("annotations must be a Map"); + } + + if (v.size == 0) { + throw new TypeError("there must be at least one annotation"); + } + + for (let [key, value] of v.entries()) { + if (typeof key != "string") { + throw new TypeError("all annotation keys must be strings"); + } + if ( + typeof value != "string" && + typeof value != "number" && + typeof value != "boolean" && + value !== null && + value !== undefined + ) { + throw new TypeError( + "all annotation values must be Boolean, Numbers or Strings" + ); + } + } + return v; + }, + visits: v => { + if (!Array.isArray(v) || !v.length) { + throw new TypeError("PageInfo object must have an array of visits"); + } + let visits = []; + for (let inVisit of v) { + let visit = { + date: new Date(), + transition: inVisit.transition || lazy.History.TRANSITIONS.LINK, + }; + + if (!PlacesUtils.history.isValidTransition(visit.transition)) { + throw new TypeError( + `transition: ${visit.transition} is not a valid transition type` + ); + } + + if (inVisit.date) { + PlacesUtils.history.ensureDate(inVisit.date); + if (inVisit.date > Date.now() + TIMERS_RESOLUTION_SKEW_MS) { + throw new TypeError(`date: ${inVisit.date} cannot be a future date`); + } + visit.date = inVisit.date; + } + + if (inVisit.referrer) { + visit.referrer = PlacesUtils.normalizeToURLOrGUID(inVisit.referrer); + } + visits.push(visit); + } + return visits; + }, +}); + +export var PlacesUtils = { + // Place entries that are containers, e.g. bookmark folders or queries. + TYPE_X_MOZ_PLACE_CONTAINER: "text/x-moz-place-container", + // Place entries that are bookmark separators. + TYPE_X_MOZ_PLACE_SEPARATOR: "text/x-moz-place-separator", + // Place entries that are not containers or separators + TYPE_X_MOZ_PLACE: "text/x-moz-place", + // Place entries in shortcut url format (url\ntitle) + TYPE_X_MOZ_URL: "text/x-moz-url", + // Place entries formatted as HTML anchors + TYPE_HTML: "text/html", + // Place entries as raw URL text + TYPE_PLAINTEXT: "text/plain", + // Used to track the action that populated the clipboard. + TYPE_X_MOZ_PLACE_ACTION: "text/x-moz-place-action", + + // Deprecated: Remaining only for supporting migration of old livemarks. + LMANNO_FEEDURI: "livemark/feedURI", + LMANNO_SITEURI: "livemark/siteURI", + CHARSET_ANNO: "URIProperties/characterSet", + // Deprecated: This is only used for supporting import from older datasets. + MOBILE_ROOT_ANNO: "mobile/bookmarksRoot", + + TOPIC_SHUTDOWN: "places-shutdown", + TOPIC_INIT_COMPLETE: "places-init-complete", + TOPIC_DATABASE_LOCKED: "places-database-locked", + TOPIC_EXPIRATION_FINISHED: "places-expiration-finished", + TOPIC_FAVICONS_EXPIRED: "places-favicons-expired", + TOPIC_VACUUM_STARTING: "places-vacuum-starting", + TOPIC_BOOKMARKS_RESTORE_BEGIN: "bookmarks-restore-begin", + TOPIC_BOOKMARKS_RESTORE_SUCCESS: "bookmarks-restore-success", + TOPIC_BOOKMARKS_RESTORE_FAILED: "bookmarks-restore-failed", + + observers: PlacesObservers, + + /** + * GUIDs associated with virtual queries that are used for displaying the + * top-level folders in the left pane. + */ + virtualAllBookmarksGuid: "allbms_____v", + virtualHistoryGuid: "history____v", + virtualDownloadsGuid: "downloads__v", + virtualTagsGuid: "tags_______v", + + /** + * Checks if a guid is a virtual left-pane root. + * + * @param {String} guid The guid of the item to look for. + * @returns {Boolean} true if guid is a virtual root, false otherwise. + */ + isVirtualLeftPaneItem(guid) { + return ( + guid == PlacesUtils.virtualAllBookmarksGuid || + guid == PlacesUtils.virtualHistoryGuid || + guid == PlacesUtils.virtualDownloadsGuid || + guid == PlacesUtils.virtualTagsGuid + ); + }, + + asContainer: aNode => asContainer(aNode), + asQuery: aNode => asQuery(aNode), + + endl: NEWLINE, + + /** + * Is a string a valid GUID? + * + * @param guid: (String) + * @return (Boolean) + */ + isValidGuid(guid) { + return typeof guid == "string" && guid && /^[a-zA-Z0-9\-_]{12}$/.test(guid); + }, + + /** + * Is a string a valid GUID prefix? + * + * @param guidPrefix: (String) + * @return (Boolean) + */ + isValidGuidPrefix(guidPrefix) { + return ( + typeof guidPrefix == "string" && + guidPrefix && + /^[a-zA-Z0-9\-_]{1,11}$/.test(guidPrefix) + ); + }, + + /** + * Generates a random GUID and replace its beginning with the given + * prefix. We do this instead of just prepending the prefix to keep + * the correct character length. + * + * @param prefix: (String) + * @return (String) + */ + generateGuidWithPrefix(prefix) { + return prefix + this.history.makeGuid().substring(prefix.length); + }, + + /** + * Converts a string or n URL object to an nsIURI. + * + * @param url (URL) or (String) + * the URL to convert. + * @return nsIURI for the given URL. + */ + toURI(url) { + if (url instanceof Ci.nsIURI) { + return url; + } + if (URL.isInstance(url)) { + return url.URI; + } + return Services.io.newURI(url); + }, + + /** + * Convert a Date object to a PRTime (microseconds). + * + * @param date + * the Date object to convert. + * @return microseconds from the epoch. + */ + toPRTime(date) { + if ( + (typeof date != "number" && date.constructor.name != "Date") || + isNaN(date) + ) { + throw new Error("Invalid value passed to toPRTime"); + } + return date * 1000; + }, + + /** + * Convert a PRTime to a Date object. + * + * @param time + * microseconds from the epoch. + * @return a Date object. + */ + toDate(time) { + if (typeof time != "number" || isNaN(time)) { + throw new Error("Invalid value passed to toDate"); + } + return new Date(parseInt(time / 1000)); + }, + + /** + * Wraps a string in a nsISupportsString wrapper. + * @param aString + * The string to wrap. + * @returns A nsISupportsString object containing a string. + */ + toISupportsString: function PU_toISupportsString(aString) { + let s = Cc["@mozilla.org/supports-string;1"].createInstance( + Ci.nsISupportsString + ); + s.data = aString; + return s; + }, + + getFormattedString: function PU_getFormattedString(key, params) { + return lazy.bundle.formatStringFromName(key, params); + }, + + getString: function PU_getString(key) { + return lazy.bundle.GetStringFromName(key); + }, + + /** + * Parses a moz-action URL and returns its parts. + * + * @param url A moz-action URI. + * @note URL is in the format moz-action:ACTION,JSON_ENCODED_PARAMS + */ + parseActionUrl(url) { + if (url instanceof Ci.nsIURI) { + url = url.spec; + } else if (URL.isInstance(url)) { + url = url.href; + } + // Faster bailout. + if (!url.startsWith("moz-action:")) { + return null; + } + + try { + let [, type, params] = url.match(lazy.MOZ_ACTION_REGEX); + let action = { + type, + params: JSON.parse(params), + }; + for (let key in action.params) { + action.params[key] = decodeURIComponent(action.params[key]); + } + return action; + } catch (ex) { + console.error(`Invalid action url "${url}"`); + return null; + } + }, + + /** + * Determines if a folder is generated from a query. + * @param aNode a result true. + * @returns true if the node is a folder generated from a query. + */ + isQueryGeneratedFolder(node) { + if (!node.parent) { + return false; + } + return this.nodeIsFolder(node) && this.nodeIsQuery(node.parent); + }, + + /** + * Determines whether or not a ResultNode is a Bookmark folder. + * @param aNode + * A result node + * @returns true if the node is a Bookmark folder, false otherwise + */ + nodeIsFolder: function PU_nodeIsFolder(aNode) { + return ( + aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER || + aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER_SHORTCUT + ); + }, + + /** + * Determines whether or not a ResultNode represents a bookmarked URI. + * @param aNode + * A result node + * @returns true if the node represents a bookmarked URI, false otherwise + */ + nodeIsBookmark: function PU_nodeIsBookmark(aNode) { + return ( + aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_URI && + aNode.itemId != -1 + ); + }, + + /** + * Determines whether or not a ResultNode is a Bookmark separator. + * @param aNode + * A result node + * @returns true if the node is a Bookmark separator, false otherwise + */ + nodeIsSeparator: function PU_nodeIsSeparator(aNode) { + return aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR; + }, + + /** + * Determines whether or not a ResultNode is a URL item. + * @param aNode + * A result node + * @returns true if the node is a URL item, false otherwise + */ + nodeIsURI: function PU_nodeIsURI(aNode) { + return aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_URI; + }, + + /** + * Determines whether or not a ResultNode is a Query item. + * @param aNode + * A result node + * @returns true if the node is a Query item, false otherwise + */ + nodeIsQuery: function PU_nodeIsQuery(aNode) { + return aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY; + }, + + /** + * Generator for a node's ancestors. + * @param aNode + * A result node + */ + nodeAncestors: function* PU_nodeAncestors(aNode) { + let node = aNode.parent; + while (node) { + yield node; + node = node.parent; + } + }, + + /** + * Checks validity of an object, filling up default values for optional + * properties. + * + * @param {string} name + * The operation name. This is included in the error message if + * validation fails. + * @param validators (object) + * An object containing input validators. Keys should be field names; + * values should be validation functions. + * @param props (object) + * The object to validate. + * @param behavior (object) [optional] + * Object defining special behavior for some of the properties. + * The following behaviors may be optionally set: + * - required: this property is required. + * - replaceWith: this property will be overwritten with the value + * provided + * - requiredIf: if the provided condition is satisfied, then this + * property is required. + * - validIf: if the provided condition is not satisfied, then this + * property is invalid. + * - defaultValue: an undefined property should default to this value. + * - fixup: a function invoked when validation fails, takes the input + * object as argument and must fix the property. + * + * @return a validated and normalized item. + * @throws if the object contains invalid data. + * @note any unknown properties are pass-through. + */ + validateItemProperties(name, validators, props, behavior = {}) { + if (typeof props != "object" || !props) { + throw new Error(`${name}: Input should be a valid object`); + } + // Make a shallow copy of `props` to avoid mutating the original object + // when filling in defaults. + let input = Object.assign({}, props); + let normalizedInput = {}; + let required = new Set(); + for (let prop in behavior) { + if ( + behavior[prop].hasOwnProperty("required") && + behavior[prop].required + ) { + required.add(prop); + } + if ( + behavior[prop].hasOwnProperty("requiredIf") && + behavior[prop].requiredIf(input) + ) { + required.add(prop); + } + if ( + behavior[prop].hasOwnProperty("validIf") && + input[prop] !== undefined && + !behavior[prop].validIf(input) + ) { + if (behavior[prop].hasOwnProperty("fixup")) { + behavior[prop].fixup(input); + } else { + throw new Error( + `${name}: Invalid value for property '${prop}': ${JSON.stringify( + input[prop] + )}` + ); + } + } + if ( + behavior[prop].hasOwnProperty("defaultValue") && + input[prop] === undefined + ) { + input[prop] = behavior[prop].defaultValue; + } + if (behavior[prop].hasOwnProperty("replaceWith")) { + input[prop] = behavior[prop].replaceWith; + } + } + + for (let prop in input) { + if (required.has(prop)) { + required.delete(prop); + } else if (input[prop] === undefined) { + // Skip undefined properties that are not required. + continue; + } + if (validators.hasOwnProperty(prop)) { + try { + normalizedInput[prop] = validators[prop](input[prop], input); + } catch (ex) { + if ( + behavior.hasOwnProperty(prop) && + behavior[prop].hasOwnProperty("fixup") + ) { + behavior[prop].fixup(input); + normalizedInput[prop] = input[prop]; + } else { + throw new Error( + `${name}: Invalid value for property '${prop}': ${JSON.stringify( + input[prop] + )}` + ); + } + } + } + } + if (required.size > 0) { + throw new Error( + `${name}: The following properties were expected: ${[...required].join( + ", " + )}` + ); + } + return normalizedInput; + }, + + BOOKMARK_VALIDATORS, + PAGEINFO_VALIDATORS, + SYNC_BOOKMARK_VALIDATORS, + SYNC_CHANGE_RECORD_VALIDATORS, + + QueryInterface: ChromeUtils.generateQI(["nsIObserver"]), + + _shutdownFunctions: [], + registerShutdownFunction: function PU_registerShutdownFunction(aFunc) { + // If this is the first registered function, add the shutdown observer. + if (!this._shutdownFunctions.length) { + Services.obs.addObserver(this, this.TOPIC_SHUTDOWN); + } + this._shutdownFunctions.push(aFunc); + }, + + // nsIObserver + observe: function PU_observe(aSubject, aTopic, aData) { + switch (aTopic) { + case this.TOPIC_SHUTDOWN: + Services.obs.removeObserver(this, this.TOPIC_SHUTDOWN); + while (this._shutdownFunctions.length) { + this._shutdownFunctions.shift().apply(this); + } + break; + } + }, + + /** + * Determines whether or not a ResultNode is a host container. + * @param aNode + * A result node + * @returns true if the node is a host container, false otherwise + */ + nodeIsHost: function PU_nodeIsHost(aNode) { + return ( + aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY && + aNode.parent && + asQuery(aNode.parent).queryOptions.resultType == + Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY + ); + }, + + /** + * Determines whether or not a ResultNode is a day container. + * @param node + * A NavHistoryResultNode + * @returns true if the node is a day container, false otherwise + */ + nodeIsDay: function PU_nodeIsDay(aNode) { + var resultType; + return ( + aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY && + aNode.parent && + ((resultType = asQuery(aNode.parent).queryOptions.resultType) == + Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY || + resultType == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY) + ); + }, + + /** + * Determines whether or not a result-node is a tag container. + * @param aNode + * A result-node + * @returns true if the node is a tag container, false otherwise + */ + nodeIsTagQuery: function PU_nodeIsTagQuery(aNode) { + if (aNode.type != Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY) { + return false; + } + // Direct child of RESULTS_AS_TAGS_ROOT. + let parent = aNode.parent; + if ( + parent && + PlacesUtils.asQuery(parent).queryOptions.resultType == + Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAGS_ROOT + ) { + return true; + } + // We must also support the right pane of the Library, when the tag query + // is the root node. Unfortunately this is also valid for any tag query + // selected in the left pane that is not a direct child of RESULTS_AS_TAGS_ROOT. + if ( + !parent && + aNode == aNode.parentResult.root && + PlacesUtils.asQuery(aNode).query.tags.length == 1 + ) { + return true; + } + return false; + }, + + /** + * Determines whether or not a ResultNode is a container. + * @param aNode + * A result node + * @returns true if the node is a container item, false otherwise + */ + containerTypes: [ + Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER, + Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER_SHORTCUT, + Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY, + ], + nodeIsContainer: function PU_nodeIsContainer(aNode) { + return this.containerTypes.includes(aNode.type); + }, + + /** + * Determines whether or not a ResultNode is an history related container. + * @param node + * A result node + * @returns true if the node is an history related container, false otherwise + */ + nodeIsHistoryContainer: function PU_nodeIsHistoryContainer(aNode) { + var resultType; + return ( + this.nodeIsQuery(aNode) && + ((resultType = asQuery(aNode).queryOptions.resultType) == + Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY || + resultType == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY || + resultType == Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY || + this.nodeIsDay(aNode) || + this.nodeIsHost(aNode)) + ); + }, + + /** + * Gets the concrete item-guid for the given node. For everything but folder + * shortcuts, this is just node.bookmarkGuid. For folder shortcuts, this is + * node.targetFolderGuid (see nsINavHistoryService.idl for the semantics). + * + * @param aNode + * a result node. + * @return the concrete item-guid for aNode. + */ + getConcreteItemGuid(aNode) { + if (aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER_SHORTCUT) { + return asQuery(aNode).targetFolderGuid; + } + return aNode.bookmarkGuid; + }, + + /** + * Reverse a host based on the moz_places algorithm, that is reverse the host + * string and add a trailing period. For example "google.com" becomes + * "moc.elgoog.". + * + * @param url + * the URL to generate a rev host for. + * @return the reversed host string. + */ + getReversedHost(url) { + return url.host.split("").reverse().join("") + "."; + }, + + /** + * String-wraps a result node according to the rules of the specified + * content type for copy or move operations. + * + * @param aNode + * The Result node to wrap (serialize) + * @param aType + * The content type to serialize as + * @return A string serialization of the node + */ + wrapNode(aNode, aType) { + // when wrapping a node, we want all the items, even if the original + // query options are excluding them. + // This can happen when copying from the left hand pane of the bookmarks + // organizer. + // @return [node, shouldClose] + function gatherDataFromNode(node, gatherDataFunc) { + if ( + PlacesUtils.nodeIsFolder(node) && + node.type != Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER_SHORTCUT && + asQuery(node).queryOptions.excludeItems + ) { + let folderRoot = PlacesUtils.getFolderContents( + node.bookmarkGuid, + false, + true + ).root; + try { + return gatherDataFunc(folderRoot); + } finally { + folderRoot.containerOpen = false; + } + } + // If we didn't create our own query, do not alter the node's state. + return gatherDataFunc(node); + } + + function gatherDataHtml(node) { + let htmlEscape = s => + s + .replace(/&/g, "&") + .replace(/>/g, ">") + .replace(/</g, "<") + .replace(/"/g, """) + .replace(/'/g, "'"); + + // escape out potential HTML in the title + let escapedTitle = node.title ? htmlEscape(node.title) : ""; + + if (PlacesUtils.nodeIsContainer(node)) { + asContainer(node); + let wasOpen = node.containerOpen; + if (!wasOpen) { + node.containerOpen = true; + } + + let childString = "<DL><DT>" + escapedTitle + "</DT>" + NEWLINE; + let cc = node.childCount; + for (let i = 0; i < cc; ++i) { + childString += + "<DD>" + + NEWLINE + + gatherDataHtml(node.getChild(i)) + + "</DD>" + + NEWLINE; + } + node.containerOpen = wasOpen; + return childString + "</DL>" + NEWLINE; + } + if (PlacesUtils.nodeIsURI(node)) { + return `<A HREF="${node.uri}">${escapedTitle}</A>${NEWLINE}`; + } + if (PlacesUtils.nodeIsSeparator(node)) { + return "<HR>" + NEWLINE; + } + return ""; + } + + function gatherDataText(node) { + if (PlacesUtils.nodeIsContainer(node)) { + asContainer(node); + let wasOpen = node.containerOpen; + if (!wasOpen) { + node.containerOpen = true; + } + + let childString = node.title + NEWLINE; + let cc = node.childCount; + for (let i = 0; i < cc; ++i) { + let child = node.getChild(i); + let suffix = i < cc - 1 ? NEWLINE : ""; + childString += gatherDataText(child) + suffix; + } + node.containerOpen = wasOpen; + return childString; + } + if (PlacesUtils.nodeIsURI(node)) { + return node.uri; + } + if (PlacesUtils.nodeIsSeparator(node)) { + return "--------------------"; + } + return ""; + } + + switch (aType) { + case this.TYPE_X_MOZ_PLACE: + case this.TYPE_X_MOZ_PLACE_SEPARATOR: + case this.TYPE_X_MOZ_PLACE_CONTAINER: { + // Serialize the node to JSON. + return serializeNode(aNode); + } + case this.TYPE_X_MOZ_URL: { + if (PlacesUtils.nodeIsURI(aNode)) { + return aNode.uri + NEWLINE + aNode.title; + } + if (PlacesUtils.nodeIsContainer(aNode)) { + return PlacesUtils.getURLsForContainerNode(aNode) + .map(item => item.uri + "\n" + item.title) + .join("\n"); + } + return ""; + } + case this.TYPE_HTML: { + return gatherDataFromNode(aNode, gatherDataHtml); + } + } + + // Otherwise, we wrap as TYPE_PLAINTEXT. + return gatherDataFromNode(aNode, gatherDataText); + }, + + /** + * Unwraps data from the Clipboard or the current Drag Session. + * @param blob + * A blob (string) of data, in some format we potentially know how + * to parse. + * @param type + * The content type of the blob. + * @returns An array of objects representing each item contained by the source. + * @throws if the blob contains invalid data. + */ + unwrapNodes: function PU_unwrapNodes(blob, type) { + // We split on "\n" because the transferable system converts "\r\n" to "\n" + var nodes = []; + switch (type) { + case this.TYPE_X_MOZ_PLACE: + case this.TYPE_X_MOZ_PLACE_SEPARATOR: + case this.TYPE_X_MOZ_PLACE_CONTAINER: + nodes = JSON.parse("[" + blob + "]"); + break; + case this.TYPE_X_MOZ_URL: { + let parts = blob.split("\n"); + // data in this type has 2 parts per entry, so if there are fewer + // than 2 parts left, the blob is malformed and we should stop + // but drag and drop of files from the shell has parts.length = 1 + if (parts.length != 1 && parts.length % 2) { + break; + } + for (let i = 0; i < parts.length; i = i + 2) { + let uriString = parts[i]; + let titleString = ""; + if (parts.length > i + 1) { + titleString = parts[i + 1]; + } else { + // for drag and drop of files, try to use the leafName as title + try { + titleString = Services.io + .newURI(uriString) + .QueryInterface(Ci.nsIURL).fileName; + } catch (ex) {} + } + // note: Services.io.newURI() will throw if uriString is not a valid URI + let uri = Services.io.newURI(uriString); + if (Services.io.newURI(uriString) && uri.scheme != "place") { + nodes.push({ + uri: uriString, + title: titleString ? titleString : uriString, + type: this.TYPE_X_MOZ_URL, + }); + } + } + break; + } + case this.TYPE_PLAINTEXT: { + let parts = blob.split("\n"); + for (let i = 0; i < parts.length; i++) { + let uriString = parts[i]; + // text/uri-list is converted to TYPE_PLAINTEXT but it could contain + // comments line prepended by #, we should skip them, as well as + // empty uris. + if (uriString.substr(0, 1) == "\x23" || uriString == "") { + continue; + } + // note: Services.io.newURI) will throw if uriString is not a valid URI + let uri = Services.io.newURI(uriString); + if (uri.scheme != "place") { + nodes.push({ + uri: uriString, + title: uriString, + type: this.TYPE_X_MOZ_URL, + }); + } + } + break; + } + default: + throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG); + } + return nodes; + }, + + /** + * Validate an input PageInfo object, returning a valid PageInfo object. + * + * @param pageInfo: (PageInfo) + * @return (PageInfo) + */ + validatePageInfo(pageInfo, validateVisits = true) { + return this.validateItemProperties( + "PageInfo", + PAGEINFO_VALIDATORS, + pageInfo, + { + url: { requiredIf: b => !b.guid }, + guid: { requiredIf: b => !b.url }, + visits: { requiredIf: b => validateVisits }, + } + ); + }, + /** + * Normalize a key to either a string (if it is a valid GUID) or an + * instance of `URL` (if it is a `URL`, `nsIURI`, or a string + * representing a valid url). + * + * @throws (TypeError) + * If the key is neither a valid guid nor a valid url. + */ + normalizeToURLOrGUID(key) { + if (typeof key === "string") { + // A string may be a URL or a guid + if (this.isValidGuid(key)) { + return key; + } + return new URL(key); + } + if (URL.isInstance(key)) { + return key; + } + if (key instanceof Ci.nsIURI) { + return URL.fromURI(key); + } + throw new TypeError("Invalid url or guid: " + key); + }, + + /** + * Generates a nsINavHistoryResult for the contents of a folder. + * @param aFolderGuid + * The folder to open + * @param [optional] excludeItems + * True to hide all items (individual bookmarks). This is used on + * the left places pane so you just get a folder hierarchy. + * @param [optional] expandQueries + * True to make query items expand as new containers. For managing, + * you want this to be false, for menus and such, you want this to + * be true. + * @returns A nsINavHistoryResult containing the contents of the + * folder. The result.root is guaranteed to be open. + */ + getFolderContents(aFolderGuid, aExcludeItems, aExpandQueries) { + if (!this.isValidGuid(aFolderGuid)) { + throw new Error("aFolderGuid should be a valid GUID."); + } + var query = this.history.getNewQuery(); + query.setParents([aFolderGuid]); + var options = this.history.getNewQueryOptions(); + options.excludeItems = aExcludeItems; + options.expandQueries = aExpandQueries; + + var result = this.history.executeQuery(query, options); + result.root.containerOpen = true; + return result; + }, + + // Identifier getters for special folders. + // You should use these everywhere PlacesUtils is available to avoid XPCOM + // traversal just to get roots' ids. + get tagsFolderId() { + delete this.tagsFolderId; + return (this.tagsFolderId = this.bookmarks.tagsFolder); + }, + + /** + * Checks if item is a root. + * + * @param {String} guid The guid of the item to look for. + * @returns {Boolean} true if guid is a root, false otherwise. + */ + isRootItem(guid) { + return ( + guid == PlacesUtils.bookmarks.menuGuid || + guid == PlacesUtils.bookmarks.toolbarGuid || + guid == PlacesUtils.bookmarks.unfiledGuid || + guid == PlacesUtils.bookmarks.tagsGuid || + guid == PlacesUtils.bookmarks.rootGuid || + guid == PlacesUtils.bookmarks.mobileGuid + ); + }, + + /** + * Returns a nsNavHistoryContainerResultNode with forced excludeItems and + * expandQueries. + * @param aNode + * The node to convert + * @param [optional] excludeItems + * True to hide all items (individual bookmarks). This is used on + * the left places pane so you just get a folder hierarchy. + * @param [optional] expandQueries + * True to make query items expand as new containers. For managing, + * you want this to be false, for menus and such, you want this to + * be true. + * @returns A nsINavHistoryContainerResultNode containing the unfiltered + * contents of the container. + * @note The returned container node could be open or closed, we don't + * guarantee its status. + */ + getContainerNodeWithOptions: function PU_getContainerNodeWithOptions( + aNode, + aExcludeItems, + aExpandQueries + ) { + if (!this.nodeIsContainer(aNode)) { + throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG); + } + + // excludeItems is inherited by child containers in an excludeItems view. + var excludeItems = + asQuery(aNode).queryOptions.excludeItems || + asQuery(aNode.parentResult.root).queryOptions.excludeItems; + // expandQueries is inherited by child containers in an expandQueries view. + var expandQueries = + asQuery(aNode).queryOptions.expandQueries && + asQuery(aNode.parentResult.root).queryOptions.expandQueries; + + // If our options are exactly what we expect, directly return the node. + if (excludeItems == aExcludeItems && expandQueries == aExpandQueries) { + return aNode; + } + + // Otherwise, get contents manually. + var query = {}, + options = {}; + this.history.queryStringToQuery(aNode.uri, query, options); + options.value.excludeItems = aExcludeItems; + options.value.expandQueries = aExpandQueries; + return this.history.executeQuery(query.value, options.value).root; + }, + + /** + * Returns true if a container has uri nodes in its first level. + * Has better performance than (getURLsForContainerNode(node).length > 0). + * @param aNode + * The container node to search through. + * @returns true if the node contains uri nodes, false otherwise. + */ + hasChildURIs: function PU_hasChildURIs(aNode) { + if (!this.nodeIsContainer(aNode)) { + return false; + } + + let root = this.getContainerNodeWithOptions(aNode, false, true); + let result = root.parentResult; + let didSuppressNotifications = false; + let wasOpen = root.containerOpen; + if (!wasOpen) { + didSuppressNotifications = result.suppressNotifications; + if (!didSuppressNotifications) { + result.suppressNotifications = true; + } + + root.containerOpen = true; + } + + let found = false; + for (let i = 0; i < root.childCount && !found; i++) { + let child = root.getChild(i); + if (this.nodeIsURI(child)) { + found = true; + } + } + + if (!wasOpen) { + root.containerOpen = false; + if (!didSuppressNotifications) { + result.suppressNotifications = false; + } + } + return found; + }, + + /** + * Returns an array containing all the uris in the first level of the + * passed in container. + * If you only need to know if the node contains uris, use hasChildURIs. + * @param aNode + * The container node to search through + * @returns array of uris in the first level of the container. + */ + getURLsForContainerNode: function PU_getURLsForContainerNode(aNode) { + let urls = []; + if (!this.nodeIsContainer(aNode)) { + return urls; + } + + let root = this.getContainerNodeWithOptions(aNode, false, true); + let result = root.parentResult; + let wasOpen = root.containerOpen; + let didSuppressNotifications = false; + if (!wasOpen) { + didSuppressNotifications = result.suppressNotifications; + if (!didSuppressNotifications) { + result.suppressNotifications = true; + } + + root.containerOpen = true; + } + + for (let i = 0; i < root.childCount; ++i) { + let child = root.getChild(i); + if (this.nodeIsURI(child)) { + urls.push({ + uri: child.uri, + isBookmark: this.nodeIsBookmark(child), + title: child.title, + }); + } + } + + if (!wasOpen) { + root.containerOpen = false; + if (!didSuppressNotifications) { + result.suppressNotifications = false; + } + } + return urls; + }, + + /** + * Gets a shared Sqlite.sys.mjs readonly connection to the Places database, + * usable only for SELECT queries. + * + * This is intended to be used mostly internally, components outside of + * Places should, when possible, use API calls and file bugs to get proper + * APIs, where they are missing. + * Keep in mind the Places DB schema is by no means frozen or even stable. + * Your custom queries can - and will - break overtime. + * + * Example: + * let db = await PlacesUtils.promiseDBConnection(); + * let rows = await db.executeCached(sql, params); + */ + promiseDBConnection: () => lazy.gAsyncDBConnPromised, + + /** + * This is pretty much the same as promiseDBConnection, but with a larger + * page cache, useful for consumers doing large table scans, like the urlbar. + * @see promiseDBConnection + */ + promiseLargeCacheDBConnection: () => lazy.gAsyncDBLargeCacheConnPromised, + get largeCacheDBConnDeferred() { + return gAsyncDBLargeCacheConnDeferred; + }, + + /** + * Returns a Sqlite.sys.mjs wrapper for the main Places connection. Most callers + * should prefer `withConnectionWrapper`, which ensures that all database + * operations finish before the connection is closed. + */ + promiseUnsafeWritableDBConnection: () => lazy.gAsyncDBWrapperPromised, + + /** + * Performs a read/write operation on the Places database through a Sqlite.sys.mjs + * wrapped connection to the Places database. + * + * This is intended to be used only by Places itself, always use APIs if you + * need to modify the Places database. Use promiseDBConnection if you need to + * SELECT from the database and there's no covering API. + * Keep in mind the Places DB schema is by no means frozen or even stable. + * Your custom queries can - and will - break overtime. + * + * As all operations on the Places database are asynchronous, if shutdown + * is initiated while an operation is pending, this could cause dataloss. + * Using `withConnectionWrapper` ensures that shutdown waits until all + * operations are complete before proceeding. + * + * Example: + * await withConnectionWrapper("Bookmarks: Remove a bookmark", Task.async(function*(db) { + * // Proceed with the db, asynchronously. + * // Shutdown will not interrupt operations that take place here. + * })); + * + * @param {string} name The name of the operation. Used for debugging, logging + * and crash reporting. + * @param {function(db)} task A function that takes as argument a Sqlite.sys.mjs + * connection and returns a Promise. Shutdown is guaranteed to not interrupt + * execution of `task`. + */ + async withConnectionWrapper(name, task) { + if (!name) { + throw new TypeError("Expecting a user-readable name"); + } + let db = await lazy.gAsyncDBWrapperPromised; + return db.executeBeforeShutdown(name, task); + }, + + /** + * Gets favicon data for a given page url. + * + * @param {string | URL | nsIURI} aPageUrl + * url of the page to look favicon for. + * @param {number} preferredWidth + * The preferred width of the favicon in pixels. The default value of 0 + * returns the largest icon available. + * @resolves to an object representing a favicon entry, having the following + * properties: { uri, dataLen, data, mimeType } + * @rejects JavaScript exception if the given url has no associated favicon. + */ + promiseFaviconData(aPageUrl, preferredWidth = 0) { + return new Promise((resolve, reject) => { + if (!(aPageUrl instanceof Ci.nsIURI)) { + aPageUrl = PlacesUtils.toURI(aPageUrl); + } + PlacesUtils.favicons.getFaviconDataForPage( + aPageUrl, + function (uri, dataLen, data, mimeType, size) { + if (uri) { + resolve({ uri, dataLen, data, mimeType, size }); + } else { + reject(); + } + }, + preferredWidth + ); + }); + }, + + /** + * Returns the passed URL with a #size ref for the specified size and + * devicePixelRatio. + * + * @param window + * The window where the icon will appear. + * @param href + * The string href we should add the ref to. + * @param size + * The target image size + * @return The URL with the fragment at the end, in the same formar as input. + */ + urlWithSizeRef(window, href, size) { + return ( + href + + (href.includes("#") ? "&" : "#") + + "size=" + + Math.round(size) * window.devicePixelRatio + ); + }, + + /** + * Get the unique id for an item (a bookmark, a folder or a separator) given + * its item id. + * + * @param aItemId + * an item id + * @return {Promise} + * @resolves to the GUID. + * @rejects if aItemId is invalid. + */ + promiseItemGuid(aItemId) { + return GuidHelper.getItemGuid(aItemId); + }, + + /** + * Get the item id for an item (a bookmark, a folder or a separator) given + * its unique id. + * + * @param aGuid + * an item GUID + * @return {Promise} + * @resolves to the item id. + * @rejects if there's no item for the given GUID. + */ + promiseItemId(aGuid) { + return GuidHelper.getItemId(aGuid); + }, + + /** + * Get the item ids for multiple items (a bookmark, a folder or a separator) + * given the unique ids for each item. + * + * @param {Array} aGuids An array of item GUIDs. + * @return {Promise} + * @resolves to a Map of item ids. + * @rejects if not all of the GUIDs could be found. + */ + promiseManyItemIds(aGuids) { + return GuidHelper.getManyItemIds(aGuids); + }, + + /** + * Invalidate the GUID cache for the given itemId. + * + * @param aItemId + * an item id + */ + invalidateCachedGuidFor(aItemId) { + GuidHelper.invalidateCacheForItemId(aItemId); + }, + + /** + * Invalidates the entire GUID cache. + */ + invalidateCachedGuids() { + GuidHelper.invalidateCache(); + }, + + /** + * Asynchronously retrieve a JS-object representation of a places bookmarks + * item (a bookmark, a folder, or a separator) along with all of its + * descendants. + * + * @param [optional] aItemGuid + * the (topmost) item to be queried. If it's not passed, the places + * root is queried: that is, you get a representation of the entire + * bookmarks hierarchy. + * @param [optional] aOptions + * Options for customizing the query behavior, in the form of a JS + * object with any of the following properties: + * - excludeItemsCallback: a function for excluding items, along with + * their descendants. Given an item object (that has everything set + * apart its potential children data), it should return true if the + * item should be excluded. Once an item is excluded, the function + * isn't called for any of its descendants. This isn't called for + * the root item. + * WARNING: since the function may be called for each item, using + * this option can slow down the process significantly if the + * callback does anything that's not relatively trivial. It is + * highly recommended to avoid any synchronous I/O or DB queries. + * - includeItemIds: opt-in to include the deprecated id property. + * Use it if you must. It'll be removed once the switch to GUIDs is + * complete. + * + * @return {Promise} + * @resolves to a JS object that represents either a single item or a + * bookmarks tree. Each node in the tree has the following properties set: + * - guid (string): the item's GUID (same as aItemGuid for the top item). + * - [deprecated] id (number): the item's id. This is only if + * aOptions.includeItemIds is set. + * - type (string): the item's type. @see PlacesUtils.TYPE_X_* + * - typeCode (number): the item's type in numeric format. + * @see PlacesUtils.bookmarks.TYPE_* + * - title (string): the item's title. If it has no title, this property + * isn't set. + * - dateAdded (number, microseconds from the epoch): the date-added value of + * the item. + * - lastModified (number, microseconds from the epoch): the last-modified + * value of the item. + * - index: the item's index under it's parent. + * + * The root object (i.e. the one for aItemGuid) also has the following + * properties set: + * - parentGuid (string): the GUID of the root's parent. This isn't set if + * the root item is the places root. + * - itemsCount (number, not enumerable): the number of items, including the + * root item itself, which are represented in the resolved object. + * + * Bookmark items also have the following properties: + * - uri (string): the item's url. + * - tags (string): csv string of the bookmark's tags. + * - charset (string): the last known charset of the bookmark. + * - keyword (string): the bookmark's keyword (unset if none). + * - postData (string): the bookmark's keyword postData (unset if none). + * - iconUri (string): the bookmark's favicon url. + * The last four properties are not set at all if they're irrelevant (e.g. + * |charset| is not set if no charset was previously set for the bookmark + * url). + * + * Folders may also have the following properties: + * - children (array): the folder's children information, each of them + * having the same set of properties as above. + * + * @rejects if the query failed for any reason. + * @note if aItemGuid points to a non-existent item, the returned promise is + * resolved to null. + */ + async promiseBookmarksTree(aItemGuid = "", aOptions = {}) { + let createItemInfoObject = async function (aRow, aIncludeParentGuid) { + let item = {}; + let copyProps = (...props) => { + for (let prop of props) { + let val = aRow.getResultByName(prop); + if (val !== null) { + item[prop] = val; + } + } + }; + copyProps("guid", "title", "index", "dateAdded", "lastModified"); + if (aIncludeParentGuid) { + copyProps("parentGuid"); + } + + let itemId = aRow.getResultByName("id"); + if (aOptions.includeItemIds) { + item.id = itemId; + } + + // Cache it for promiseItemId consumers regardless. + GuidHelper.updateCache(itemId, item.guid); + + let type = aRow.getResultByName("type"); + item.typeCode = type; + if (type == Ci.nsINavBookmarksService.TYPE_BOOKMARK) { + copyProps("charset", "tags", "iconUri"); + } + + switch (type) { + case PlacesUtils.bookmarks.TYPE_BOOKMARK: + item.type = PlacesUtils.TYPE_X_MOZ_PLACE; + // If this throws due to an invalid url, the item will be skipped. + try { + item.uri = new URL(aRow.getResultByName("url")).href; + } catch (ex) { + let error = new Error("Invalid bookmark URL"); + error.becauseInvalidURL = true; + throw error; + } + // Keywords are cached, so this should be decently fast. + let entry = await PlacesUtils.keywords.fetch({ url: item.uri }); + if (entry) { + item.keyword = entry.keyword; + item.postData = entry.postData; + } + break; + case PlacesUtils.bookmarks.TYPE_FOLDER: + item.type = PlacesUtils.TYPE_X_MOZ_PLACE_CONTAINER; + // Mark root folders. + if (item.guid == PlacesUtils.bookmarks.rootGuid) { + item.root = "placesRoot"; + } else if (item.guid == PlacesUtils.bookmarks.menuGuid) { + item.root = "bookmarksMenuFolder"; + } else if (item.guid == PlacesUtils.bookmarks.unfiledGuid) { + item.root = "unfiledBookmarksFolder"; + } else if (item.guid == PlacesUtils.bookmarks.toolbarGuid) { + item.root = "toolbarFolder"; + } else if (item.guid == PlacesUtils.bookmarks.mobileGuid) { + item.root = "mobileFolder"; + } + break; + case PlacesUtils.bookmarks.TYPE_SEPARATOR: + item.type = PlacesUtils.TYPE_X_MOZ_PLACE_SEPARATOR; + break; + default: + console.error(`Unexpected bookmark type ${type}`); + break; + } + return item; + }; + + const QUERY_STR = `/* do not warn (bug no): cannot use an index */ + WITH RECURSIVE + descendants(fk, level, type, id, guid, parent, parentGuid, position, + title, dateAdded, lastModified) AS ( + SELECT b1.fk, 0, b1.type, b1.id, b1.guid, b1.parent, + (SELECT guid FROM moz_bookmarks WHERE id = b1.parent), + b1.position, b1.title, b1.dateAdded, b1.lastModified + FROM moz_bookmarks b1 WHERE b1.guid=:item_guid + UNION ALL + SELECT b2.fk, level + 1, b2.type, b2.id, b2.guid, b2.parent, + descendants.guid, b2.position, b2.title, b2.dateAdded, + b2.lastModified + FROM moz_bookmarks b2 + JOIN descendants ON b2.parent = descendants.id AND b2.id <> :tags_folder) + SELECT d.level, d.id, d.guid, d.parent, d.parentGuid, d.type, + d.position AS [index], IFNULL(d.title, '') AS title, d.dateAdded, + d.lastModified, h.url, (SELECT icon_url FROM moz_icons i + JOIN moz_icons_to_pages ON icon_id = i.id + JOIN moz_pages_w_icons pi ON page_id = pi.id + WHERE pi.page_url_hash = hash(h.url) AND pi.page_url = h.url + ORDER BY width DESC LIMIT 1) AS iconUri, + (SELECT GROUP_CONCAT(t.title, ',') + FROM moz_bookmarks b2 + JOIN moz_bookmarks t ON t.id = +b2.parent AND t.parent = :tags_folder + WHERE b2.fk = h.id + ) AS tags, + (SELECT a.content FROM moz_annos a + JOIN moz_anno_attributes n ON a.anno_attribute_id = n.id + WHERE place_id = h.id AND n.name = :charset_anno + ) AS charset + FROM descendants d + LEFT JOIN moz_bookmarks b3 ON b3.id = d.parent + LEFT JOIN moz_places h ON h.id = d.fk + ORDER BY d.level, d.parent, d.position`; + + if (!aItemGuid) { + aItemGuid = this.bookmarks.rootGuid; + } + + let hasExcludeItemsCallback = aOptions.hasOwnProperty( + "excludeItemsCallback" + ); + let excludedParents = new Set(); + let shouldExcludeItem = (aItem, aParentGuid) => { + let exclude = + excludedParents.has(aParentGuid) || + aOptions.excludeItemsCallback(aItem); + if (exclude) { + if (aItem.type == this.TYPE_X_MOZ_PLACE_CONTAINER) { + excludedParents.add(aItem.guid); + } + } + return exclude; + }; + + let rootItem = null; + let parentsMap = new Map(); + let conn = await this.promiseDBConnection(); + let rows = await conn.executeCached(QUERY_STR, { + tags_folder: PlacesUtils.tagsFolderId, + charset_anno: PlacesUtils.CHARSET_ANNO, + item_guid: aItemGuid, + }); + let yieldCounter = 0; + for (let row of rows) { + let item; + if (!rootItem) { + try { + // This is the first row. + rootItem = item = await createItemInfoObject(row, true); + Object.defineProperty(rootItem, "itemsCount", { + value: 1, + writable: true, + enumerable: false, + configurable: false, + }); + } catch (ex) { + console.error("Failed to fetch the data for the root item"); + throw ex; + } + } else { + try { + // Our query guarantees that we always visit parents ahead of their + // children. + item = await createItemInfoObject(row, false); + let parentGuid = row.getResultByName("parentGuid"); + if (hasExcludeItemsCallback && shouldExcludeItem(item, parentGuid)) { + continue; + } + + let parentItem = parentsMap.get(parentGuid); + if ("children" in parentItem) { + parentItem.children.push(item); + } else { + parentItem.children = [item]; + } + + rootItem.itemsCount++; + } catch (ex) { + // This is a bogus child, report and skip it. + console.error("Failed to fetch the data for an item " + ex); + continue; + } + } + + if (item.type == this.TYPE_X_MOZ_PLACE_CONTAINER) { + parentsMap.set(item.guid, item); + } + + // With many bookmarks we end up stealing the CPU - even with yielding! + // So we let everyone else have a go every few items (bug 1186714). + if (++yieldCounter % 50 == 0) { + await new Promise(resolve => { + Services.tm.dispatchToMainThread(resolve); + }); + } + } + + return rootItem; + }, + + /** + * Returns a generator that iterates over `array` and yields slices of no + * more than `chunkLength` elements at a time. + * + * @param {Array} array An array containing zero or more elements. + * @param {number} chunkLength The maximum number of elements in each chunk. + * @yields {Array} A chunk of the array. + * @throws if `chunkLength` is negative or not an integer. + */ + *chunkArray(array, chunkLength) { + if (chunkLength <= 0 || !Number.isInteger(chunkLength)) { + throw new TypeError("Chunk length must be a positive integer"); + } + if (!array.length) { + return; + } + if (array.length <= chunkLength) { + yield array; + return; + } + let startIndex = 0; + while (startIndex < array.length) { + yield array.slice(startIndex, (startIndex += chunkLength)); + } + }, + + /** + * Returns SQL placeholders to bind multiple values into an IN clause. + * @param {Array|number} info + * Array or number of entries to create. + * @param {string} [prefix] + * String prefix to add before the SQL param. + * @param {string} [suffix] + * String suffix to add after the SQL param. + */ + sqlBindPlaceholders(info, prefix = "", suffix = "") { + let length = Array.isArray(info) ? info.length : info; + return new Array(length).fill(prefix + "?" + suffix).join(","); + }, + + /** + * Run some text through md5 and return the hash. + * @param {string} data The string to hash. + * @param {string} [format] Which format of the hash to return: + * - "ascii" for ascii format. + * - "hex" for hex format. + * @returns {string} md5 hash of the input string in the required format. + */ + md5(data, { format = "ascii" } = {}) { + lazy.gCryptoHash.init(lazy.gCryptoHash.MD5); + + // Convert the data to a byte array for hashing + lazy.gCryptoHash.update( + data.split("").map(c => c.charCodeAt(0)), + data.length + ); + switch (format) { + case "hex": + let hash = lazy.gCryptoHash.finish(false); + return Array.from(hash, (c, i) => + hash.charCodeAt(i).toString(16).padStart(2, "0") + ).join(""); + case "ascii": + default: + return lazy.gCryptoHash.finish(true); + } + }, + + /** + * Inserts a new place if one doesn't currently exist. + * + * This should only be used from an API that is connecting this new entry to + * some additional foreign table. Otherwise this will just create an orphan + * entry that could be expired at any time. + * + * @param db + * The database connection to use. + * @param url + * A valid URL object. + * @return {Promise} resolved when the operation is complete. + */ + async maybeInsertPlace(db, url) { + // The IGNORE conflict can trigger on `guid`. + await db.executeCached( + `INSERT OR IGNORE INTO moz_places (url, url_hash, rev_host, hidden, frecency, guid) + VALUES (:url, hash(:url), :rev_host, + (CASE WHEN :url BETWEEN 'place:' AND 'place:' || X'FFFF' THEN 1 ELSE 0 END), + :frecency, + IFNULL((SELECT guid FROM moz_places WHERE url_hash = hash(:url) AND url = :url), + GENERATE_GUID())) + `, + { + url: url.href, + rev_host: this.getReversedHost(url), + frecency: url.protocol == "place:" ? 0 : -1, + } + ); + await db.executeCached("DELETE FROM moz_updateoriginsinsert_temp"); + }, + + /** + * Tries to insert a set of new places if they don't exist yet. + * + * This should only be used from an API that is connecting this new entry to + * some additional foreign table. Otherwise this will just create an orphan + * entry that could be expired at any time. + * + * @param db + * The database to use + * @param urls + * An array with all the url objects to insert. + * @return {Promise} resolved when the operation is complete. + */ + async maybeInsertManyPlaces(db, urls) { + await db.executeCached( + `INSERT OR IGNORE INTO moz_places (url, url_hash, rev_host, hidden, frecency, guid) VALUES + (:url, hash(:url), :rev_host, + (CASE WHEN :url BETWEEN 'place:' AND 'place:' || X'FFFF' THEN 1 ELSE 0 END), + :frecency, + IFNULL((SELECT guid FROM moz_places WHERE url_hash = hash(:url) AND url = :url), :maybeguid))`, + urls.map(url => ({ + url: url.href, + rev_host: this.getReversedHost(url), + frecency: url.protocol == "place:" ? 0 : -1, + maybeguid: this.history.makeGuid(), + })) + ); + await db.executeCached("DELETE FROM moz_updateoriginsinsert_temp"); + }, + + /** + * Can be used to detect being in automation to allow specific code paths + * that are normally disallowed. + */ + get isInAutomation() { + return ( + Cu.isInAutomation || Services.env.exists("XPCSHELL_TEST_PROFILE_DIR") + ); + }, + + /** + * Creates a logger. + * Logging level can be controlled through places.loglevel. + * + * @param {string} [prefix] Prefix to use for the logged messages, "::" will + * be appended automatically to the prefix. + * @returns {object} The logger. + */ + getLogger({ prefix = "" } = {}) { + if (!this._logger) { + this._logger = lazy.Log.repository.getLogger("places"); + this._logger.manageLevelFromPref("places.loglevel"); + this._logger.addAppender( + new lazy.Log.ConsoleAppender(new lazy.Log.BasicFormatter()) + ); + } + if (prefix) { + // This is not an early return because it is necessary to invoke getLogger + // at least once before getLoggerWithMessagePrefix; it replaces a + // method of the original logger, rather than using an actual Proxy. + return lazy.Log.repository.getLoggerWithMessagePrefix( + "places", + prefix + " :: " + ); + } + return this._logger; + }, +}; + +XPCOMUtils.defineLazyGetter(PlacesUtils, "history", function () { + let hs = Cc["@mozilla.org/browser/nav-history-service;1"].getService( + Ci.nsINavHistoryService + ); + return Object.freeze( + new Proxy(hs, { + get(target, name) { + let property, object; + if (name in target) { + property = target[name]; + object = target; + } else { + property = lazy.History[name]; + object = lazy.History; + } + if (typeof property == "function") { + return property.bind(object); + } + return property; + }, + set(target, name, val) { + // Forward to the XPCOM object, otherwise don't allow to set properties. + if (name in target) { + target[name] = val; + return true; + } + // This will throw in strict mode. + return false; + }, + }) + ); +}); + +XPCOMUtils.defineLazyServiceGetter( + PlacesUtils, + "favicons", + "@mozilla.org/browser/favicon-service;1", + "nsIFaviconService" +); + +XPCOMUtils.defineLazyServiceGetter( + lazy, + "bmsvc", + "@mozilla.org/browser/nav-bookmarks-service;1", + "nsINavBookmarksService" +); +XPCOMUtils.defineLazyGetter(PlacesUtils, "bookmarks", () => { + return Object.freeze( + new Proxy(lazy.Bookmarks, { + get: (target, name) => + lazy.Bookmarks.hasOwnProperty(name) + ? lazy.Bookmarks[name] + : lazy.bmsvc[name], + }) + ); +}); + +XPCOMUtils.defineLazyServiceGetter( + PlacesUtils, + "tagging", + "@mozilla.org/browser/tagging-service;1", + "nsITaggingService" +); + +XPCOMUtils.defineLazyGetter(lazy, "bundle", function () { + const PLACES_STRING_BUNDLE_URI = "chrome://places/locale/places.properties"; + return Services.strings.createBundle(PLACES_STRING_BUNDLE_URI); +}); + +// This is just used as a reasonably-random value for copy & paste / drag operations. +XPCOMUtils.defineLazyGetter(PlacesUtils, "instanceId", () => { + return PlacesUtils.history.makeGuid(); +}); + +/** + * Setup internal databases for closing properly during shutdown. + * + * 1. Places initiates shutdown. + * 2. Before places can move to the step where it closes the low-level connection, + * we need to make sure that we have closed `conn`. + * 3. Before we can close `conn`, we need to make sure that all external clients + * have stopped using `conn`. + * 4. Before we can close Sqlite, we need to close `conn`. + */ +function setupDbForShutdown(conn, name) { + try { + let state = "0. Not started."; + let promiseClosed = new Promise((resolve, reject) => { + // The service initiates shutdown. + // Before it can safely close its connection, we need to make sure + // that we have closed the high-level connection. + try { + PlacesUtils.history.connectionShutdownClient.jsclient.addBlocker( + `${name} closing as part of Places shutdown`, + async function () { + state = "1. Service has initiated shutdown"; + + // At this stage, all external clients have finished using the + // database. We just need to close the high-level connection. + try { + await conn.close(); + state = "2. Closed Sqlite.sys.mjs connection."; + resolve(); + } catch (ex) { + state = "2. Failed to closed Sqlite.sys.mjs connection: " + ex; + reject(ex); + } + }, + () => state + ); + } catch (ex) { + // It's too late to block shutdown, just close the connection. + conn.close(); + reject(ex); + } + }).catch(console.error); + + // Make sure that Sqlite.sys.mjs doesn't close until we are done + // with the high-level connection. + lazy.Sqlite.shutdown.addBlocker( + `${name} must be closed before Sqlite.sys.mjs`, + () => promiseClosed, + () => state + ); + } catch (ex) { + // It's too late to block shutdown, just close the connection. + conn.close(); + throw ex; + } +} + +XPCOMUtils.defineLazyGetter(lazy, "gAsyncDBConnPromised", () => + lazy.Sqlite.cloneStorageConnection({ + connection: PlacesUtils.history.DBConnection, + readOnly: true, + }) + .then(conn => { + setupDbForShutdown(conn, "PlacesUtils read-only connection"); + return conn; + }) + .catch(console.error) +); + +XPCOMUtils.defineLazyGetter(lazy, "gAsyncDBWrapperPromised", () => + lazy.Sqlite.wrapStorageConnection({ + connection: PlacesUtils.history.DBConnection, + }) + .then(conn => { + setupDbForShutdown(conn, "PlacesUtils wrapped connection"); + return conn; + }) + .catch(console.error) +); + +var gAsyncDBLargeCacheConnDeferred = PromiseUtils.defer(); +XPCOMUtils.defineLazyGetter(lazy, "gAsyncDBLargeCacheConnPromised", () => + lazy.Sqlite.cloneStorageConnection({ + connection: PlacesUtils.history.DBConnection, + readOnly: true, + }) + .then(async conn => { + setupDbForShutdown(conn, "PlacesUtils large cache read-only connection"); + // Components like the urlbar often fallback to a table scan due to lack + // of full text indices. A larger cache helps reducing IO and improves + // performance. This value is expected to be larger than the default + // mozStorage value defined as MAX_CACHE_SIZE_BYTES in + // storage/mozStorageConnection.cpp. + await conn.execute("PRAGMA cache_size = -6144"); // 6MiB + // These should be kept in sync with nsPlacesTables.h. + await conn.execute(` + CREATE TEMP TABLE IF NOT EXISTS moz_openpages_temp ( + url TEXT, + userContextId INTEGER, + open_count INTEGER, + PRIMARY KEY (url, userContextId) + )`); + await conn.execute(` + CREATE TEMP TRIGGER IF NOT EXISTS moz_openpages_temp_afterupdate_trigger + AFTER UPDATE OF open_count ON moz_openpages_temp FOR EACH ROW + WHEN NEW.open_count = 0 + BEGIN + DELETE FROM moz_openpages_temp + WHERE url = NEW.url + AND userContextId = NEW.userContextId; + END`); + gAsyncDBLargeCacheConnDeferred.resolve(conn); + return conn; + }) + .catch(console.error) +); + +/** + * The metadata API allows consumers to store simple key-value metadata in + * Places. Keys are strings, values can be any type that SQLite supports: + * numbers (integers and doubles), Booleans, strings, and blobs. Values are + * cached in memory for faster lookups. + * + * Since some consumers set metadata as part of an existing operation or active + * transaction, the API also exposes a `*withConnection` variant for each + * method that takes an open database connection. + */ +PlacesUtils.metadata = { + cache: new Map(), + jsonPrefix: "data:application/json;base64,", + + /** + * Returns the value associated with a metadata key. + * + * @param {String} key + * The metadata key to look up. + * @param {String|Object|Array} defaultValue + * Optional. The default value to return if the value is not present, + * or cannot be parsed. + * @resolves {*} + * The value associated with the key, or the defaultValue if there is one. + * @rejects + * Rejected if the value is not found or it cannot be parsed + * and there is no defaultValue. + */ + get(key, defaultValue) { + return PlacesUtils.withConnectionWrapper("PlacesUtils.metadata.get", db => + this.getWithConnection(db, key, defaultValue) + ); + }, + + /** + * Sets the value for a metadata key. + * + * @param {String} key + * The metadata key to update. + * @param {*} + * The value to associate with the key. + */ + set(key, value) { + return PlacesUtils.withConnectionWrapper("PlacesUtils.metadata.set", db => + this.setWithConnection(db, key, value) + ); + }, + + /** + * Removes the values for the given metadata keys. + * + * @param {String...} + * One or more metadata keys to remove. + */ + delete(...keys) { + return PlacesUtils.withConnectionWrapper( + "PlacesUtils.metadata.delete", + db => this.deleteWithConnection(db, ...keys) + ); + }, + + async getWithConnection(db, key, defaultValue) { + key = this.canonicalizeKey(key); + if (this.cache.has(key)) { + return this.cache.get(key); + } + let rows = await db.executeCached( + ` + SELECT value FROM moz_meta WHERE key = :key`, + { key } + ); + let value = null; + if (rows.length) { + let row = rows[0]; + let rawValue = row.getResultByName("value"); + // Convert blobs back to `Uint8Array`s. + if (row.getTypeOfIndex(0) == row.VALUE_TYPE_BLOB) { + value = new Uint8Array(rawValue); + } else if ( + typeof rawValue == "string" && + rawValue.startsWith(this.jsonPrefix) + ) { + try { + value = JSON.parse( + this._base64Decode(rawValue.substr(this.jsonPrefix.length)) + ); + } catch (ex) { + if (defaultValue !== undefined) { + // We must create a new array in the local scope to avoid a memory + // leak due to the array global object. + value = Cu.cloneInto(defaultValue, {}); + } else { + throw ex; + } + } + } else { + value = rawValue; + } + } else if (defaultValue !== undefined) { + // We must create a new array in the local scope to avoid a memory leak due + // to the array global object. + value = Cu.cloneInto(defaultValue, {}); + } else { + throw new Error(`No data stored for key ${key}`); + } + this.cache.set(key, value); + return value; + }, + + async setWithConnection(db, key, value) { + if (value === null) { + await this.deleteWithConnection(db, key); + return; + } + + let cacheValue = value; + if ( + typeof value == "object" && + ChromeUtils.getClassName(value) != "Uint8Array" + ) { + value = this.jsonPrefix + this._base64Encode(JSON.stringify(value)); + } + + key = this.canonicalizeKey(key); + await db.executeCached( + ` + REPLACE INTO moz_meta (key, value) + VALUES (:key, :value)`, + { key, value } + ); + this.cache.set(key, cacheValue); + }, + + async deleteWithConnection(db, ...keys) { + keys = keys.map(this.canonicalizeKey); + if (!keys.length) { + return; + } + await db.execute( + ` + DELETE FROM moz_meta + WHERE key IN (${new Array(keys.length).fill("?").join(",")})`, + keys + ); + for (let key of keys) { + this.cache.delete(key); + } + }, + + canonicalizeKey(key) { + if (typeof key != "string" || !/^[a-zA-Z0-9\/_]+$/.test(key)) { + throw new TypeError("Invalid metadata key: " + key); + } + return key.toLowerCase(); + }, + + _base64Encode(str) { + return ChromeUtils.base64URLEncode(new TextEncoder().encode(str), { + pad: true, + }); + }, + + _base64Decode(str) { + return new TextDecoder("utf-8").decode( + ChromeUtils.base64URLDecode(str, { padding: "require" }) + ); + }, +}; + +/** + * Keywords management API. + * Sooner or later these keywords will merge with search aliases, this is an + * interim API that should then be replaced by a unified one. + * Keywords are associated with URLs and can have POST data. + * The relations between URLs and keywords are the following: + * - 1 keyword can only point to 1 URL + * - 1 URL can have multiple keywords, iff they differ by POST data (included the empty one). + */ +PlacesUtils.keywords = { + /** + * Fetches a keyword entry based on keyword or URL. + * + * @param keywordOrEntry + * Either the keyword to fetch or an entry providing keyword + * or url property to find keywords for. If both properties are set, + * this returns their intersection. + * @param onResult [optional] + * Callback invoked for each found entry. + * @return {Promise} + * @resolves to an object in the form: { keyword, url, postData }, + * or null if a keyword entry was not found. + */ + fetch(keywordOrEntry, onResult = null) { + if (typeof keywordOrEntry == "string") { + keywordOrEntry = { keyword: keywordOrEntry }; + } + + if ( + keywordOrEntry === null || + typeof keywordOrEntry != "object" || + ("keyword" in keywordOrEntry && typeof keywordOrEntry.keyword != "string") + ) { + throw new Error("Invalid keyword"); + } + + let hasKeyword = "keyword" in keywordOrEntry; + let hasUrl = "url" in keywordOrEntry; + + if (!hasKeyword && !hasUrl) { + throw new Error("At least keyword or url must be provided"); + } + if (onResult && typeof onResult != "function") { + throw new Error("onResult callback must be a valid function"); + } + + if (hasUrl) { + try { + keywordOrEntry.url = BOOKMARK_VALIDATORS.url(keywordOrEntry.url); + } catch (ex) { + throw new Error(keywordOrEntry.url + " is not a valid URL"); + } + } + if (hasKeyword) { + keywordOrEntry.keyword = keywordOrEntry.keyword.trim().toLowerCase(); + } + + let safeOnResult = entry => { + if (onResult) { + try { + onResult(entry); + } catch (ex) { + console.error(ex); + } + } + }; + + return promiseKeywordsCache().then(cache => { + let entries = []; + if (hasKeyword) { + let entry = cache.get(keywordOrEntry.keyword); + if (entry) { + entries.push(entry); + } + } + if (hasUrl) { + for (let entry of cache.values()) { + if (entry.url.href == keywordOrEntry.url.href) { + entries.push(entry); + } + } + } + + entries = entries.filter(e => { + return ( + (!hasUrl || e.url.href == keywordOrEntry.url.href) && + (!hasKeyword || e.keyword == keywordOrEntry.keyword) + ); + }); + + entries.forEach(safeOnResult); + return entries.length ? entries[0] : null; + }); + }, + + /** + * Adds a new keyword and postData for the given URL. + * + * @param keywordEntry + * An object describing the keyword to insert, in the form: + * { + * keyword: non-empty string, + * url: URL or href to associate to the keyword, + * postData: optional POST data to associate to the keyword + * source: The change source, forwarded to all bookmark observers. + * Defaults to nsINavBookmarksService::SOURCE_DEFAULT. + * } + * @note Do not define a postData property if there isn't any POST data. + * Defining an empty string for POST data is equivalent to not having it. + * @resolves when the addition is complete. + */ + insert(keywordEntry) { + if (!keywordEntry || typeof keywordEntry != "object") { + throw new Error("Input should be a valid object"); + } + + if ( + !("keyword" in keywordEntry) || + !keywordEntry.keyword || + typeof keywordEntry.keyword != "string" + ) { + throw new Error("Invalid keyword"); + } + if ( + "postData" in keywordEntry && + keywordEntry.postData && + typeof keywordEntry.postData != "string" + ) { + throw new Error("Invalid POST data"); + } + if (!("url" in keywordEntry)) { + throw new Error("undefined is not a valid URL"); + } + + if (!("source" in keywordEntry)) { + keywordEntry.source = PlacesUtils.bookmarks.SOURCES.DEFAULT; + } + let { keyword, url, source } = keywordEntry; + keyword = keyword.trim().toLowerCase(); + let postData = keywordEntry.postData || ""; + // This also checks href for validity + try { + url = BOOKMARK_VALIDATORS.url(url); + } catch (ex) { + throw new Error(url + " is not a valid URL"); + } + + return PlacesUtils.withConnectionWrapper( + "PlacesUtils.keywords.insert", + async db => { + let cache = await promiseKeywordsCache(); + + // Trying to set the same keyword is a no-op. + let oldEntry = cache.get(keyword); + if ( + oldEntry && + oldEntry.url.href == url.href && + (oldEntry.postData || "") == postData + ) { + return; + } + + // A keyword can only be associated to a single page. + // If another page is using the new keyword, we must update the keyword + // entry. + // Note we cannot use INSERT OR REPLACE cause it wouldn't invoke the delete + // trigger. + if (oldEntry) { + await db.executeCached( + `UPDATE moz_keywords + SET place_id = (SELECT id FROM moz_places WHERE url_hash = hash(:url) AND url = :url), + post_data = :post_data + WHERE keyword = :keyword + `, + { url: url.href, keyword, post_data: postData } + ); + await notifyKeywordChange(oldEntry.url.href, "", source); + } else { + // An entry for the given page could be missing, in such a case we need to + // create it. The IGNORE conflict can trigger on `guid`. + await db.executeTransaction(async () => { + await PlacesUtils.maybeInsertPlace(db, url); + + // A new keyword could be assigned to an url that already has one, + // then we must replace the old keyword with the new one. + let oldKeywords = []; + for (let entry of cache.values()) { + if ( + entry.url.href == url.href && + (entry.postData || "") == postData + ) { + oldKeywords.push(entry.keyword); + } + } + if (oldKeywords.length) { + for (let oldKeyword of oldKeywords) { + await db.executeCached( + `DELETE FROM moz_keywords WHERE keyword = :oldKeyword`, + { oldKeyword } + ); + cache.delete(oldKeyword); + } + } + + await db.executeCached( + `INSERT INTO moz_keywords (keyword, place_id, post_data) + VALUES (:keyword, (SELECT id FROM moz_places WHERE url_hash = hash(:url) AND url = :url), :post_data) + `, + { url: url.href, keyword, post_data: postData } + ); + + await lazy.PlacesSyncUtils.bookmarks.addSyncChangesForBookmarksWithURL( + db, + url, + lazy.PlacesSyncUtils.bookmarks.determineSyncChangeDelta(source) + ); + }); + } + + cache.set(keyword, { keyword, url, postData: postData || null }); + + // In any case, notify about the new keyword. + await notifyKeywordChange(url.href, keyword, source); + } + ); + }, + + /** + * Removes a keyword. + * + * @param keyword + * The keyword to remove. + * @return {Promise} + * @resolves when the removal is complete. + */ + remove(keywordOrEntry) { + if (typeof keywordOrEntry == "string") { + keywordOrEntry = { + keyword: keywordOrEntry, + source: Ci.nsINavBookmarksService.SOURCE_DEFAULT, + }; + } + + if ( + keywordOrEntry === null || + typeof keywordOrEntry != "object" || + !keywordOrEntry.keyword || + typeof keywordOrEntry.keyword != "string" + ) { + throw new Error("Invalid keyword"); + } + + let { keyword, source = Ci.nsINavBookmarksService.SOURCE_DEFAULT } = + keywordOrEntry; + keyword = keywordOrEntry.keyword.trim().toLowerCase(); + return PlacesUtils.withConnectionWrapper( + "PlacesUtils.keywords.remove", + async db => { + let cache = await promiseKeywordsCache(); + if (!cache.has(keyword)) { + return; + } + let { url } = cache.get(keyword); + cache.delete(keyword); + + await db.executeTransaction(async function () { + await db.execute( + `DELETE FROM moz_keywords WHERE keyword = :keyword`, + { keyword } + ); + + await lazy.PlacesSyncUtils.bookmarks.addSyncChangesForBookmarksWithURL( + db, + url, + lazy.PlacesSyncUtils.bookmarks.determineSyncChangeDelta(source) + ); + }); + + // Notify bookmarks about the removal. + await notifyKeywordChange(url.href, "", source); + } + ); + }, + + /** + * Moves all (keyword, POST data) pairs from one URL to another, and fires + * observer notifications for all affected bookmarks. If the destination URL + * already has keywords, they will be removed and replaced with the source + * URL's keywords. + * + * @param oldURL + * The source URL. + * @param newURL + * The destination URL. + * @param source + * The change source, forwarded to all bookmark observers. + * @return {Promise} + * @resolves when all keywords have been moved to the destination URL. + */ + reassign(oldURL, newURL, source = PlacesUtils.bookmarks.SOURCES.DEFAULT) { + try { + oldURL = BOOKMARK_VALIDATORS.url(oldURL); + } catch (ex) { + throw new Error(oldURL + " is not a valid source URL"); + } + try { + newURL = BOOKMARK_VALIDATORS.url(newURL); + } catch (ex) { + throw new Error(oldURL + " is not a valid destination URL"); + } + return PlacesUtils.withConnectionWrapper( + "PlacesUtils.keywords.reassign", + async function (db) { + let keywordsToReassign = []; + let keywordsToRemove = []; + let cache = await promiseKeywordsCache(); + for (let [keyword, entry] of cache) { + if (entry.url.href == oldURL.href) { + keywordsToReassign.push(keyword); + } + if (entry.url.href == newURL.href) { + keywordsToRemove.push(keyword); + } + } + if (!keywordsToReassign.length) { + return; + } + + await db.executeTransaction(async function () { + // Remove existing keywords from the new URL. + await db.executeCached( + `DELETE FROM moz_keywords WHERE keyword = :keyword`, + keywordsToRemove.map(keyword => ({ keyword })) + ); + + // Move keywords from the old URL to the new URL. + await db.executeCached( + ` + UPDATE moz_keywords SET + place_id = (SELECT id FROM moz_places + WHERE url_hash = hash(:newURL) AND + url = :newURL) + WHERE place_id = (SELECT id FROM moz_places + WHERE url_hash = hash(:oldURL) AND + url = :oldURL)`, + { newURL: newURL.href, oldURL: oldURL.href } + ); + }); + for (let keyword of keywordsToReassign) { + let entry = cache.get(keyword); + entry.url = newURL; + } + for (let keyword of keywordsToRemove) { + cache.delete(keyword); + } + + if (keywordsToReassign.length) { + // If we moved any keywords, notify that we removed all keywords from + // the old and new URLs, then notify for each moved keyword. + await notifyKeywordChange(oldURL, "", source); + await notifyKeywordChange(newURL, "", source); + for (let keyword of keywordsToReassign) { + await notifyKeywordChange(newURL, keyword, source); + } + } else if (keywordsToRemove.length) { + // If the old URL didn't have any keywords, but the new URL did, just + // notify that we removed all keywords from the new URL. + await notifyKeywordChange(oldURL, "", source); + } + } + ); + }, + + /** + * Removes all orphaned keywords from the given URLs. Orphaned keywords are + * associated with URLs that are no longer bookmarked. If a given URL is still + * bookmarked, its keywords will not be removed. + * + * @param urls + * A list of URLs to check for orphaned keywords. + * @return {Promise} + * @resolves when all keywords have been removed from URLs that are no longer + * bookmarked. + */ + removeFromURLsIfNotBookmarked(urls) { + let hrefs = new Set(); + for (let url of urls) { + try { + url = BOOKMARK_VALIDATORS.url(url); + } catch (ex) { + throw new Error(url + " is not a valid URL"); + } + hrefs.add(url.href); + } + return PlacesUtils.withConnectionWrapper( + "PlacesUtils.keywords.removeFromURLsIfNotBookmarked", + async function (db) { + let keywordsByHref = new Map(); + let cache = await promiseKeywordsCache(); + for (let [keyword, entry] of cache) { + let href = entry.url.href; + if (!hrefs.has(href)) { + continue; + } + if (!keywordsByHref.has(href)) { + keywordsByHref.set(href, [keyword]); + continue; + } + let existingKeywords = keywordsByHref.get(href); + existingKeywords.push(keyword); + } + if (!keywordsByHref.size) { + return; + } + + let placeInfosToRemove = []; + let rows = await db.execute( + ` + SELECT h.id, h.url + FROM moz_places h + JOIN moz_keywords k ON k.place_id = h.id + GROUP BY h.id + HAVING h.foreign_count = count(*) + + (SELECT count(*) + FROM moz_bookmarks b + JOIN moz_bookmarks p ON b.parent = p.id + WHERE p.parent = :tags_root AND b.fk = h.id) + `, + { tags_root: PlacesUtils.tagsFolderId } + ); + for (let row of rows) { + placeInfosToRemove.push({ + placeId: row.getResultByName("id"), + href: row.getResultByName("url"), + }); + } + if (!placeInfosToRemove.length) { + return; + } + + await db.execute( + `DELETE FROM moz_keywords WHERE place_id IN (${Array.from( + placeInfosToRemove.map(info => info.placeId) + ).join()})` + ); + for (let { href } of placeInfosToRemove) { + let keywords = keywordsByHref.get(href); + for (let keyword of keywords) { + cache.delete(keyword); + } + } + } + ); + }, + + /** + * Removes all keywords from all URLs. + * + * @return {Promise} + * @resolves when all keywords have been removed. + */ + eraseEverything() { + return PlacesUtils.withConnectionWrapper( + "PlacesUtils.keywords.eraseEverything", + async function (db) { + let cache = await promiseKeywordsCache(); + if (!cache.size) { + return; + } + await db.executeCached(`DELETE FROM moz_keywords`); + cache.clear(); + } + ); + }, + + /** + * Invalidates the keywords cache, leaving all existing keywords in place. + * The cache will be repopulated on the next `PlacesUtils.keywords.*` call. + * + * @return {Promise} + * @resolves when the cache has been cleared. + */ + invalidateCachedKeywords() { + gKeywordsCachePromise = gKeywordsCachePromise.then(_ => null); + return gKeywordsCachePromise; + }, +}; + +var gKeywordsCachePromise = Promise.resolve(); + +function promiseKeywordsCache() { + let promise = gKeywordsCachePromise.then(function (cache) { + if (cache) { + return cache; + } + return PlacesUtils.withConnectionWrapper( + "PlacesUtils: promiseKeywordsCache", + async db => { + let cache = new Map(); + let rows = await db.execute( + `SELECT keyword, url, post_data + FROM moz_keywords k + JOIN moz_places h ON h.id = k.place_id + ` + ); + let brokenKeywords = []; + for (let row of rows) { + let keyword = row.getResultByName("keyword"); + try { + let entry = { + keyword, + url: new URL(row.getResultByName("url")), + postData: row.getResultByName("post_data") || null, + }; + cache.set(keyword, entry); + } catch (ex) { + // The url is invalid, don't load the keyword and remove it, or it + // would break the whole keywords API. + brokenKeywords.push(keyword); + } + } + if (brokenKeywords.length) { + await db.execute( + `DELETE FROM moz_keywords + WHERE keyword IN (${brokenKeywords.map(JSON.stringify).join(",")}) + ` + ); + } + return cache; + } + ); + }); + gKeywordsCachePromise = promise.catch(_ => {}); + return promise; +} + +// Sometime soon, likely as part of the transition to mozIAsyncBookmarks, +// itemIds will be deprecated in favour of GUIDs, which play much better +// with multiple undo/redo operations. Because these GUIDs are already stored, +// and because we don't want to revise the transactions API once more when this +// happens, transactions are set to work with GUIDs exclusively, in the sense +// that they may never expose itemIds, nor do they accept them as input. +// More importantly, transactions which add or remove items guarantee to +// restore the GUIDs on undo/redo, so that the following transactions that may +// done or undo can assume the items they're interested in are stil accessible +// through the same GUID. +// The current bookmarks API, however, doesn't expose the necessary means for +// working with GUIDs. So, until it does, this helper object accesses the +// Places database directly in order to switch between GUIDs and itemIds, and +// "restore" GUIDs on items re-created items. +var GuidHelper = { + // Cache for GUID<->itemId paris. + guidsForIds: new Map(), + idsForGuids: new Map(), + + async getItemId(aGuid) { + let cached = this.idsForGuids.get(aGuid); + if (cached !== undefined) { + return cached; + } + + let itemId = await PlacesUtils.withConnectionWrapper( + "GuidHelper.getItemId", + async function (db) { + let rows = await db.executeCached( + "SELECT b.id, b.guid from moz_bookmarks b WHERE b.guid = :guid LIMIT 1", + { guid: aGuid } + ); + if (!rows.length) { + throw new Error("no item found for the given GUID"); + } + + return rows[0].getResultByName("id"); + } + ); + + this.updateCache(itemId, aGuid); + return itemId; + }, + + async getManyItemIds(aGuids) { + let uncachedGuids = aGuids.filter(guid => !this.idsForGuids.has(guid)); + if (uncachedGuids.length) { + await PlacesUtils.withConnectionWrapper( + "GuidHelper.getItemId", + async db => { + while (uncachedGuids.length) { + let chunk = uncachedGuids.splice(0, 100); + let rows = await db.executeCached( + `SELECT b.id, b.guid from moz_bookmarks b WHERE + b.guid IN (${"?,".repeat(chunk.length - 1) + "?"}) + LIMIT ${chunk.length}`, + chunk + ); + if (rows.length < chunk.length) { + throw new Error("Not all items were found!"); + } + for (let row of rows) { + this.updateCache( + row.getResultByIndex(0), + row.getResultByIndex(1) + ); + } + } + } + ); + } + return new Map(aGuids.map(guid => [guid, this.idsForGuids.get(guid)])); + }, + + async getItemGuid(aItemId) { + let cached = this.guidsForIds.get(aItemId); + if (cached !== undefined) { + return cached; + } + + let guid = await PlacesUtils.withConnectionWrapper( + "GuidHelper.getItemGuid", + async function (db) { + let rows = await db.executeCached( + "SELECT b.id, b.guid from moz_bookmarks b WHERE b.id = :id LIMIT 1", + { id: aItemId } + ); + if (!rows.length) { + throw new Error("no item found for the given itemId"); + } + + return rows[0].getResultByName("guid"); + } + ); + + this.updateCache(aItemId, guid); + return guid; + }, + + /** + * Updates the cache. + * + * @note This is the only place where the cache should be populated, + * invalidation relies on both Maps being populated at the same time. + */ + updateCache(aItemId, aGuid) { + if (typeof aItemId != "number" || aItemId <= 0) { + throw new Error( + "Trying to update the GUIDs cache with an invalid itemId" + ); + } + if (!PlacesUtils.isValidGuid(aGuid)) { + throw new Error("Trying to update the GUIDs cache with an invalid GUID"); + } + this.ensureObservingRemovedItems(); + this.guidsForIds.set(aItemId, aGuid); + this.idsForGuids.set(aGuid, aItemId); + }, + + invalidateCacheForItemId(aItemId) { + let guid = this.guidsForIds.get(aItemId); + this.guidsForIds.delete(aItemId); + this.idsForGuids.delete(guid); + }, + + invalidateCache() { + this.guidsForIds.clear(); + this.idsForGuids.clear(); + }, + + ensureObservingRemovedItems() { + if (this.addListeners) { + return; + } + /** + * This observers serves two purposes: + * (1) Invalidate cached id<->GUID paris on when items are removed. + * (2) Cache GUIDs given us free of charge by onItemAdded/onItemRemoved. + * So, for exmaple, when the NewBookmark needs the new GUID, we already + * have it cached. + */ + let listener = events => { + for (let event of events) { + switch (event.type) { + case "bookmark-added": + this.updateCache(event.id, event.guid); + this.updateCache(event.parentId, event.parentGuid); + break; + case "bookmark-removed": + this.guidsForIds.delete(event.id); + this.idsForGuids.delete(event.guid); + this.updateCache(event.parentId, event.parentGuid); + break; + } + } + }; + + this.addListeners = true; + PlacesUtils.observers.addListener( + ["bookmark-added", "bookmark-removed"], + listener + ); + PlacesUtils.registerShutdownFunction(() => { + PlacesUtils.observers.removeListener( + ["bookmark-added", "bookmark-removed"], + listener + ); + }); + }, +}; |