The Tor Browser: comparison toolkit/components/places/PlacesUtils.jsm

--1:000000000000
+:c1da90dc76d1
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. */
+this.EXPORTED_SYMBOLS = [
+"PlacesUtils"
+, "PlacesAggregatedTransaction"
+, "PlacesCreateFolderTransaction"
+, "PlacesCreateBookmarkTransaction"
+, "PlacesCreateSeparatorTransaction"
+, "PlacesCreateLivemarkTransaction"
+, "PlacesMoveItemTransaction"
+, "PlacesRemoveItemTransaction"
+, "PlacesEditItemTitleTransaction"
+, "PlacesEditBookmarkURITransaction"
+, "PlacesSetItemAnnotationTransaction"
+, "PlacesSetPageAnnotationTransaction"
+, "PlacesEditBookmarkKeywordTransaction"
+, "PlacesEditBookmarkPostDataTransaction"
+, "PlacesEditItemDateAddedTransaction"
+, "PlacesEditItemLastModifiedTransaction"
+, "PlacesSortFolderByNameTransaction"
+, "PlacesTagURITransaction"
+, "PlacesUntagURITransaction"
+];
+const Ci = Components.interfaces;
+const Cc = Components.classes;
+const Cr = Components.results;
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Services",
+"resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+"resource://gre/modules/NetUtil.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+"resource://gre/modules/Task.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+"resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Deprecated",
+"resource://gre/modules/Deprecated.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "BookmarkJSONUtils",
+"resource://gre/modules/BookmarkJSONUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PlacesBackups",
+"resource://gre/modules/PlacesBackups.jsm");
+// The minimum amount of transactions before starting a batch. Usually we do
+// do incremental updates, a batch will cause views to completely
+// refresh instead.
+const MIN_TRANSACTIONS_FOR_BATCH = 5;
+#ifdef XP_MACOSX
+// On Mac OSX, the transferable system converts "\r\n" to "\n\n", where we
+// really just want "\n".
+const NEWLINE= "\n";
+#else
+// On other platforms, the transferable system converts "\r\n" to "\n".
+const NEWLINE = "\r\n";
+#endif
+function QI_node(aNode, aIID) {
+var result = null;
+try {
+result = aNode.QueryInterface(aIID);
+}
+catch (e) {
+}
+return result;
+}
+function asContainer(aNode) QI_node(aNode, Ci.nsINavHistoryContainerResultNode);
+function asQuery(aNode) QI_node(aNode, Ci.nsINavHistoryQueryResultNode);
+this.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_UNICODE: "text/unicode",
+// Used to track the action that populated the clipboard.
+TYPE_X_MOZ_PLACE_ACTION: "text/x-moz-place-action",
+EXCLUDE_FROM_BACKUP_ANNO: "places/excludeFromBackup",
+LMANNO_FEEDURI: "livemark/feedURI",
+LMANNO_SITEURI: "livemark/siteURI",
+POST_DATA_ANNO: "bookmarkProperties/POSTData",
+READ_ONLY_ANNO: "placesInternal/READ_ONLY",
+CHARSET_ANNO: "URIProperties/characterSet",
+TOPIC_SHUTDOWN: "places-shutdown",
+TOPIC_INIT_COMPLETE: "places-init-complete",
+TOPIC_DATABASE_LOCKED: "places-database-locked",
+TOPIC_EXPIRATION_FINISHED: "places-expiration-finished",
+TOPIC_FEEDBACK_UPDATED: "places-autocomplete-feedback-updated",
+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",
+asContainer: function(aNode) asContainer(aNode),
+asQuery: function(aNode) asQuery(aNode),
+endl: NEWLINE,
+/**
+* Makes a URI from a spec.
+* @param   aSpec
+*          The string spec of the URI
+* @returns A URI object for the spec.
+*/
+_uri: function PU__uri(aSpec) {
+return NetUtil.newURI(aSpec);
+},
+/**
+* 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 bundle.formatStringFromName(key, params, params.length);
+},
+getString: function PU_getString(key) {
+return bundle.GetStringFromName(key);
+},
+/**
+* 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;
+}
+},
+/**
+* Cache array of read-only item IDs.
+*
+* The first time this property is called:
+* - the cache is filled with all ids with the RO annotation
+* - an annotation observer is added
+* - a shutdown observer is added
+*
+* When the annotation observer detects annotations added or
+* removed that are the RO annotation name, it adds/removes
+* the ids from the cache.
+*
+* At shutdown, the annotation and shutdown observers are removed.
+*/
+get _readOnly() {
+// Add annotations observer.
+this.annotations.addObserver(this, false);
+this.registerShutdownFunction(function () {
+this.annotations.removeObserver(this);
+});
+var readOnly = this.annotations.getItemsWithAnnotation(this.READ_ONLY_ANNO);
+this.__defineGetter__("_readOnly", function() readOnly);
+return this._readOnly;
+},
+QueryInterface: XPCOMUtils.generateQI([
+Ci.nsIAnnotationObserver
+, Ci.nsIObserver
+, Ci.nsITransactionListener
+]),
+_shutdownFunctions: [],
+registerShutdownFunction: function PU_registerShutdownFunction(aFunc)
+{
+// If this is the first registered function, add the shutdown observer.
+if (this._shutdownFunctions.length == 0) {
+Services.obs.addObserver(this, this.TOPIC_SHUTDOWN, false);
+}
+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 > 0) {
+this._shutdownFunctions.shift().apply(this);
+}
+if (this._bookmarksServiceObserversQueue.length > 0) {
+// Since we are shutting down, there's no reason to add the observers.
+this._bookmarksServiceObserversQueue.length = 0;
+}
+break;
+case "bookmarks-service-ready":
+this._bookmarksServiceReady = true;
+while (this._bookmarksServiceObserversQueue.length > 0) {
+let observerInfo = this._bookmarksServiceObserversQueue.shift();
+this.bookmarks.addObserver(observerInfo.observer, observerInfo.weak);
+}
+break;
+}
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsIAnnotationObserver
+onItemAnnotationSet: function PU_onItemAnnotationSet(aItemId, aAnnotationName)
+{
+if (aAnnotationName == this.READ_ONLY_ANNO &&
+this._readOnly.indexOf(aItemId) == -1)
+this._readOnly.push(aItemId);
+},
+onItemAnnotationRemoved:
+function PU_onItemAnnotationRemoved(aItemId, aAnnotationName)
+{
+var index = this._readOnly.indexOf(aItemId);
+if (aAnnotationName == this.READ_ONLY_ANNO && index > -1)
+delete this._readOnly[index];
+},
+onPageAnnotationSet: function() {},
+onPageAnnotationRemoved: function() {},
+//////////////////////////////////////////////////////////////////////////////
+//// nsITransactionListener
+didDo: function PU_didDo(aManager, aTransaction, aDoResult)
+{
+updateCommandsOnActiveWindow();
+},
+didUndo: function PU_didUndo(aManager, aTransaction, aUndoResult)
+{
+updateCommandsOnActiveWindow();
+},
+didRedo: function PU_didRedo(aManager, aTransaction, aRedoResult)
+{
+updateCommandsOnActiveWindow();
+},
+didBeginBatch: function PU_didBeginBatch(aManager, aResult)
+{
+// A no-op transaction is pushed to the stack, in order to make safe and
+// easy to implement "Undo" an unknown number of transactions (including 0),
+// "above" beginBatch and endBatch. Otherwise,implementing Undo that way
+// head to dataloss: for example, if no changes were done in the
+// edit-item panel, the last transaction on the undo stack would be the
+// initial createItem transaction, or even worse, the batched editing of
+// some other item.
+// DO NOT MOVE this to the window scope, that would leak (bug 490068)!
+this.transactionManager.doTransaction({ doTransaction: function() {},
+undoTransaction: function() {},
+redoTransaction: function() {},
+isTransient: false,
+merge: function() { return false; }
+});
+},
+willDo: function PU_willDo() {},
+willUndo: function PU_willUndo() {},
+willRedo: function PU_willRedo() {},
+willBeginBatch: function PU_willBeginBatch() {},
+willEndBatch: function PU_willEndBatch() {},
+didEndBatch: function PU_didEndBatch() {},
+willMerge: function PU_willMerge() {},
+didMerge: function PU_didMerge() {},
+/**
+* Determines if a node is read only (children cannot be inserted, sometimes
+* they cannot be removed depending on the circumstance)
+* @param   aNode
+*          A result node
+* @returns true if the node is readonly, false otherwise
+*/
+nodeIsReadOnly: function PU_nodeIsReadOnly(aNode) {
+let itemId = aNode.itemId;
+if (itemId != -1) {
+return this._readOnly.indexOf(itemId) != -1;
+}
+if (this.nodeIsQuery(aNode) &&
+asQuery(aNode).queryOptions.resultType !=
+Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAG_CONTENTS)
+return aNode.childrenReadOnly;
+return false;
+},
+/**
+* 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) {
+return aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY &&
+asQuery(aNode).queryOptions.resultType ==
+Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAG_CONTENTS;
+},
+/**
+* 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.indexOf(aNode.type) != -1;
+},
+/**
+* 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));
+},
+/**
+* Determines whether or not a node is a readonly folder.
+* @param   aNode
+*          The node to test.
+* @returns true if the node is a readonly folder.
+*/
+isReadonlyFolder: function(aNode) {
+return this.nodeIsFolder(aNode) &&
+this._readOnly.indexOf(asQuery(aNode).folderItemId) != -1;
+},
+/**
+* Gets the concrete item-id for the given node. Generally, this is just
+* node.itemId, but for folder-shortcuts that's node.folderItemId.
+*/
+getConcreteItemId: function PU_getConcreteItemId(aNode) {
+if (aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER_SHORTCUT)
+return asQuery(aNode).folderItemId;
+else if (PlacesUtils.nodeIsTagQuery(aNode)) {
+// RESULTS_AS_TAG_CONTENTS queries are similar to folder shortcuts
+// so we can still get the concrete itemId for them.
+var queries = aNode.getQueries();
+var folders = queries[0].getFolders();
+return folders[0];
+}
+return aNode.itemId;
+},
+/**
+* String-wraps a result node according to the rules of the specified
+* content type.
+* @param   aNode
+*          The Result node to wrap (serialize)
+* @param   aType
+*          The content type to serialize as
+* @param   [optional] aOverrideURI
+*          Used instead of the node's URI if provided.
+*          This is useful for wrapping a container as TYPE_X_MOZ_URL,
+*          TYPE_HTML or TYPE_UNICODE.
+* @return  A string serialization of the node
+*/
+wrapNode: function PU_wrapNode(aNode, aType, aOverrideURI) {
+// 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 convertNode(cNode) {
+if (PlacesUtils.nodeIsFolder(cNode) &&
+cNode.type != Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER_SHORTCUT &&
+asQuery(cNode).queryOptions.excludeItems) {
+return [PlacesUtils.getFolderContents(cNode.itemId, false, true).root, true];
+}
+// If we didn't create our own query, do not alter the node's open state.
+return [cNode, false];
+}
+function gatherLivemarkUrl(aNode) {
+try {
+return PlacesUtils.annotations
+.getItemAnnotation(aNode.itemId,
+PlacesUtils.LMANNO_SITEURI);
+} catch (ex) {
+return PlacesUtils.annotations
+.getItemAnnotation(aNode.itemId,
+PlacesUtils.LMANNO_FEEDURI);
+}
+}
+function isLivemark(aNode) {
+return PlacesUtils.nodeIsFolder(aNode) &&
+PlacesUtils.annotations
+.itemHasAnnotation(aNode.itemId,
+PlacesUtils.LMANNO_FEEDURI);
+}
+switch (aType) {
+case this.TYPE_X_MOZ_PLACE:
+case this.TYPE_X_MOZ_PLACE_SEPARATOR:
+case this.TYPE_X_MOZ_PLACE_CONTAINER: {
+let writer = {
+value: "",
+write: function PU_wrapNode__write(aStr, aLen) {
+this.value += aStr;
+}
+};
+let [node, shouldClose] = convertNode(aNode);
+this._serializeNodeAsJSONToOutputStream(node, writer);
+if (shouldClose)
+node.containerOpen = false;
+return writer.value;
+}
+case this.TYPE_X_MOZ_URL: {
+function gatherDataUrl(bNode) {
+if (isLivemark(bNode)) {
+return gatherLivemarkUrl(bNode) + NEWLINE + bNode.title;
+}
+if (PlacesUtils.nodeIsURI(bNode))
+return (aOverrideURI || bNode.uri) + NEWLINE + bNode.title;
+// ignore containers and separators - items without valid URIs
+return "";
+}
+let [node, shouldClose] = convertNode(aNode);
+let dataUrl = gatherDataUrl(node);
+if (shouldClose)
+node.containerOpen = false;
+return dataUrl;
+}
+case this.TYPE_HTML: {
+function gatherDataHtml(bNode) {
+function htmlEscape(s) {
+s = s.replace(/&/g, "&amp;");
+s = s.replace(/>/g, "&gt;");
+s = s.replace(/</g, "&lt;");
+s = s.replace(/"/g, "&quot;");
+s = s.replace(/'/g, "&apos;");
+return s;
+}
+// escape out potential HTML in the title
+let escapedTitle = bNode.title ? htmlEscape(bNode.title) : "";
+if (isLivemark(bNode)) {
+return "<A HREF=\"" + gatherLivemarkUrl(bNode) + "\">" + escapedTitle + "</A>" + NEWLINE;
+}
+if (PlacesUtils.nodeIsContainer(bNode)) {
+asContainer(bNode);
+let wasOpen = bNode.containerOpen;
+if (!wasOpen)
+bNode.containerOpen = true;
+let childString = "<DL><DT>" + escapedTitle + "</DT>" + NEWLINE;
+let cc = bNode.childCount;
+for (let i = 0; i < cc; ++i)
+childString += "<DD>"
++ NEWLINE
++ gatherDataHtml(bNode.getChild(i))
++ "</DD>"
++ NEWLINE;
+bNode.containerOpen = wasOpen;
+return childString + "</DL>" + NEWLINE;
+}
+if (PlacesUtils.nodeIsURI(bNode))
+return "<A HREF=\"" + bNode.uri + "\">" + escapedTitle + "</A>" + NEWLINE;
+if (PlacesUtils.nodeIsSeparator(bNode))
+return "<HR>" + NEWLINE;
+return "";
+}
+let [node, shouldClose] = convertNode(aNode);
+let dataHtml = gatherDataHtml(node);
+if (shouldClose)
+node.containerOpen = false;
+return dataHtml;
+}
+}
+// Otherwise, we wrap as TYPE_UNICODE.
+function gatherDataText(bNode) {
+if (isLivemark(bNode)) {
+return gatherLivemarkUrl(bNode);
+}
+if (PlacesUtils.nodeIsContainer(bNode)) {
+asContainer(bNode);
+let wasOpen = bNode.containerOpen;
+if (!wasOpen)
+bNode.containerOpen = true;
+let childString = bNode.title + NEWLINE;
+let cc = bNode.childCount;
+for (let i = 0; i < cc; ++i) {
+let child = bNode.getChild(i);
+let suffix = i < (cc - 1) ? NEWLINE : "";
+childString += gatherDataText(child) + suffix;
+}
+bNode.containerOpen = wasOpen;
+return childString;
+}
+if (PlacesUtils.nodeIsURI(bNode))
+return (aOverrideURI || bNode.uri);
+if (PlacesUtils.nodeIsSeparator(bNode))
+return "--------------------";
+return "";
+}
+let [node, shouldClose] = convertNode(aNode);
+let dataText = gatherDataText(node);
+// Convert node could pass an open container node.
+if (shouldClose)
+node.containerOpen = false;
+return dataText;
+},
+/**
+* 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.
+*/
+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:
+var 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 (var i = 0; i < parts.length; i=i+2) {
+var uriString = parts[i];
+var 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 = this._uri(uriString).QueryInterface(Ci.nsIURL)
+.fileName;
+}
+catch (e) {}
+}
+// note:  this._uri() will throw if uriString is not a valid URI
+if (this._uri(uriString)) {
+nodes.push({ uri: uriString,
+title: titleString ? titleString : uriString ,
+type: this.TYPE_X_MOZ_URL });
+}
+}
+break;
+case this.TYPE_UNICODE:
+var parts = blob.split("\n");
+for (var i = 0; i < parts.length; i++) {
+var uriString = parts[i];
+// text/uri-list is converted to TYPE_UNICODE but it could contain
+// comments line prepended by #, we should skip them
+if (uriString.substr(0, 1) == '\x23')
+continue;
+// note: this._uri() will throw if uriString is not a valid URI
+if (uriString != "" && this._uri(uriString))
+nodes.push({ uri: uriString,
+title: uriString,
+type: this.TYPE_X_MOZ_URL });
+}
+break;
+default:
+throw Cr.NS_ERROR_INVALID_ARG;
+}
+return nodes;
+},
+/**
+* Generates a nsINavHistoryResult for the contents of a folder.
+* @param   folderId
+*          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:
+function PU_getFolderContents(aFolderId, aExcludeItems, aExpandQueries) {
+var query = this.history.getNewQuery();
+query.setFolders([aFolderId], 1);
+var options = this.history.getNewQueryOptions();
+options.excludeItems = aExcludeItems;
+options.expandQueries = aExpandQueries;
+var result = this.history.executeQuery(query, options);
+result.root.containerOpen = true;
+return result;
+},
+/**
+* Fetch all annotations for a URI, including all properties of each
+* annotation which would be required to recreate it.
+* @param aURI
+*        The URI for which annotations are to be retrieved.
+* @return Array of objects, each containing the following properties:
+*         name, flags, expires, value
+*/
+getAnnotationsForURI: function PU_getAnnotationsForURI(aURI) {
+var annosvc = this.annotations;
+var annos = [], val = null;
+var annoNames = annosvc.getPageAnnotationNames(aURI);
+for (var i = 0; i < annoNames.length; i++) {
+var flags = {}, exp = {}, storageType = {};
+annosvc.getPageAnnotationInfo(aURI, annoNames[i], flags, exp, storageType);
+val = annosvc.getPageAnnotation(aURI, annoNames[i]);
+annos.push({name: annoNames[i],
+flags: flags.value,
+expires: exp.value,
+value: val});
+}
+return annos;
+},
+/**
+* Fetch all annotations for an item, including all properties of each
+* annotation which would be required to recreate it.
+* @param aItemId
+*        The identifier of the itme for which annotations are to be
+*        retrieved.
+* @return Array of objects, each containing the following properties:
+*         name, flags, expires, mimeType, type, value
+*/
+getAnnotationsForItem: function PU_getAnnotationsForItem(aItemId) {
+var annosvc = this.annotations;
+var annos = [], val = null;
+var annoNames = annosvc.getItemAnnotationNames(aItemId);
+for (var i = 0; i < annoNames.length; i++) {
+var flags = {}, exp = {}, storageType = {};
+annosvc.getItemAnnotationInfo(aItemId, annoNames[i], flags, exp, storageType);
+val = annosvc.getItemAnnotation(aItemId, annoNames[i]);
+annos.push({name: annoNames[i],
+flags: flags.value,
+expires: exp.value,
+value: val});
+}
+return annos;
+},
+/**
+* Annotate a URI with a batch of annotations.
+* @param aURI
+*        The URI for which annotations are to be set.
+* @param aAnnotations
+*        Array of objects, each containing the following properties:
+*        name, flags, expires.
+*        If the value for an annotation is not set it will be removed.
+*/
+setAnnotationsForURI: function PU_setAnnotationsForURI(aURI, aAnnos) {
+var annosvc = this.annotations;
+aAnnos.forEach(function(anno) {
+if (anno.value === undefined || anno.value === null) {
+annosvc.removePageAnnotation(aURI, anno.name);
+}
+else {
+let flags = ("flags" in anno) ? anno.flags : 0;
+let expires = ("expires" in anno) ?
+anno.expires : Ci.nsIAnnotationService.EXPIRE_NEVER;
+annosvc.setPageAnnotation(aURI, anno.name, anno.value, flags, expires);
+}
+});
+},
+/**
+* Annotate an item with a batch of annotations.
+* @param aItemId
+*        The identifier of the item for which annotations are to be set
+* @param aAnnotations
+*        Array of objects, each containing the following properties:
+*        name, flags, expires.
+*        If the value for an annotation is not set it will be removed.
+*/
+setAnnotationsForItem: function PU_setAnnotationsForItem(aItemId, aAnnos) {
+var annosvc = this.annotations;
+aAnnos.forEach(function(anno) {
+if (anno.value === undefined || anno.value === null) {
+annosvc.removeItemAnnotation(aItemId, anno.name);
+}
+else {
+let flags = ("flags" in anno) ? anno.flags : 0;
+let expires = ("expires" in anno) ?
+anno.expires : Ci.nsIAnnotationService.EXPIRE_NEVER;
+annosvc.setItemAnnotation(aItemId, anno.name, anno.value, flags,
+expires);
+}
+});
+},
+// Identifier getters for special folders.
+// You should use these everywhere PlacesUtils is available to avoid XPCOM
+// traversal just to get roots' ids.
+get placesRootId() {
+delete this.placesRootId;
+return this.placesRootId = this.bookmarks.placesRoot;
+},
+get bookmarksMenuFolderId() {
+delete this.bookmarksMenuFolderId;
+return this.bookmarksMenuFolderId = this.bookmarks.bookmarksMenuFolder;
+},
+get toolbarFolderId() {
+delete this.toolbarFolderId;
+return this.toolbarFolderId = this.bookmarks.toolbarFolder;
+},
+get tagsFolderId() {
+delete this.tagsFolderId;
+return this.tagsFolderId = this.bookmarks.tagsFolder;
+},
+get unfiledBookmarksFolderId() {
+delete this.unfiledBookmarksFolderId;
+return this.unfiledBookmarksFolderId = this.bookmarks.unfiledBookmarksFolder;
+},
+/**
+* Checks if aItemId is a root.
+*
+*   @param aItemId
+*          item id to look for.
+*   @returns true if aItemId is a root, false otherwise.
+*/
+isRootItem: function PU_isRootItem(aItemId) {
+return aItemId == PlacesUtils.bookmarksMenuFolderId ||
+aItemId == PlacesUtils.toolbarFolderId ||
+aItemId == PlacesUtils.unfiledBookmarksFolderId ||
+aItemId == PlacesUtils.tagsFolderId ||
+aItemId == PlacesUtils.placesRootId;
+},
+/**
+* Set the POST data associated with a bookmark, if any.
+* Used by POST keywords.
+*   @param aBookmarkId
+*   @returns string of POST data
+*/
+setPostDataForBookmark: function PU_setPostDataForBookmark(aBookmarkId, aPostData) {
+const annos = this.annotations;
+if (aPostData)
+annos.setItemAnnotation(aBookmarkId, this.POST_DATA_ANNO, aPostData,
+0, Ci.nsIAnnotationService.EXPIRE_NEVER);
+else if (annos.itemHasAnnotation(aBookmarkId, this.POST_DATA_ANNO))
+annos.removeItemAnnotation(aBookmarkId, this.POST_DATA_ANNO);
+},
+/**
+* Get the POST data associated with a bookmark, if any.
+* @param aBookmarkId
+* @returns string of POST data if set for aBookmarkId. null otherwise.
+*/
+getPostDataForBookmark: function PU_getPostDataForBookmark(aBookmarkId) {
+const annos = this.annotations;
+if (annos.itemHasAnnotation(aBookmarkId, this.POST_DATA_ANNO))
+return annos.getItemAnnotation(aBookmarkId, this.POST_DATA_ANNO);
+return null;
+},
+/**
+* Get the URI (and any associated POST data) for a given keyword.
+* @param aKeyword string keyword
+* @returns an array containing a string URL and a string of POST data
+*/
+getURLAndPostDataForKeyword: function PU_getURLAndPostDataForKeyword(aKeyword) {
+var url = null, postdata = null;
+try {
+var uri = this.bookmarks.getURIForKeyword(aKeyword);
+if (uri) {
+url = uri.spec;
+var bookmarks = this.bookmarks.getBookmarkIdsForURI(uri);
+for (let i = 0; i < bookmarks.length; i++) {
+var bookmark = bookmarks[i];
+var kw = this.bookmarks.getKeywordForBookmark(bookmark);
+if (kw == aKeyword) {
+postdata = this.getPostDataForBookmark(bookmark);
+break;
+}
+}
+}
+} catch(ex) {}
+return [url, postdata];
+},
+/**
+* Get all bookmarks for a URL, excluding items under tags.
+*/
+getBookmarksForURI:
+function PU_getBookmarksForURI(aURI) {
+var bmkIds = this.bookmarks.getBookmarkIdsForURI(aURI);
+// filter the ids list
+return bmkIds.filter(function(aID) {
+var parentId = this.bookmarks.getFolderIdForItem(aID);
+var grandparentId = this.bookmarks.getFolderIdForItem(parentId);
+// item under a tag container
+if (grandparentId == this.tagsFolderId)
+return false;
+return true;
+}, this);
+},
+/**
+* Get the most recently added/modified bookmark for a URL, excluding items
+* under tags.
+*
+* @param aURI
+*        nsIURI of the page we will look for.
+* @returns itemId of the found bookmark, or -1 if nothing is found.
+*/
+getMostRecentBookmarkForURI:
+function PU_getMostRecentBookmarkForURI(aURI) {
+var bmkIds = this.bookmarks.getBookmarkIdsForURI(aURI);
+for (var i = 0; i < bmkIds.length; i++) {
+// Find the first folder which isn't a tag container
+var itemId = bmkIds[i];
+var parentId = this.bookmarks.getFolderIdForItem(itemId);
+// Optimization: if this is a direct child of a root we don't need to
+// check if its grandparent is a tag.
+if (parentId == this.unfiledBookmarksFolderId ||
+parentId == this.toolbarFolderId ||
+parentId == this.bookmarksMenuFolderId)
+return itemId;
+var grandparentId = this.bookmarks.getFolderIdForItem(parentId);
+if (grandparentId != this.tagsFolderId)
+return itemId;
+}
+return -1;
+},
+/**
+* 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 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 queries = {}, options = {};
+this.history.queryStringToQueries(aNode.uri, queries, {}, options);
+options.value.excludeItems = aExcludeItems;
+options.value.expandQueries = aExpandQueries;
+return this.history.executeQueries(queries.value,
+queries.value.length,
+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)});
+}
+if (!wasOpen) {
+root.containerOpen = false;
+if (!didSuppressNotifications)
+result.suppressNotifications = false;
+}
+return urls;
+},
+/**
+* Serializes the given node (and all its descendents) as JSON
+* and writes the serialization to the given output stream.
+*
+* @param   aNode
+*          An nsINavHistoryResultNode
+* @param   aStream
+*          An nsIOutputStream. NOTE: it only uses the write(str, len)
+*          method of nsIOutputStream. The caller is responsible for
+*          closing the stream.
+*/
+_serializeNodeAsJSONToOutputStream: function (aNode, aStream) {
+function addGenericProperties(aPlacesNode, aJSNode) {
+aJSNode.title = aPlacesNode.title;
+aJSNode.id = aPlacesNode.itemId;
+if (aJSNode.id != -1) {
+var parent = aPlacesNode.parent;
+if (parent) {
+aJSNode.parent = parent.itemId;
+aJSNode.parentReadOnly = PlacesUtils.nodeIsReadOnly(parent);
+}
+var dateAdded = aPlacesNode.dateAdded;
+if (dateAdded)
+aJSNode.dateAdded = dateAdded;
+var lastModified = aPlacesNode.lastModified;
+if (lastModified)
+aJSNode.lastModified = lastModified;
+// XXX need a hasAnnos api
+var annos = [];
+try {
+annos = PlacesUtils.getAnnotationsForItem(aJSNode.id).filter(function(anno) {
+// XXX should whitelist this instead, w/ a pref for
+// backup/restore of non-whitelisted annos
+// XXX causes JSON encoding errors, so utf-8 encode
+//anno.value = unescape(encodeURIComponent(anno.value));
+if (anno.name == PlacesUtils.LMANNO_FEEDURI)
+aJSNode.livemark = 1;
+return true;
+});
+} catch(ex) {}
+if (annos.length != 0)
+aJSNode.annos = annos;
+}
+// XXXdietrich - store annos for non-bookmark items
+}
+function addURIProperties(aPlacesNode, aJSNode) {
+aJSNode.type = PlacesUtils.TYPE_X_MOZ_PLACE;
+aJSNode.uri = aPlacesNode.uri;
+if (aJSNode.id && aJSNode.id != -1) {
+// harvest bookmark-specific properties
+var keyword = PlacesUtils.bookmarks.getKeywordForBookmark(aJSNode.id);
+if (keyword)
+aJSNode.keyword = keyword;
+}
+if (aPlacesNode.tags)
+aJSNode.tags = aPlacesNode.tags;
+// last character-set
+var uri = PlacesUtils._uri(aPlacesNode.uri);
+try {
+var lastCharset = PlacesUtils.annotations.getPageAnnotation(
+uri, PlacesUtils.CHARSET_ANNO);
+aJSNode.charset = lastCharset;
+} catch (e) {}
+}
+function addSeparatorProperties(aPlacesNode, aJSNode) {
+aJSNode.type = PlacesUtils.TYPE_X_MOZ_PLACE_SEPARATOR;
+}
+function addContainerProperties(aPlacesNode, aJSNode) {
+var concreteId = PlacesUtils.getConcreteItemId(aPlacesNode);
+if (concreteId != -1) {
+// This is a bookmark or a tag container.
+if (PlacesUtils.nodeIsQuery(aPlacesNode) ||
+concreteId != aPlacesNode.itemId) {
+aJSNode.type = PlacesUtils.TYPE_X_MOZ_PLACE;
+aJSNode.uri = aPlacesNode.uri;
+// folder shortcut
+aJSNode.concreteId = concreteId;
+}
+else { // Bookmark folder or a shortcut we should convert to folder.
+aJSNode.type = PlacesUtils.TYPE_X_MOZ_PLACE_CONTAINER;
+// Mark root folders.
+if (aJSNode.id == PlacesUtils.placesRootId)
+aJSNode.root = "placesRoot";
+else if (aJSNode.id == PlacesUtils.bookmarksMenuFolderId)
+aJSNode.root = "bookmarksMenuFolder";
+else if (aJSNode.id == PlacesUtils.tagsFolderId)
+aJSNode.root = "tagsFolder";
+else if (aJSNode.id == PlacesUtils.unfiledBookmarksFolderId)
+aJSNode.root = "unfiledBookmarksFolder";
+else if (aJSNode.id == PlacesUtils.toolbarFolderId)
+aJSNode.root = "toolbarFolder";
+}
+}
+else {
+// This is a grouped container query, generated on the fly.
+aJSNode.type = PlacesUtils.TYPE_X_MOZ_PLACE;
+aJSNode.uri = aPlacesNode.uri;
+}
+}
+function appendConvertedComplexNode(aNode, aSourceNode, aArray) {
+var repr = {};
+for (let [name, value] in Iterator(aNode))
+repr[name] = value;
+// write child nodes
+var children = repr.children = [];
+if (!aNode.livemark) {
+asContainer(aSourceNode);
+var wasOpen = aSourceNode.containerOpen;
+if (!wasOpen)
+aSourceNode.containerOpen = true;
+var cc = aSourceNode.childCount;
+for (var i = 0; i < cc; ++i) {
+var childNode = aSourceNode.getChild(i);
+appendConvertedNode(aSourceNode.getChild(i), i, children);
+}
+if (!wasOpen)
+aSourceNode.containerOpen = false;
+}
+aArray.push(repr);
+return true;
+}
+function appendConvertedNode(bNode, aIndex, aArray) {
+var node = {};
+// set index in order received
+// XXX handy shortcut, but are there cases where we don't want
+// to export using the sorting provided by the query?
+if (aIndex)
+node.index = aIndex;
+addGenericProperties(bNode, node);
+var parent = bNode.parent;
+var grandParent = parent ? parent.parent : null;
+if (grandParent)
+node.grandParentId = grandParent.itemId;
+if (PlacesUtils.nodeIsURI(bNode)) {
+// Tag root accept only folder nodes
+if (parent && parent.itemId == PlacesUtils.tagsFolderId)
+return false;
+// Check for url validity, since we can't halt while writing a backup.
+// This will throw if we try to serialize an invalid url and it does
+// not make sense saving a wrong or corrupt uri node.
+try {
+PlacesUtils._uri(bNode.uri);
+} catch (ex) {
+return false;
+}
+addURIProperties(bNode, node);
+}
+else if (PlacesUtils.nodeIsContainer(bNode)) {
+// Tag containers accept only uri nodes
+if (grandParent && grandParent.itemId == PlacesUtils.tagsFolderId)
+return false;
+addContainerProperties(bNode, node);
+}
+else if (PlacesUtils.nodeIsSeparator(bNode)) {
+// Tag root accept only folder nodes
+// Tag containers accept only uri nodes
+if ((parent && parent.itemId == PlacesUtils.tagsFolderId) ||
+(grandParent && grandParent.itemId == PlacesUtils.tagsFolderId))
+return false;
+addSeparatorProperties(bNode, node);
+}
+if (!node.feedURI && node.type == PlacesUtils.TYPE_X_MOZ_PLACE_CONTAINER)
+return appendConvertedComplexNode(node, bNode, aArray);
+aArray.push(node);
+return true;
+}
+// serialize to stream
+var array = [];
+if (appendConvertedNode(aNode, null, array)) {
+var json = JSON.stringify(array[0]);
+aStream.write(json, json.length);
+}
+else {
+throw Cr.NS_ERROR_UNEXPECTED;
+}
+},
+/**
+* Given a uri returns list of itemIds associated to it.
+*
+* @param aURI
+*        nsIURI or spec of the page.
+* @param aCallback
+*        Function to be called when done.
+*        The function will receive an array of itemIds associated to aURI and
+*        aURI itself.
+*
+* @return A object with a .cancel() method allowing to cancel the request.
+*
+* @note Children of live bookmarks folders are excluded. The callback function is
+*       not invoked if the request is cancelled or hits an error.
+*/
+asyncGetBookmarkIds: function PU_asyncGetBookmarkIds(aURI, aCallback)
+{
+if (!this._asyncGetBookmarksStmt) {
+let db = this.history.DBConnection;
+this._asyncGetBookmarksStmt = db.createAsyncStatement(
+"SELECT b.id "
++ "FROM moz_bookmarks b "
++ "JOIN moz_places h on h.id = b.fk "
++ "WHERE h.url = :url "
+);
+this.registerShutdownFunction(function () {
+this._asyncGetBookmarksStmt.finalize();
+});
+}
+let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
+this._asyncGetBookmarksStmt.params.url = url;
+// Storage does not guarantee that invoking cancel() on a statement
+// will cause a REASON_CANCELED.  Thus we wrap the statement.
+let stmt = new AsyncStatementCancelWrapper(this._asyncGetBookmarksStmt);
+return stmt.executeAsync({
+_callback: aCallback,
+_itemIds: [],
+handleResult: function(aResultSet) {
+for (let row; (row = aResultSet.getNextRow());) {
+this._itemIds.push(row.getResultByIndex(0));
+}
+},
+handleCompletion: function(aReason)
+{
+if (aReason == Ci.mozIStorageStatementCallback.REASON_FINISHED) {
+this._callback(this._itemIds, aURI);
+}
+}
+});
+},
+/**
+* Lazily adds a bookmarks observer, waiting for the bookmarks service to be
+* alive before registering the observer.  This is especially useful in the
+* startup path, to avoid initializing the service just to add an observer.
+*
+* @param aObserver
+*        Object implementing nsINavBookmarkObserver
+* @param [optional]aWeakOwner
+*        Whether to use weak ownership.
+*
+* @note Correct functionality of lazy observers relies on the fact Places
+*       notifies categories before real observers, and uses
+*       PlacesCategoriesStarter component to kick-off the registration.
+*/
+_bookmarksServiceReady: false,
+_bookmarksServiceObserversQueue: [],
+addLazyBookmarkObserver:
+function PU_addLazyBookmarkObserver(aObserver, aWeakOwner) {
+if (this._bookmarksServiceReady) {
+this.bookmarks.addObserver(aObserver, aWeakOwner === true);
+return;
+}
+this._bookmarksServiceObserversQueue.push({ observer: aObserver,
+weak: aWeakOwner === true });
+},
+/**
+* Removes a bookmarks observer added through addLazyBookmarkObserver.
+*
+* @param aObserver
+*        Object implementing nsINavBookmarkObserver
+*/
+removeLazyBookmarkObserver:
+function PU_removeLazyBookmarkObserver(aObserver) {
+if (this._bookmarksServiceReady) {
+this.bookmarks.removeObserver(aObserver);
+return;
+}
+let index = -1;
+for (let i = 0;
+i < this._bookmarksServiceObserversQueue.length && index == -1; i++) {
+if (this._bookmarksServiceObserversQueue[i].observer === aObserver)
+index = i;
+}
+if (index != -1) {
+this._bookmarksServiceObserversQueue.splice(index, 1);
+}
+},
+/**
+* Sets the character-set for a URI.
+*
+* @param aURI nsIURI
+* @param aCharset character-set value.
+* @return {Promise}
+*/
+setCharsetForURI: function PU_setCharsetForURI(aURI, aCharset) {
+let deferred = Promise.defer();
+// Delaying to catch issues with asynchronous behavior while waiting
+// to implement asynchronous annotations in bug 699844.
+Services.tm.mainThread.dispatch(function() {
+if (aCharset && aCharset.length > 0) {
+PlacesUtils.annotations.setPageAnnotation(
+aURI, PlacesUtils.CHARSET_ANNO, aCharset, 0,
+Ci.nsIAnnotationService.EXPIRE_NEVER);
+} else {
+PlacesUtils.annotations.removePageAnnotation(
+aURI, PlacesUtils.CHARSET_ANNO);
+}
+deferred.resolve();
+}, Ci.nsIThread.DISPATCH_NORMAL);
+return deferred.promise;
+},
+/**
+* Gets the last saved character-set for a URI.
+*
+* @param aURI nsIURI
+* @return {Promise}
+* @resolve a character-set or null.
+*/
+getCharsetForURI: function PU_getCharsetForURI(aURI) {
+let deferred = Promise.defer();
+Services.tm.mainThread.dispatch(function() {
+let charset = null;
+try {
+charset = PlacesUtils.annotations.getPageAnnotation(aURI,
+PlacesUtils.CHARSET_ANNO);
+} catch (ex) { }
+deferred.resolve(charset);
+}, Ci.nsIThread.DISPATCH_NORMAL);
+return deferred.promise;
+},
+/**
+* Promised wrapper for mozIAsyncHistory::updatePlaces for a single place.
+*
+* @param aPlaces
+*        a single mozIPlaceInfo object
+* @resolves {Promise}
+*/
+promiseUpdatePlace: function PU_promiseUpdatePlaces(aPlace) {
+let deferred = Promise.defer();
+PlacesUtils.asyncHistory.updatePlaces(aPlace, {
+_placeInfo: null,
+handleResult: function handleResult(aPlaceInfo) {
+this._placeInfo = aPlaceInfo;
+},
+handleError: function handleError(aResultCode, aPlaceInfo) {
+deferred.reject(new Components.Exception("Error", aResultCode));
+},
+handleCompletion: function() {
+deferred.resolve(this._placeInfo);
+}
+});
+return deferred.promise;
+},
+/**
+* Promised wrapper for mozIAsyncHistory::getPlacesInfo for a single place.
+*
+* @param aPlaceIdentifier
+*        either an nsIURI or a GUID (@see getPlacesInfo)
+* @resolves to the place info object handed to handleResult.
+*/
+promisePlaceInfo: function PU_promisePlaceInfo(aPlaceIdentifier) {
+let deferred = Promise.defer();
+PlacesUtils.asyncHistory.getPlacesInfo(aPlaceIdentifier, {
+_placeInfo: null,
+handleResult: function handleResult(aPlaceInfo) {
+this._placeInfo = aPlaceInfo;
+},
+handleError: function handleError(aResultCode, aPlaceInfo) {
+deferred.reject(new Components.Exception("Error", aResultCode));
+},
+handleCompletion: function() {
+deferred.resolve(this._placeInfo);
+}
+});
+return deferred.promise;
+},
+/**
+* Gets favicon data for a given page url.
+*
+* @param aPageUrl url of the page to look favicon for.
+* @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: function (aPageUrl) {
+let deferred = Promise.defer();
+PlacesUtils.favicons.getFaviconDataForPage(NetUtil.newURI(aPageUrl),
+function (aURI, aDataLen, aData, aMimeType) {
+if (aURI) {
+deferred.resolve({ uri: aURI,
+dataLen: aDataLen,
+data: aData,
+mimeType: aMimeType });
+} else {
+deferred.reject();
+}
+});
+return deferred.promise;
+},
+/**
+* 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: function (aItemId) 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
+* @retrun {Promise}
+* @resolves to the GUID.
+* @rejects if there's no item for the given GUID.
+*/
+promiseItemId: function (aGUID) GUIDHelper.getItemId(aGUID)
+};
+/**
+* Wraps the provided statement so that invoking cancel() on the pending
+* statement object will always cause a REASON_CANCELED.
+*/
+function AsyncStatementCancelWrapper(aStmt) {
+this._stmt = aStmt;
+}
+AsyncStatementCancelWrapper.prototype = {
+_canceled: false,
+_cancel: function() {
+this._canceled = true;
+this._pendingStmt.cancel();
+},
+handleResult: function(aResultSet) {
+this._callback.handleResult(aResultSet);
+},
+handleError: function(aError) {
+Cu.reportError("Async statement execution returned (" + aError.result +
+"): " + aError.message);
+},
+handleCompletion: function(aReason)
+{
+let reason = this._canceled ?
+Ci.mozIStorageStatementCallback.REASON_CANCELED :
+aReason;
+this._callback.handleCompletion(reason);
+},
+executeAsync: function(aCallback) {
+this._pendingStmt = this._stmt.executeAsync(this);
+this._callback = aCallback;
+let self = this;
+return { cancel: function () { self._cancel(); } }
+}
+}
+XPCOMUtils.defineLazyGetter(PlacesUtils, "history", function() {
+return Cc["@mozilla.org/browser/nav-history-service;1"]
+.getService(Ci.nsINavHistoryService)
+.QueryInterface(Ci.nsIBrowserHistory)
+.QueryInterface(Ci.nsPIPlacesDatabase);
+});
+XPCOMUtils.defineLazyServiceGetter(PlacesUtils, "asyncHistory",
+"@mozilla.org/browser/history;1",
+"mozIAsyncHistory");
+XPCOMUtils.defineLazyGetter(PlacesUtils, "bhistory", function() {
+return PlacesUtils.history;
+});
+XPCOMUtils.defineLazyServiceGetter(PlacesUtils, "favicons",
+"@mozilla.org/browser/favicon-service;1",
+"mozIAsyncFavicons");
+XPCOMUtils.defineLazyServiceGetter(PlacesUtils, "bookmarks",
+"@mozilla.org/browser/nav-bookmarks-service;1",
+"nsINavBookmarksService");
+XPCOMUtils.defineLazyServiceGetter(PlacesUtils, "annotations",
+"@mozilla.org/browser/annotation-service;1",
+"nsIAnnotationService");
+XPCOMUtils.defineLazyServiceGetter(PlacesUtils, "tagging",
+"@mozilla.org/browser/tagging-service;1",
+"nsITaggingService");
+XPCOMUtils.defineLazyGetter(PlacesUtils, "livemarks", function() {
+return Cc["@mozilla.org/browser/livemark-service;2"].
+getService(Ci.mozIAsyncLivemarks);
+});
+XPCOMUtils.defineLazyGetter(PlacesUtils, "transactionManager", function() {
+let tm = Cc["@mozilla.org/transactionmanager;1"].
+createInstance(Ci.nsITransactionManager);
+tm.AddListener(PlacesUtils);
+this.registerShutdownFunction(function () {
+// Clear all references to local transactions in the transaction manager,
+// this prevents from leaking it.
+this.transactionManager.RemoveListener(this);
+this.transactionManager.clear();
+});
+// Bug 750269
+// The transaction manager keeps strong references to transactions, and by
+// that, also to the global for each transaction.  A transaction, however,
+// could be either the transaction itself (for which the global is this
+// module) or some js-proxy in another global, usually a window.  The later
+// would leak because the transaction lifetime (in the manager's stacks)
+// is independent of the global from which doTransaction was called.
+// To avoid such a leak, we hide the native doTransaction from callers,
+// and let each doTransaction call go through this module.
+// Doing so ensures that, as long as the transaction is any of the
+// PlacesXXXTransaction objects declared in this module, the object
+// referenced by the transaction manager has the module itself as global.
+return Object.create(tm, {
+"doTransaction": {
+value: function(aTransaction) {
+tm.doTransaction(aTransaction);
+}
+}
+});
+});
+XPCOMUtils.defineLazyGetter(this, "bundle", function() {
+const PLACES_STRING_BUNDLE_URI = "chrome://places/locale/places.properties";
+return Cc["@mozilla.org/intl/stringbundle;1"].
+getService(Ci.nsIStringBundleService).
+createBundle(PLACES_STRING_BUNDLE_URI);
+});
+XPCOMUtils.defineLazyServiceGetter(this, "focusManager",
+"@mozilla.org/focus-manager;1",
+"nsIFocusManager");
+// 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.
+const REASON_FINISHED = Ci.mozIStorageStatementCallback.REASON_FINISHED;
+let GUIDHelper = {
+// Cache for guid<->itemId paris.
+GUIDsForIds: new Map(),
+idsForGUIDs: new Map(),
+getItemId: function (aGUID) {
+if (this.idsForGUIDs.has(aGUID))
+return Promise.resolve(this.idsForGUIDs.get(aGUID));
+let deferred = Promise.defer();
+let itemId = -1;
+this._getIDStatement.params.guid = aGUID;
+this._getIDStatement.executeAsync({
+handleResult: function (aResultSet) {
+let row = aResultSet.getNextRow();
+if (row)
+itemId = row.getResultByIndex(0);
+},
+handleCompletion: aReason => {
+if (aReason == REASON_FINISHED && itemId != -1) {
+this.ensureObservingRemovedItems();
+this.idsForGUIDs.set(aGUID, itemId);
+deferred.resolve(itemId);
+}
+else if (itemId != -1) {
+deferred.reject("no item found for the given guid");
+}
+else {
+deferred.reject("SQLite Error: " + aReason);
+}
+}
+});
+return deferred.promise;
+},
+getItemGUID: function (aItemId) {
+if (this.GUIDsForIds.has(aItemId))
+return Promise.resolve(this.GUIDsForIds.get(aItemId));
+let deferred = Promise.defer();
+let guid = "";
+this._getGUIDStatement.params.id = aItemId;
+this._getGUIDStatement.executeAsync({
+handleResult: function (aResultSet) {
+let row = aResultSet.getNextRow();
+if (row) {
+guid = row.getResultByIndex(1);
+}
+},
+handleCompletion: aReason => {
+if (aReason == REASON_FINISHED && guid) {
+this.ensureObservingRemovedItems();
+this.GUIDsForIds.set(aItemId, guid);
+deferred.resolve(guid);
+}
+else if (!guid) {
+deferred.reject("no item found for the given itemId");
+}
+else {
+deferred.reject("SQLite Error: " + aReason);
+}
+}
+});
+return deferred.promise;
+},
+ensureObservingRemovedItems: function () {
+if (!("observer" in this)) {
+/**
+* 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.
+*/
+this.observer = {
+onItemAdded: (aItemId, aParentId, aIndex, aItemType, aURI, aTitle,
+aDateAdded, aGUID, aParentGUID) => {
+this.GUIDsForIds.set(aItemId, aGUID);
+this.GUIDsForIds.set(aParentId, aParentGUID);
+},
+onItemRemoved:
+(aItemId, aParentId, aIndex, aItemTyep, aURI, aGUID, aParentGUID) => {
+this.GUIDsForIds.delete(aItemId);
+this.idsForGUIDs.delete(aGUID);
+this.GUIDsForIds.set(aParentId, aParentGUID);
+},
+QueryInterface: XPCOMUtils.generateQI(Ci.nsINavBookmarkObserver),
+__noSuchMethod__: () => {}, // Catch all all onItem* methods.
+};
+PlacesUtils.bookmarks.addObserver(this.observer, false);
+PlacesUtils.registerShutdownFunction(() => {
+PlacesUtils.bookmarks.removeObserver(this.observer);
+});
+}
+}
+};
+XPCOMUtils.defineLazyGetter(GUIDHelper, "_getIDStatement", () => {
+let s = PlacesUtils.history.DBConnection.createAsyncStatement(
+"SELECT b.id, b.guid from moz_bookmarks b WHERE b.guid = :guid");
+PlacesUtils.registerShutdownFunction( () => s.finalize() );
+return s;
+});
+XPCOMUtils.defineLazyGetter(GUIDHelper, "_getGUIDStatement", () => {
+let s = PlacesUtils.history.DBConnection.createAsyncStatement(
+"SELECT b.id, b.guid from moz_bookmarks b WHERE b.id = :id");
+PlacesUtils.registerShutdownFunction( () => s.finalize() );
+return s;
+});
+////////////////////////////////////////////////////////////////////////////////
+//// Transactions handlers.
+/**
+* Updates commands in the undo group of the active window commands.
+* Inactive windows commands will be updated on focus.
+*/
+function updateCommandsOnActiveWindow()
+{
+let win = focusManager.activeWindow;
+if (win && win instanceof Ci.nsIDOMWindow) {
+// Updating "undo" will cause a group update including "redo".
+win.updateCommands("undo");
+}
+}
+/**
+* Used to cache bookmark information in transactions.
+*
+* @note To avoid leaks any non-primitive property should be copied.
+* @note Used internally, DO NOT EXPORT.
+*/
+function TransactionItemCache()
+{
+}
+TransactionItemCache.prototype = {
+set id(v)
+this._id = (parseInt(v) > 0 ? v : null),
+get id()
+this._id || -1,
+set parentId(v)
+this._parentId = (parseInt(v) > 0 ? v : null),
+get parentId()
+this._parentId || -1,
+keyword: null,
+title: null,
+dateAdded: null,
+lastModified: null,
+postData: null,
+itemType: null,
+set uri(v)
+this._uri = (v instanceof Ci.nsIURI ? v.clone() : null),
+get uri()
+this._uri || null,
+set feedURI(v)
+this._feedURI = (v instanceof Ci.nsIURI ? v.clone() : null),
+get feedURI()
+this._feedURI || null,
+set siteURI(v)
+this._siteURI = (v instanceof Ci.nsIURI ? v.clone() : null),
+get siteURI()
+this._siteURI || null,
+set index(v)
+this._index = (parseInt(v) >= 0 ? v : null),
+// Index can be 0.
+get index()
+this._index != null ? this._index : PlacesUtils.bookmarks.DEFAULT_INDEX,
+set annotations(v)
+this._annotations = Array.isArray(v) ? Cu.cloneInto(v, {}) : null,
+get annotations()
+this._annotations || null,
+set tags(v)
+this._tags = (v && Array.isArray(v) ? Array.slice(v) : null),
+get tags()
+this._tags || null,
+};
+/**
+* Base transaction implementation.
+*
+* @note used internally, DO NOT EXPORT.
+*/
+function BaseTransaction()
+{
+}
+BaseTransaction.prototype = {
+name: null,
+set childTransactions(v)
+this._childTransactions = (Array.isArray(v) ? Array.slice(v) : null),
+get childTransactions()
+this._childTransactions || null,
+doTransaction: function BTXN_doTransaction() {},
+redoTransaction: function BTXN_redoTransaction() this.doTransaction(),
+undoTransaction: function BTXN_undoTransaction() {},
+merge: function BTXN_merge() false,
+get isTransient() false,
+QueryInterface: XPCOMUtils.generateQI([
+Ci.nsITransaction
+]),
+};
+/**
+* Transaction for performing several Places Transactions in a single batch.
+*
+* @param aName
+*        title of the aggregate transactions
+* @param aTransactions
+*        an array of transactions to perform
+*
+* @return nsITransaction object
+*/
+this.PlacesAggregatedTransaction =
+function PlacesAggregatedTransaction(aName, aTransactions)
+{
+// Copy the transactions array to decouple it from its prototype, which
+// otherwise keeps alive its associated global object.
+this.childTransactions = aTransactions;
+this.name = aName;
+this.item = new TransactionItemCache();
+// Check child transactions number.  We will batch if we have more than
+// MIN_TRANSACTIONS_FOR_BATCH total number of transactions.
+let countTransactions = function(aTransactions, aTxnCount)
+{
+for (let i = 0;
+i < aTransactions.length && aTxnCount < MIN_TRANSACTIONS_FOR_BATCH;
+++i, ++aTxnCount) {
+let txn = aTransactions[i];
+if (txn.childTransactions && txn.childTransactions.length > 0)
+aTxnCount = countTransactions(txn.childTransactions, aTxnCount);
+}
+return aTxnCount;
+}
+let txnCount = countTransactions(this.childTransactions, 0);
+this._useBatch = txnCount >= MIN_TRANSACTIONS_FOR_BATCH;
+}
+PlacesAggregatedTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function ATXN_doTransaction()
+{
+this._isUndo = false;
+if (this._useBatch)
+PlacesUtils.bookmarks.runInBatchMode(this, null);
+else
+this.runBatched(false);
+},
+undoTransaction: function ATXN_undoTransaction()
+{
+this._isUndo = true;
+if (this._useBatch)
+PlacesUtils.bookmarks.runInBatchMode(this, null);
+else
+this.runBatched(true);
+},
+runBatched: function ATXN_runBatched()
+{
+// Use a copy of the transactions array, so we won't reverse the original
+// one on undoing.
+let transactions = this.childTransactions.slice(0);
+if (this._isUndo)
+transactions.reverse();
+for (let i = 0; i < transactions.length; ++i) {
+let txn = transactions[i];
+if (this.item.parentId != -1)
+txn.item.parentId = this.item.parentId;
+if (this._isUndo)
+txn.undoTransaction();
+else
+txn.doTransaction();
+}
+}
+};
+/**
+* Transaction for creating a new folder.
+*
+* @param aTitle
+*        the title for the new folder
+* @param aParentId
+*        the id of the parent folder in which the new folder should be added
+* @param [optional] aIndex
+*        the index of the item in aParentId
+* @param [optional] aAnnotations
+*        array of annotations to set for the new folder
+* @param [optional] aChildTransactions
+*        array of transactions for items to be created in the new folder
+*
+* @return nsITransaction object
+*/
+this.PlacesCreateFolderTransaction =
+function PlacesCreateFolderTransaction(aTitle, aParentId, aIndex, aAnnotations,
+aChildTransactions)
+{
+this.item = new TransactionItemCache();
+this.item.title = aTitle;
+this.item.parentId = aParentId;
+this.item.index = aIndex;
+this.item.annotations = aAnnotations;
+this.childTransactions = aChildTransactions;
+}
+PlacesCreateFolderTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function CFTXN_doTransaction()
+{
+this.item.id = PlacesUtils.bookmarks.createFolder(this.item.parentId,
+this.item.title,
+this.item.index);
+if (this.item.annotations && this.item.annotations.length > 0)
+PlacesUtils.setAnnotationsForItem(this.item.id, this.item.annotations);
+if (this.childTransactions && this.childTransactions.length > 0) {
+// Set the new parent id into child transactions.
+for (let i = 0; i < this.childTransactions.length; ++i) {
+this.childTransactions[i].item.parentId = this.item.id;
+}
+let txn = new PlacesAggregatedTransaction("Create folder childTxn",
+this.childTransactions);
+txn.doTransaction();
+}
+},
+undoTransaction: function CFTXN_undoTransaction()
+{
+if (this.childTransactions && this.childTransactions.length > 0) {
+let txn = new PlacesAggregatedTransaction("Create folder childTxn",
+this.childTransactions);
+txn.undoTransaction();
+}
+// Remove item only after all child transactions have been reverted.
+PlacesUtils.bookmarks.removeItem(this.item.id);
+}
+};
+/**
+* Transaction for creating a new bookmark.
+*
+* @param aURI
+*        the nsIURI of the new bookmark
+* @param aParentId
+*        the id of the folder in which the bookmark should be added.
+* @param [optional] aIndex
+*        the index of the item in aParentId
+* @param [optional] aTitle
+*        the title of the new bookmark
+* @param [optional] aKeyword
+*        the keyword for the new bookmark
+* @param [optional] aAnnotations
+*        array of annotations to set for the new bookmark
+* @param [optional] aChildTransactions
+*        child transactions to commit after creating the bookmark. Prefer
+*        using any of the arguments above if possible. In general, a child
+*        transations should be used only if the change it does has to be
+*        reverted manually when removing the bookmark item.
+*        a child transaction must support setting its bookmark-item
+*        identifier via an "id" js setter.
+*
+* @return nsITransaction object
+*/
+this.PlacesCreateBookmarkTransaction =
+function PlacesCreateBookmarkTransaction(aURI, aParentId, aIndex, aTitle,
+aKeyword, aAnnotations,
+aChildTransactions)
+{
+this.item = new TransactionItemCache();
+this.item.uri = aURI;
+this.item.parentId = aParentId;
+this.item.index = aIndex;
+this.item.title = aTitle;
+this.item.keyword = aKeyword;
+this.item.annotations = aAnnotations;
+this.childTransactions = aChildTransactions;
+}
+PlacesCreateBookmarkTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function CITXN_doTransaction()
+{
+this.item.id = PlacesUtils.bookmarks.insertBookmark(this.item.parentId,
+this.item.uri,
+this.item.index,
+this.item.title);
+if (this.item.keyword) {
+PlacesUtils.bookmarks.setKeywordForBookmark(this.item.id,
+this.item.keyword);
+}
+if (this.item.annotations && this.item.annotations.length > 0)
+PlacesUtils.setAnnotationsForItem(this.item.id, this.item.annotations);
+if (this.childTransactions && this.childTransactions.length > 0) {
+// Set the new item id into child transactions.
+for (let i = 0; i < this.childTransactions.length; ++i) {
+this.childTransactions[i].item.id = this.item.id;
+}
+let txn = new PlacesAggregatedTransaction("Create item childTxn",
+this.childTransactions);
+txn.doTransaction();
+}
+},
+undoTransaction: function CITXN_undoTransaction()
+{
+if (this.childTransactions && this.childTransactions.length > 0) {
+// Undo transactions should always be done in reverse order.
+let txn = new PlacesAggregatedTransaction("Create item childTxn",
+this.childTransactions);
+txn.undoTransaction();
+}
+// Remove item only after all child transactions have been reverted.
+PlacesUtils.bookmarks.removeItem(this.item.id);
+}
+};
+/**
+* Transaction for creating a new separator.
+*
+* @param aParentId
+*        the id of the folder in which the separator should be added
+* @param [optional] aIndex
+*        the index of the item in aParentId
+*
+* @return nsITransaction object
+*/
+this.PlacesCreateSeparatorTransaction =
+function PlacesCreateSeparatorTransaction(aParentId, aIndex)
+{
+this.item = new TransactionItemCache();
+this.item.parentId = aParentId;
+this.item.index = aIndex;
+}
+PlacesCreateSeparatorTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function CSTXN_doTransaction()
+{
+this.item.id =
+PlacesUtils.bookmarks.insertSeparator(this.item.parentId, this.item.index);
+},
+undoTransaction: function CSTXN_undoTransaction()
+{
+PlacesUtils.bookmarks.removeItem(this.item.id);
+}
+};
+/**
+* Transaction for creating a new livemark item.
+*
+* @see mozIAsyncLivemarks for documentation regarding the arguments.
+*
+* @param aFeedURI
+*        nsIURI of the feed
+* @param [optional] aSiteURI
+*        nsIURI of the page serving the feed
+* @param aTitle
+*        title for the livemark
+* @param aParentId
+*        the id of the folder in which the livemark should be added
+* @param [optional]  aIndex
+*        the index of the livemark in aParentId
+* @param [optional] aAnnotations
+*        array of annotations to set for the new livemark.
+*
+* @return nsITransaction object
+*/
+this.PlacesCreateLivemarkTransaction =
+function PlacesCreateLivemarkTransaction(aFeedURI, aSiteURI, aTitle, aParentId,
+aIndex, aAnnotations)
+{
+this.item = new TransactionItemCache();
+this.item.feedURI = aFeedURI;
+this.item.siteURI = aSiteURI;
+this.item.title = aTitle;
+this.item.parentId = aParentId;
+this.item.index = aIndex;
+this.item.annotations = aAnnotations;
+}
+PlacesCreateLivemarkTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function CLTXN_doTransaction()
+{
+PlacesUtils.livemarks.addLivemark(
+{ title: this.item.title
+, feedURI: this.item.feedURI
+, parentId: this.item.parentId
+, index: this.item.index
+, siteURI: this.item.siteURI
+}).then(aLivemark => {
+this.item.id = aLivemark.id;
+if (this.item.annotations && this.item.annotations.length > 0) {
+PlacesUtils.setAnnotationsForItem(this.item.id,
+this.item.annotations);
+}
+}, Cu.reportError);
+},
+undoTransaction: function CLTXN_undoTransaction()
+{
+// The getLivemark callback may fail, but it is used just to serialize,
+// so it doesn't matter.
+PlacesUtils.livemarks.getLivemark({ id: this.item.id })
+.then(null, null).then( () => {
+PlacesUtils.bookmarks.removeItem(this.item.id);
+});
+}
+};
+/**
+* Transaction for removing a livemark item.
+*
+* @param aLivemarkId
+*        the identifier of the folder for the livemark.
+*
+* @return nsITransaction object
+* @note used internally by PlacesRemoveItemTransaction, DO NOT EXPORT.
+*/
+function PlacesRemoveLivemarkTransaction(aLivemarkId)
+{
+this.item = new TransactionItemCache();
+this.item.id = aLivemarkId;
+this.item.title = PlacesUtils.bookmarks.getItemTitle(this.item.id);
+this.item.parentId = PlacesUtils.bookmarks.getFolderIdForItem(this.item.id);
+let annos = PlacesUtils.getAnnotationsForItem(this.item.id);
+// Exclude livemark service annotations, those will be recreated automatically
+let annosToExclude = [PlacesUtils.LMANNO_FEEDURI,
+PlacesUtils.LMANNO_SITEURI];
+this.item.annotations = annos.filter(function(aValue, aIndex, aArray) {
+return annosToExclude.indexOf(aValue.name) == -1;
+});
+this.item.dateAdded = PlacesUtils.bookmarks.getItemDateAdded(this.item.id);
+this.item.lastModified =
+PlacesUtils.bookmarks.getItemLastModified(this.item.id);
+}
+PlacesRemoveLivemarkTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function RLTXN_doTransaction()
+{
+PlacesUtils.livemarks.getLivemark({ id: this.item.id })
+.then(aLivemark => {
+this.item.feedURI = aLivemark.feedURI;
+this.item.siteURI = aLivemark.siteURI;
+PlacesUtils.bookmarks.removeItem(this.item.id);
+}, Cu.reportError);
+},
+undoTransaction: function RLTXN_undoTransaction()
+{
+// Undo work must be serialized, otherwise won't be able to know the
+// feedURI and siteURI of the livemark.
+// The getLivemark callback is expected to receive a failure status but it
+// is used just to serialize, so doesn't matter.
+PlacesUtils.livemarks.getLivemark({ id: this.item.id })
+.then(null, () => {
+PlacesUtils.livemarks.addLivemark({ parentId: this.item.parentId
+, title: this.item.title
+, siteURI: this.item.siteURI
+, feedURI: this.item.feedURI
+, index: this.item.index
+, lastModified: this.item.lastModified
+}).then(
+aLivemark => {
+let itemId = aLivemark.id;
+PlacesUtils.bookmarks.setItemDateAdded(itemId, this.item.dateAdded);
+PlacesUtils.setAnnotationsForItem(itemId, this.item.annotations);
+}, Cu.reportError);
+});
+}
+};
+/**
+* Transaction for moving an Item.
+*
+* @param aItemId
+*        the id of the item to move
+* @param aNewParentId
+*        id of the new parent to move to
+* @param aNewIndex
+*        index of the new position to move to
+*
+* @return nsITransaction object
+*/
+this.PlacesMoveItemTransaction =
+function PlacesMoveItemTransaction(aItemId, aNewParentId, aNewIndex)
+{
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.item.parentId = PlacesUtils.bookmarks.getFolderIdForItem(this.item.id);
+this.new = new TransactionItemCache();
+this.new.parentId = aNewParentId;
+this.new.index = aNewIndex;
+}
+PlacesMoveItemTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function MITXN_doTransaction()
+{
+this.item.index = PlacesUtils.bookmarks.getItemIndex(this.item.id);
+PlacesUtils.bookmarks.moveItem(this.item.id,
+this.new.parentId, this.new.index);
+this._undoIndex = PlacesUtils.bookmarks.getItemIndex(this.item.id);
+},
+undoTransaction: function MITXN_undoTransaction()
+{
+// moving down in the same parent takes in count removal of the item
+// so to revert positions we must move to oldIndex + 1
+if (this.new.parentId == this.item.parentId &&
+this.item.index > this._undoIndex) {
+PlacesUtils.bookmarks.moveItem(this.item.id, this.item.parentId,
+this.item.index + 1);
+}
+else {
+PlacesUtils.bookmarks.moveItem(this.item.id, this.item.parentId,
+this.item.index);
+}
+}
+};
+/**
+* Transaction for removing an Item
+*
+* @param aItemId
+*        id of the item to remove
+*
+* @return nsITransaction object
+*/
+this.PlacesRemoveItemTransaction =
+function PlacesRemoveItemTransaction(aItemId)
+{
+if (PlacesUtils.isRootItem(aItemId))
+throw Cr.NS_ERROR_INVALID_ARG;
+// if the item lives within a tag container, use the tagging transactions
+let parent = PlacesUtils.bookmarks.getFolderIdForItem(aItemId);
+let grandparent = PlacesUtils.bookmarks.getFolderIdForItem(parent);
+if (grandparent == PlacesUtils.tagsFolderId) {
+let uri = PlacesUtils.bookmarks.getBookmarkURI(aItemId);
+return new PlacesUntagURITransaction(uri, [parent]);
+}
+// if the item is a livemark container we will not save its children.
+if (PlacesUtils.annotations.itemHasAnnotation(aItemId,
+PlacesUtils.LMANNO_FEEDURI))
+return new PlacesRemoveLivemarkTransaction(aItemId);
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.item.itemType = PlacesUtils.bookmarks.getItemType(this.item.id);
+if (this.item.itemType == Ci.nsINavBookmarksService.TYPE_FOLDER) {
+this.childTransactions = this._getFolderContentsTransactions();
+// Remove this folder itself.
+let txn = PlacesUtils.bookmarks.getRemoveFolderTransaction(this.item.id);
+this.childTransactions.push(txn);
+}
+else if (this.item.itemType == Ci.nsINavBookmarksService.TYPE_BOOKMARK) {
+this.item.uri = PlacesUtils.bookmarks.getBookmarkURI(this.item.id);
+this.item.keyword =
+PlacesUtils.bookmarks.getKeywordForBookmark(this.item.id);
+}
+if (this.item.itemType != Ci.nsINavBookmarksService.TYPE_SEPARATOR)
+this.item.title = PlacesUtils.bookmarks.getItemTitle(this.item.id);
+this.item.parentId = PlacesUtils.bookmarks.getFolderIdForItem(this.item.id);
+this.item.annotations = PlacesUtils.getAnnotationsForItem(this.item.id);
+this.item.dateAdded = PlacesUtils.bookmarks.getItemDateAdded(this.item.id);
+this.item.lastModified =
+PlacesUtils.bookmarks.getItemLastModified(this.item.id);
+}
+PlacesRemoveItemTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function RITXN_doTransaction()
+{
+this.item.index = PlacesUtils.bookmarks.getItemIndex(this.item.id);
+if (this.item.itemType == Ci.nsINavBookmarksService.TYPE_FOLDER) {
+let txn = new PlacesAggregatedTransaction("Remove item childTxn",
+this.childTransactions);
+txn.doTransaction();
+}
+else {
+// Before removing the bookmark, save its tags.
+let tags = this.item.uri ?
+PlacesUtils.tagging.getTagsForURI(this.item.uri) : null;
+PlacesUtils.bookmarks.removeItem(this.item.id);
+// If this was the last bookmark (excluding tag-items) for this url,
+// persist the tags.
+if (tags && PlacesUtils.getMostRecentBookmarkForURI(this.item.uri) == -1) {
+this.item.tags = tags;
+}
+}
+},
+undoTransaction: function RITXN_undoTransaction()
+{
+if (this.item.itemType == Ci.nsINavBookmarksService.TYPE_BOOKMARK) {
+this.item.id = PlacesUtils.bookmarks.insertBookmark(this.item.parentId,
+this.item.uri,
+this.item.index,
+this.item.title);
+if (this.item.tags && this.item.tags.length > 0)
+PlacesUtils.tagging.tagURI(this.item.uri, this.item.tags);
+if (this.item.keyword) {
+PlacesUtils.bookmarks.setKeywordForBookmark(this.item.id,
+this.item.keyword);
+}
+}
+else if (this.item.itemType == Ci.nsINavBookmarksService.TYPE_FOLDER) {
+let txn = new PlacesAggregatedTransaction("Remove item childTxn",
+this.childTransactions);
+txn.undoTransaction();
+}
+else { // TYPE_SEPARATOR
+this.item.id = PlacesUtils.bookmarks.insertSeparator(this.item.parentId,
+this.item.index);
+}
+if (this.item.annotations && this.item.annotations.length > 0)
+PlacesUtils.setAnnotationsForItem(this.item.id, this.item.annotations);
+PlacesUtils.bookmarks.setItemDateAdded(this.item.id, this.item.dateAdded);
+PlacesUtils.bookmarks.setItemLastModified(this.item.id,
+this.item.lastModified);
+},
+/**
+* Returns a flat, ordered list of transactions for a depth-first recreation
+* of items within this folder.
+*/
+_getFolderContentsTransactions:
+function RITXN__getFolderContentsTransactions()
+{
+let transactions = [];
+let contents =
+PlacesUtils.getFolderContents(this.item.id, false, false).root;
+for (let i = 0; i < contents.childCount; ++i) {
+let txn = new PlacesRemoveItemTransaction(contents.getChild(i).itemId);
+transactions.push(txn);
+}
+contents.containerOpen = false;
+// Reverse transactions to preserve parent-child relationship.
+return transactions.reverse();
+}
+};
+/**
+* Transaction for editting a bookmark's title.
+*
+* @param aItemId
+*        id of the item to edit
+* @param aNewTitle
+*        new title for the item to edit
+*
+* @return nsITransaction object
+*/
+this.PlacesEditItemTitleTransaction =
+function PlacesEditItemTitleTransaction(aItemId, aNewTitle)
+{
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.new = new TransactionItemCache();
+this.new.title = aNewTitle;
+}
+PlacesEditItemTitleTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function EITTXN_doTransaction()
+{
+this.item.title = PlacesUtils.bookmarks.getItemTitle(this.item.id);
+PlacesUtils.bookmarks.setItemTitle(this.item.id, this.new.title);
+},
+undoTransaction: function EITTXN_undoTransaction()
+{
+PlacesUtils.bookmarks.setItemTitle(this.item.id, this.item.title);
+}
+};
+/**
+* Transaction for editing a bookmark's uri.
+*
+* @param aItemId
+*        id of the bookmark to edit
+* @param aNewURI
+*        new uri for the bookmark
+*
+* @return nsITransaction object
+*/
+this.PlacesEditBookmarkURITransaction =
+function PlacesEditBookmarkURITransaction(aItemId, aNewURI) {
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.new = new TransactionItemCache();
+this.new.uri = aNewURI;
+}
+PlacesEditBookmarkURITransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function EBUTXN_doTransaction()
+{
+this.item.uri = PlacesUtils.bookmarks.getBookmarkURI(this.item.id);
+PlacesUtils.bookmarks.changeBookmarkURI(this.item.id, this.new.uri);
+// move tags from old URI to new URI
+this.item.tags = PlacesUtils.tagging.getTagsForURI(this.item.uri);
+if (this.item.tags.length != 0) {
+// only untag the old URI if this is the only bookmark
+if (PlacesUtils.getBookmarksForURI(this.item.uri, {}).length == 0)
+PlacesUtils.tagging.untagURI(this.item.uri, this.item.tags);
+PlacesUtils.tagging.tagURI(this.new.uri, this.item.tags);
+}
+},
+undoTransaction: function EBUTXN_undoTransaction()
+{
+PlacesUtils.bookmarks.changeBookmarkURI(this.item.id, this.item.uri);
+// move tags from new URI to old URI
+if (this.item.tags.length != 0) {
+// only untag the new URI if this is the only bookmark
+if (PlacesUtils.getBookmarksForURI(this.new.uri, {}).length == 0)
+PlacesUtils.tagging.untagURI(this.new.uri, this.item.tags);
+PlacesUtils.tagging.tagURI(this.item.uri, this.item.tags);
+}
+}
+};
+/**
+* Transaction for setting/unsetting an item annotation
+*
+* @param aItemId
+*        id of the item where to set annotation
+* @param aAnnotationObject
+*        Object representing an annotation, containing the following
+*        properties: name, flags, expires, value.
+*        If value is null the annotation will be removed
+*
+* @return nsITransaction object
+*/
+this.PlacesSetItemAnnotationTransaction =
+function PlacesSetItemAnnotationTransaction(aItemId, aAnnotationObject)
+{
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.new = new TransactionItemCache();
+this.new.annotations = [aAnnotationObject];
+}
+PlacesSetItemAnnotationTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function SIATXN_doTransaction()
+{
+let annoName = this.new.annotations[0].name;
+if (PlacesUtils.annotations.itemHasAnnotation(this.item.id, annoName)) {
+// fill the old anno if it is set
+let flags = {}, expires = {}, type = {};
+PlacesUtils.annotations.getItemAnnotationInfo(this.item.id, annoName, flags,
+expires, type);
+let value = PlacesUtils.annotations.getItemAnnotation(this.item.id,
+annoName);
+this.item.annotations = [{ name: annoName,
+type: type.value,
+flags: flags.value,
+value: value,
+expires: expires.value }];
+}
+else {
+// create an empty old anno
+this.item.annotations = [{ name: annoName,
+flags: 0,
+value: null,
+expires: Ci.nsIAnnotationService.EXPIRE_NEVER }];
+}
+PlacesUtils.setAnnotationsForItem(this.item.id, this.new.annotations);
+},
+undoTransaction: function SIATXN_undoTransaction()
+{
+PlacesUtils.setAnnotationsForItem(this.item.id, this.item.annotations);
+}
+};
+/**
+* Transaction for setting/unsetting a page annotation
+*
+* @param aURI
+*        URI of the page where to set annotation
+* @param aAnnotationObject
+*        Object representing an annotation, containing the following
+*        properties: name, flags, expires, value.
+*        If value is null the annotation will be removed
+*
+* @return nsITransaction object
+*/
+this.PlacesSetPageAnnotationTransaction =
+function PlacesSetPageAnnotationTransaction(aURI, aAnnotationObject)
+{
+this.item = new TransactionItemCache();
+this.item.uri = aURI;
+this.new = new TransactionItemCache();
+this.new.annotations = [aAnnotationObject];
+}
+PlacesSetPageAnnotationTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function SPATXN_doTransaction()
+{
+let annoName = this.new.annotations[0].name;
+if (PlacesUtils.annotations.pageHasAnnotation(this.item.uri, annoName)) {
+// fill the old anno if it is set
+let flags = {}, expires = {}, type = {};
+PlacesUtils.annotations.getPageAnnotationInfo(this.item.uri, annoName, flags,
+expires, type);
+let value = PlacesUtils.annotations.getPageAnnotation(this.item.uri,
+annoName);
+this.item.annotations = [{ name: annoName,
+flags: flags.value,
+value: value,
+expires: expires.value }];
+}
+else {
+// create an empty old anno
+this.item.annotations = [{ name: annoName,
+type: Ci.nsIAnnotationService.TYPE_STRING,
+flags: 0,
+value: null,
+expires: Ci.nsIAnnotationService.EXPIRE_NEVER }];
+}
+PlacesUtils.setAnnotationsForURI(this.item.uri, this.new.annotations);
+},
+undoTransaction: function SPATXN_undoTransaction()
+{
+PlacesUtils.setAnnotationsForURI(this.item.uri, this.item.annotations);
+}
+};
+/**
+* Transaction for editing a bookmark's keyword.
+*
+* @param aItemId
+*        id of the bookmark to edit
+* @param aNewKeyword
+*        new keyword for the bookmark
+*
+* @return nsITransaction object
+*/
+this.PlacesEditBookmarkKeywordTransaction =
+function PlacesEditBookmarkKeywordTransaction(aItemId, aNewKeyword)
+{
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.new = new TransactionItemCache();
+this.new.keyword = aNewKeyword;
+}
+PlacesEditBookmarkKeywordTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function EBKTXN_doTransaction()
+{
+this.item.keyword = PlacesUtils.bookmarks.getKeywordForBookmark(this.item.id);
+PlacesUtils.bookmarks.setKeywordForBookmark(this.item.id, this.new.keyword);
+},
+undoTransaction: function EBKTXN_undoTransaction()
+{
+PlacesUtils.bookmarks.setKeywordForBookmark(this.item.id, this.item.keyword);
+}
+};
+/**
+* Transaction for editing the post data associated with a bookmark.
+*
+* @param aItemId
+*        id of the bookmark to edit
+* @param aPostData
+*        post data
+*
+* @return nsITransaction object
+*/
+this.PlacesEditBookmarkPostDataTransaction =
+function PlacesEditBookmarkPostDataTransaction(aItemId, aPostData)
+{
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.new = new TransactionItemCache();
+this.new.postData = aPostData;
+}
+PlacesEditBookmarkPostDataTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function EBPDTXN_doTransaction()
+{
+this.item.postData = PlacesUtils.getPostDataForBookmark(this.item.id);
+PlacesUtils.setPostDataForBookmark(this.item.id, this.new.postData);
+},
+undoTransaction: function EBPDTXN_undoTransaction()
+{
+PlacesUtils.setPostDataForBookmark(this.item.id, this.item.postData);
+}
+};
+/**
+* Transaction for editing an item's date added property.
+*
+* @param aItemId
+*        id of the item to edit
+* @param aNewDateAdded
+*        new date added for the item
+*
+* @return nsITransaction object
+*/
+this.PlacesEditItemDateAddedTransaction =
+function PlacesEditItemDateAddedTransaction(aItemId, aNewDateAdded)
+{
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.new = new TransactionItemCache();
+this.new.dateAdded = aNewDateAdded;
+}
+PlacesEditItemDateAddedTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function EIDATXN_doTransaction()
+{
+// Child transactions have the id set as parentId.
+if (this.item.id == -1 && this.item.parentId != -1)
+this.item.id = this.item.parentId;
+this.item.dateAdded =
+PlacesUtils.bookmarks.getItemDateAdded(this.item.id);
+PlacesUtils.bookmarks.setItemDateAdded(this.item.id, this.new.dateAdded);
+},
+undoTransaction: function EIDATXN_undoTransaction()
+{
+PlacesUtils.bookmarks.setItemDateAdded(this.item.id, this.item.dateAdded);
+}
+};
+/**
+* Transaction for editing an item's last modified time.
+*
+* @param aItemId
+*        id of the item to edit
+* @param aNewLastModified
+*        new last modified date for the item
+*
+* @return nsITransaction object
+*/
+this.PlacesEditItemLastModifiedTransaction =
+function PlacesEditItemLastModifiedTransaction(aItemId, aNewLastModified)
+{
+this.item = new TransactionItemCache();
+this.item.id = aItemId;
+this.new = new TransactionItemCache();
+this.new.lastModified = aNewLastModified;
+}
+PlacesEditItemLastModifiedTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction:
+function EILMTXN_doTransaction()
+{
+// Child transactions have the id set as parentId.
+if (this.item.id == -1 && this.item.parentId != -1)
+this.item.id = this.item.parentId;
+this.item.lastModified =
+PlacesUtils.bookmarks.getItemLastModified(this.item.id);
+PlacesUtils.bookmarks.setItemLastModified(this.item.id,
+this.new.lastModified);
+},
+undoTransaction:
+function EILMTXN_undoTransaction()
+{
+PlacesUtils.bookmarks.setItemLastModified(this.item.id,
+this.item.lastModified);
+}
+};
+/**
+* Transaction for sorting a folder by name
+*
+* @param aFolderId
+*        id of the folder to sort
+*
+* @return nsITransaction object
+*/
+this.PlacesSortFolderByNameTransaction =
+function PlacesSortFolderByNameTransaction(aFolderId)
+{
+this.item = new TransactionItemCache();
+this.item.id = aFolderId;
+}
+PlacesSortFolderByNameTransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function SFBNTXN_doTransaction()
+{
+this._oldOrder = [];
+let contents =
+PlacesUtils.getFolderContents(this.item.id, false, false).root;
+let count = contents.childCount;
+// sort between separators
+let newOrder = [];
+let preSep = []; // temporary array for sorting each group of items
+let sortingMethod =
+function (a, b) {
+if (PlacesUtils.nodeIsContainer(a) && !PlacesUtils.nodeIsContainer(b))
+return -1;
+if (!PlacesUtils.nodeIsContainer(a) && PlacesUtils.nodeIsContainer(b))
+return 1;
+return a.title.localeCompare(b.title);
+};
+for (let i = 0; i < count; ++i) {
+let item = contents.getChild(i);
+this._oldOrder[item.itemId] = i;
+if (PlacesUtils.nodeIsSeparator(item)) {
+if (preSep.length > 0) {
+preSep.sort(sortingMethod);
+newOrder = newOrder.concat(preSep);
+preSep.splice(0, preSep.length);
+}
+newOrder.push(item);
+}
+else
+preSep.push(item);
+}
+contents.containerOpen = false;
+if (preSep.length > 0) {
+preSep.sort(sortingMethod);
+newOrder = newOrder.concat(preSep);
+}
+// set the nex indexes
+let callback = {
+runBatched: function() {
+for (let i = 0; i < newOrder.length; ++i) {
+PlacesUtils.bookmarks.setItemIndex(newOrder[i].itemId, i);
+}
+}
+};
+PlacesUtils.bookmarks.runInBatchMode(callback, null);
+},
+undoTransaction: function SFBNTXN_undoTransaction()
+{
+let callback = {
+_self: this,
+runBatched: function() {
+for (item in this._self._oldOrder)
+PlacesUtils.bookmarks.setItemIndex(item, this._self._oldOrder[item]);
+}
+};
+PlacesUtils.bookmarks.runInBatchMode(callback, null);
+}
+};
+/**
+* Transaction for tagging a URL with the given set of tags. Current tags set
+* for the URL persist. It's the caller's job to check whether or not aURI
+* was already tagged by any of the tags in aTags, undoing this tags
+* transaction removes them all from aURL!
+*
+* @param aURI
+*        the URL to tag.
+* @param aTags
+*        Array of tags to set for the given URL.
+*/
+this.PlacesTagURITransaction =
+function PlacesTagURITransaction(aURI, aTags)
+{
+this.item = new TransactionItemCache();
+this.item.uri = aURI;
+this.item.tags = aTags;
+}
+PlacesTagURITransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function TUTXN_doTransaction()
+{
+if (PlacesUtils.getMostRecentBookmarkForURI(this.item.uri) == -1) {
+// There is no bookmark for this uri, but we only allow to tag bookmarks.
+// Force an unfiled bookmark first.
+this.item.id =
+PlacesUtils.bookmarks
+.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+this.item.uri,
+PlacesUtils.bookmarks.DEFAULT_INDEX,
+PlacesUtils.history.getPageTitle(this.item.uri));
+}
+PlacesUtils.tagging.tagURI(this.item.uri, this.item.tags);
+},
+undoTransaction: function TUTXN_undoTransaction()
+{
+if (this.item.id != -1) {
+PlacesUtils.bookmarks.removeItem(this.item.id);
+this.item.id = -1;
+}
+PlacesUtils.tagging.untagURI(this.item.uri, this.item.tags);
+}
+};
+/**
+* Transaction for removing tags from a URL. It's the caller's job to check
+* whether or not aURI isn't tagged by any of the tags in aTags, undoing this
+* tags transaction adds them all to aURL!
+*
+* @param aURI
+*        the URL to un-tag.
+* @param aTags
+*        Array of tags to unset. pass null to remove all tags from the given
+*        url.
+*/
+this.PlacesUntagURITransaction =
+function PlacesUntagURITransaction(aURI, aTags)
+{
+this.item = new TransactionItemCache();
+this.item.uri = aURI;
+if (aTags) {
+// Within this transaction, we cannot rely on tags given by itemId
+// since the tag containers may be gone after we call untagURI.
+// Thus, we convert each tag given by its itemId to name.
+let tags = [];
+for (let i = 0; i < aTags.length; ++i) {
+if (typeof(aTags[i]) == "number")
+tags.push(PlacesUtils.bookmarks.getItemTitle(aTags[i]));
+else
+tags.push(aTags[i]);
+}
+this.item.tags = tags;
+}
+}
+PlacesUntagURITransaction.prototype = {
+__proto__: BaseTransaction.prototype,
+doTransaction: function UTUTXN_doTransaction()
+{
+// Filter tags existing on the bookmark, otherwise on undo we may try to
+// set nonexistent tags.
+let tags = PlacesUtils.tagging.getTagsForURI(this.item.uri);
+this.item.tags = this.item.tags.filter(function (aTag) {
+return tags.indexOf(aTag) != -1;
+});
+PlacesUtils.tagging.untagURI(this.item.uri, this.item.tags);
+},
+undoTransaction: function UTUTXN_undoTransaction()
+{
+PlacesUtils.tagging.tagURI(this.item.uri, this.item.tags);
+}
+};

The Tor Browser / file comparison

comparison: toolkit/components/places/PlacesUtils.jsm

toolkit/components/places/PlacesUtils.jsm