Add m-esr52 at 52.6.0

405 files changed, 49179 insertions, 0 deletions

diff --git a/toolkit/components/places/tests/.eslintrc.js b/toolkit/components/places/tests/.eslintrc.js
new file mode 100644
index 000000000..d5283c966
--- /dev/null
+++ b/toolkit/components/places/tests/.eslintrc.js
@@ -0,0 +1,9 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../testing/mochitest/mochitest.eslintrc.js",
+    "../../../../testing/mochitest/chrome.eslintrc.js",
+    "../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/PlacesTestUtils.jsm b/toolkit/components/places/tests/PlacesTestUtils.jsm
new file mode 100644
index 000000000..36e425cae
--- /dev/null
+++ b/toolkit/components/places/tests/PlacesTestUtils.jsm
@@ -0,0 +1,163 @@
+"use strict";
+
+this.EXPORTED_SYMBOLS = [
+  "PlacesTestUtils",
+];
+
+const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.importGlobalProperties(["URL"]);
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+                                  "resource://gre/modules/Task.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",
+                                  "resource://gre/modules/PlacesUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+                                  "resource://gre/modules/NetUtil.jsm");
+
+this.PlacesTestUtils = Object.freeze({
+  /**
+   * Asynchronously adds visits to a page.
+   *
+   * @param aPlaceInfo
+   *        Can be an nsIURI, in such a case a single LINK visit will be added.
+   *        Otherwise can be an object describing the visit to add, or an array
+   *        of these objects:
+   *          { uri: nsIURI of the page,
+   *            [optional] transition: one of the TRANSITION_* from nsINavHistoryService,
+   *            [optional] title: title of the page,
+   *            [optional] visitDate: visit date, either in microseconds from the epoch or as a date object
+   *            [optional] referrer: nsIURI of the referrer for this visit
+   *          }
+   *
+   * @return {Promise}
+   * @resolves When all visits have been added successfully.
+   * @rejects JavaScript exception.
+   */
+  addVisits: Task.async(function* (placeInfo) {
+    let places = [];
+    let infos = [];
+
+    if (placeInfo instanceof Ci.nsIURI ||
+        placeInfo instanceof URL ||
+        typeof placeInfo == "string") {
+      places.push({ uri: placeInfo });
+    }
+    else if (Array.isArray(placeInfo)) {
+      places = places.concat(placeInfo);
+    } else if (typeof placeInfo == "object" && placeInfo.uri) {
+      places.push(placeInfo)
+    } else {
+      throw new Error("Unsupported type passed to addVisits");
+    }
+
+    // Create a PageInfo for each entry.
+    for (let place of places) {
+      let info = {url: place.uri};
+      info.title = (typeof place.title === "string") ? place.title : "test visit for " + info.url.spec ;
+      if (typeof place.referrer == "string") {
+        place.referrer = NetUtil.newURI(place.referrer);
+      } else if (place.referrer && place.referrer instanceof URL) {
+        place.referrer = NetUtil.newURI(place.referrer.href);
+      }
+      let visitDate = place.visitDate;
+      if (visitDate) {
+        if (!(visitDate instanceof Date)) {
+          visitDate = PlacesUtils.toDate(visitDate);
+        }
+      } else {
+        visitDate = new Date();
+      }
+      info.visits = [{
+        transition: place.transition,
+        date: visitDate,
+        referrer: place.referrer
+      }];
+      infos.push(info);
+    }
+    return PlacesUtils.history.insertMany(infos);
+  }),
+
+  /**
+   * Clear all history.
+   *
+   * @return {Promise}
+   * @resolves When history was cleared successfully.
+   * @rejects JavaScript exception.
+   */
+  clearHistory() {
+    let expirationFinished = new Promise(resolve => {
+      Services.obs.addObserver(function observe(subj, topic, data) {
+        Services.obs.removeObserver(observe, topic);
+        resolve();
+      }, PlacesUtils.TOPIC_EXPIRATION_FINISHED, false);
+    });
+
+    return Promise.all([expirationFinished, PlacesUtils.history.clear()]);
+  },
+
+  /**
+   * Waits for all pending async statements on the default connection.
+   *
+   * @return {Promise}
+   * @resolves When all pending async statements finished.
+   * @rejects Never.
+   *
+   * @note The result is achieved by asynchronously executing a query requiring
+   *       a write lock.  Since all statements on the same connection are
+   *       serialized, the end of this write operation means that all writes are
+   *       complete.  Note that WAL makes so that writers don't block readers, but
+   *       this is a problem only across different connections.
+   */
+  promiseAsyncUpdates() {
+    return PlacesUtils.withConnectionWrapper("promiseAsyncUpdates", Task.async(function* (db) {
+      try {
+        yield db.executeCached("BEGIN EXCLUSIVE");
+        yield db.executeCached("COMMIT");
+      } catch (ex) {
+        // If we fail to start a transaction, it's because there is already one.
+        // In such a case we should not try to commit the existing transaction.
+      }
+    }));
+  },
+
+  /**
+   * Asynchronously checks if an address is found in the database.
+   * @param aURI
+   *        nsIURI or address to look for.
+   *
+   * @return {Promise}
+   * @resolves Returns true if the page is found.
+   * @rejects JavaScript exception.
+   */
+  isPageInDB: Task.async(function* (aURI) {
+    let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
+    let db = yield PlacesUtils.promiseDBConnection();
+    let rows = yield db.executeCached(
+      "SELECT id FROM moz_places WHERE url_hash = hash(:url) AND url = :url",
+      { url });
+    return rows.length > 0;
+  }),
+
+  /**
+   * Asynchronously checks how many visits exist for a specified page.
+   * @param aURI
+   *        nsIURI or address to look for.
+   *
+   * @return {Promise}
+   * @resolves Returns the number of visits found.
+   * @rejects JavaScript exception.
+   */
+  visitsInDB: Task.async(function* (aURI) {
+    let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
+    let db = yield PlacesUtils.promiseDBConnection();
+    let rows = yield db.executeCached(
+      `SELECT count(*) FROM moz_historyvisits v
+       JOIN moz_places h ON h.id = v.place_id
+       WHERE url_hash = hash(:url) AND url = :url`,
+      { url });
+    return rows[0].getResultByIndex(0);
+  })
+});
diff --git a/toolkit/components/places/tests/bookmarks/.eslintrc.js b/toolkit/components/places/tests/bookmarks/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/bookmarks/head_bookmarks.js b/toolkit/components/places/tests/bookmarks/head_bookmarks.js
new file mode 100644
index 000000000..842a66b31
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/head_bookmarks.js
@@ -0,0 +1,20 @@
+/* -*- 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/. */
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+// Import common head.
+{
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
+
+// Put any other stuff relative to this test folder below.
diff --git a/toolkit/components/places/tests/bookmarks/test_1016953-renaming-uncompressed.js b/toolkit/components/places/tests/bookmarks/test_1016953-renaming-uncompressed.js
new file mode 100644
index 000000000..b6982987b
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_1016953-renaming-uncompressed.js
@@ -0,0 +1,103 @@
+function run_test() {
+  run_next_test();
+}
+
+/* Bug 1016953 - When a previous bookmark backup exists with the same hash
+regardless of date, an automatic backup should attempt to either rename it to
+today's date if the backup was for an old date or leave it alone if it was for
+the same date. However if the file ext was json it will accidentally rename it
+to jsonlz4 while keeping the json contents
+*/
+
+add_task(function* test_same_date_same_hash() {
+  // If old file has been created on the same date and has the same hash
+  // the file should be left alone
+  let backupFolder = yield PlacesBackups.getBackupFolder();
+  // Save to profile dir to obtain hash and nodeCount to append to filename
+  let tempPath = OS.Path.join(OS.Constants.Path.profileDir,
+                              "bug10169583_bookmarks.json");
+  let {count, hash} = yield BookmarkJSONUtils.exportToFile(tempPath);
+
+  // Save JSON file in backup folder with hash appended
+  let dateObj = new Date();
+  let filename = "bookmarks-" + PlacesBackups.toISODateString(dateObj) + "_" +
+                  count + "_" + hash + ".json";
+  let backupFile = OS.Path.join(backupFolder, filename);
+  yield OS.File.move(tempPath, backupFile);
+
+  // Force a compressed backup which fallbacks to rename
+  yield PlacesBackups.create();
+  let mostRecentBackupFile = yield PlacesBackups.getMostRecentBackup();
+  // check to ensure not renamed to jsonlz4
+  Assert.equal(mostRecentBackupFile, backupFile);
+  // inspect contents and check if valid json
+  let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
+                        createInstance(Ci.nsIScriptableUnicodeConverter);
+  converter.charset = "UTF-8";
+  let result = yield OS.File.read(mostRecentBackupFile);
+  let jsonString = converter.convertFromByteArray(result, result.length);
+  do_print("Check is valid JSON");
+  JSON.parse(jsonString);
+
+  // Cleanup
+  yield OS.File.remove(backupFile);
+  yield OS.File.remove(tempPath);
+  PlacesBackups._backupFiles = null; // To force re-cache of backupFiles
+});
+
+add_task(function* test_same_date_diff_hash() {
+  // If the old file has been created on the same date, but has a different hash
+  // the existing file should be overwritten with the newer compressed version
+  let backupFolder = yield PlacesBackups.getBackupFolder();
+  let tempPath = OS.Path.join(OS.Constants.Path.profileDir,
+                              "bug10169583_bookmarks.json");
+  let {count} = yield BookmarkJSONUtils.exportToFile(tempPath);
+  let dateObj = new Date();
+  let filename = "bookmarks-" + PlacesBackups.toISODateString(dateObj) + "_" +
+                  count + "_" + "differentHash==" + ".json";
+  let backupFile = OS.Path.join(backupFolder, filename);
+  yield OS.File.move(tempPath, backupFile);
+  yield PlacesBackups.create(); // Force compressed backup
+  mostRecentBackupFile = yield PlacesBackups.getMostRecentBackup();
+
+  // Decode lz4 compressed file to json and check if json is valid
+  let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
+                        createInstance(Ci.nsIScriptableUnicodeConverter);
+  converter.charset = "UTF-8";
+  let result = yield OS.File.read(mostRecentBackupFile, { compression: "lz4" });
+  let jsonString = converter.convertFromByteArray(result, result.length);
+  do_print("Check is valid JSON");
+  JSON.parse(jsonString);
+
+  // Cleanup
+  yield OS.File.remove(mostRecentBackupFile);
+  yield OS.File.remove(tempPath);
+  PlacesBackups._backupFiles = null; // To force re-cache of backupFiles
+});
+
+add_task(function* test_diff_date_same_hash() {
+  // If the old file has been created on an older day but has the same hash
+  // it should be renamed with today's date without altering the contents.
+  let backupFolder = yield PlacesBackups.getBackupFolder();
+  let tempPath = OS.Path.join(OS.Constants.Path.profileDir,
+                              "bug10169583_bookmarks.json");
+  let {count, hash} = yield BookmarkJSONUtils.exportToFile(tempPath);
+  let oldDate = new Date(2014, 1, 1);
+  let curDate = new Date();
+  let oldFilename = "bookmarks-" + PlacesBackups.toISODateString(oldDate) + "_" +
+                  count + "_" + hash + ".json";
+  let newFilename = "bookmarks-" + PlacesBackups.toISODateString(curDate) + "_" +
+                  count + "_" + hash + ".json";
+  let backupFile = OS.Path.join(backupFolder, oldFilename);
+  let newBackupFile = OS.Path.join(backupFolder, newFilename);
+  yield OS.File.move(tempPath, backupFile);
+
+  // Ensure file has been renamed correctly
+  yield PlacesBackups.create();
+  let mostRecentBackupFile = yield PlacesBackups.getMostRecentBackup();
+  Assert.equal(mostRecentBackupFile, newBackupFile);
+
+  // Cleanup
+  yield OS.File.remove(mostRecentBackupFile);
+  yield OS.File.remove(tempPath);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_1017502-bookmarks_foreign_count.js b/toolkit/components/places/tests/bookmarks/test_1017502-bookmarks_foreign_count.js
new file mode 100644
index 000000000..13755e576
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_1017502-bookmarks_foreign_count.js
@@ -0,0 +1,112 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/* Bug 1017502 - Add a foreign_count column to moz_places
+This tests, tests the triggers that adjust the foreign_count when a bookmark is
+added or removed and also the maintenance task to fix wrong counts.
+*/
+
+const T_URI = NetUtil.newURI("https://www.mozilla.org/firefox/nightly/firstrun/");
+
+function* getForeignCountForURL(conn, url) {
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  url = url instanceof Ci.nsIURI ? url.spec : url;
+  let rows = yield conn.executeCached(
+    `SELECT foreign_count FROM moz_places WHERE url_hash = hash(:t_url)
+                                            AND url = :t_url`, { t_url: url });
+  return rows[0].getResultByName("foreign_count");
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* add_remove_change_bookmark_test() {
+  let conn = yield PlacesUtils.promiseDBConnection();
+
+  // Simulate a visit to the url
+  yield PlacesTestUtils.addVisits(T_URI);
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 0);
+
+  // Add 1st bookmark which should increment foreign_count by 1
+  let id1 = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                    T_URI, PlacesUtils.bookmarks.DEFAULT_INDEX, "First Run");
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 1);
+
+  // Add 2nd bookmark
+  let id2 = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.bookmarksMenuFolderId,
+                      T_URI, PlacesUtils.bookmarks.DEFAULT_INDEX, "First Run");
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 2);
+
+  // Remove 2nd bookmark which should decrement foreign_count by 1
+  PlacesUtils.bookmarks.removeItem(id2);
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 1);
+
+  // Change first bookmark's URI
+  const URI2 = NetUtil.newURI("http://www.mozilla.org");
+  PlacesUtils.bookmarks.changeBookmarkURI(id1, URI2);
+  // Check foreign count for original URI
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 0);
+  // Check foreign count for new URI
+  Assert.equal((yield getForeignCountForURL(conn, URI2)), 1);
+
+  // Cleanup - Remove changed bookmark
+  let id = PlacesUtils.bookmarks.getBookmarkIdsForURI(URI2);
+  PlacesUtils.bookmarks.removeItem(id);
+  Assert.equal((yield getForeignCountForURL(conn, URI2)), 0);
+
+});
+
+add_task(function* maintenance_foreign_count_test() {
+  let conn = yield PlacesUtils.promiseDBConnection();
+
+  // Simulate a visit to the url
+  yield PlacesTestUtils.addVisits(T_URI);
+
+  // Adjust the foreign_count for the added entry to an incorrect value
+  let deferred = Promise.defer();
+  let stmt = DBConn().createAsyncStatement(
+    `UPDATE moz_places SET foreign_count = 10 WHERE url_hash = hash(:t_url)
+                                                AND url = :t_url `);
+  stmt.params.t_url = T_URI.spec;
+  stmt.executeAsync({
+    handleCompletion: function() {
+      deferred.resolve();
+    }
+  });
+  stmt.finalize();
+  yield deferred.promise;
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 10);
+
+  // Run maintenance
+  Components.utils.import("resource://gre/modules/PlacesDBUtils.jsm");
+  let promiseMaintenanceFinished =
+    promiseTopicObserved("places-maintenance-finished");
+  PlacesDBUtils.maintenanceOnIdle();
+  yield promiseMaintenanceFinished;
+
+  // Check if the foreign_count has been adjusted to the correct value
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 0);
+});
+
+add_task(function* add_remove_tags_test() {
+  let conn = yield PlacesUtils.promiseDBConnection();
+
+  yield PlacesTestUtils.addVisits(T_URI);
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 0);
+
+  // Check foreign count incremented by 1 for a single tag
+  PlacesUtils.tagging.tagURI(T_URI, ["test tag"]);
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 1);
+
+  // Check foreign count is incremented by 2 for two tags
+  PlacesUtils.tagging.tagURI(T_URI, ["one", "two"]);
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 3);
+
+  // Check foreign count is set to 0 when all tags are removed
+  PlacesUtils.tagging.untagURI(T_URI, ["test tag", "one", "two"]);
+  Assert.equal((yield getForeignCountForURL(conn, T_URI)), 0);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_1129529.js b/toolkit/components/places/tests/bookmarks/test_1129529.js
new file mode 100644
index 000000000..da1ff708f
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_1129529.js
@@ -0,0 +1,76 @@
+var now = Date.now() * 1000;
+
+// Test that importing bookmark data where a bookmark has a tag longer than 100
+// chars imports everything except the tags for that bookmark.
+add_task(function* () {
+  let aData = {
+    guid: "root________",
+    index: 0,
+    id: 1,
+    type: "text/x-moz-place-container",
+    dateAdded: now,
+    lastModified: now,
+    root: "placesRoot",
+    children: [{
+      guid: "unfiled_____",
+      index: 0,
+      id: 2,
+      type: "text/x-moz-place-container",
+      dateAdded: now,
+      lastModified: now,
+      root: "unfiledBookmarksFolder",
+      children: [
+        {
+          guid: "___guid1____",
+          index: 0,
+          id: 3,
+          charset: "UTF-8",
+          tags: "tag0",
+          type: "text/x-moz-place",
+          dateAdded: now,
+          lastModified: now,
+          uri: "http://test0.com/"
+        },
+        {
+          guid: "___guid2____",
+          index: 1,
+          id: 4,
+          charset: "UTF-8",
+          tags: "tag1," + "a" + "0123456789".repeat(10), // 101 chars
+          type: "text/x-moz-place",
+          dateAdded: now,
+          lastModified: now,
+          uri: "http://test1.com/"
+        },
+        {
+          guid: "___guid3____",
+          index: 2,
+          id: 5,
+          charset: "UTF-8",
+          tags: "tag2",
+          type: "text/x-moz-place",
+          dateAdded: now,
+          lastModified: now,
+          uri: "http://test2.com/"
+        }
+      ]
+    }]
+  };
+
+  let contentType = "application/json";
+  let uri = "data:" + contentType + "," + JSON.stringify(aData);
+  yield BookmarkJSONUtils.importFromURL(uri, false);
+
+  let [bookmarks] = yield PlacesBackups.getBookmarksTree();
+  let unsortedBookmarks = bookmarks.children[2].children;
+  Assert.equal(unsortedBookmarks.length, 3);
+
+  for (let i = 0; i < unsortedBookmarks.length; ++i) {
+    let bookmark = unsortedBookmarks[i];
+    Assert.equal(bookmark.charset, "UTF-8");
+    Assert.equal(bookmark.dateAdded, now);
+    Assert.equal(bookmark.lastModified, now);
+    Assert.equal(bookmark.uri, "http://test" + i + ".com/");
+    Assert.equal(bookmark.tags, "tag" + i);
+  }
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_384228.js b/toolkit/components/places/tests/bookmarks/test_384228.js
new file mode 100644
index 000000000..9a52c9746
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_384228.js
@@ -0,0 +1,98 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * test querying for bookmarks in multiple folders.
+ */
+add_task(function* search_bookmark_in_folder() {
+  let testFolder1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: "bug 384228 test folder 1"
+  });
+  Assert.equal(testFolder1.index, 0);
+
+  let testFolder2 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: "bug 384228 test folder 2"
+  });
+  Assert.equal(testFolder2.index, 1);
+
+  let testFolder3 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: "bug 384228 test folder 3"
+  });
+  Assert.equal(testFolder3.index, 2);
+
+  let b1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: testFolder1.guid,
+    url: "http://foo.tld/",
+    title: "title b1 (folder 1)"
+  });
+  Assert.equal(b1.index, 0);
+
+  let b2 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: testFolder1.guid,
+    url: "http://foo.tld/",
+    title: "title b2 (folder 1)"
+  });
+  Assert.equal(b2.index, 1);
+
+  let b3 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: testFolder2.guid,
+    url: "http://foo.tld/",
+    title: "title b3 (folder 2)"
+  });
+  Assert.equal(b3.index, 0);
+
+  let b4 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: testFolder3.guid,
+    url: "http://foo.tld/",
+    title: "title b4 (folder 3)"
+  });
+  Assert.equal(b4.index, 0);
+
+  // also test recursive search
+  let testFolder1_1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: testFolder1.guid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: "bug 384228 test folder 1.1"
+  });
+  Assert.equal(testFolder1_1.index, 2);
+
+  let b5 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: testFolder1_1.guid,
+    url: "http://foo.tld/",
+    title: "title b5 (folder 1.1)"
+  });
+  Assert.equal(b5.index, 0);
+
+
+  // query folder 1, folder 2 and get 4 bookmarks
+  let folderIds = [];
+  folderIds.push(yield PlacesUtils.promiseItemId(testFolder1.guid));
+  folderIds.push(yield PlacesUtils.promiseItemId(testFolder2.guid));
+
+  let hs = PlacesUtils.history;
+  let options = hs.getNewQueryOptions();
+  let query = hs.getNewQuery();
+  query.searchTerms = "title";
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  query.setFolders(folderIds, folderIds.length);
+  let rootNode = hs.executeQuery(query, options).root;
+  rootNode.containerOpen = true;
+
+  // should not match item from folder 3
+  Assert.equal(rootNode.childCount, 4);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b1.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b2.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b3.guid);
+  Assert.equal(rootNode.getChild(3).bookmarkGuid, b5.guid);
+
+  rootNode.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_385829.js b/toolkit/components/places/tests/bookmarks/test_385829.js
new file mode 100644
index 000000000..63beee5f3
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_385829.js
@@ -0,0 +1,182 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+add_task(function* search_bookmark_by_lastModified_dateDated() {
+  // test search on folder with various sorts and max results
+  // see bug #385829 for more details
+  let folder = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: "bug 385829 test"
+  });
+
+  let now = new Date();
+  // ensure some unique values for date added and last modified
+  // for date added:    b1 < b2 < b3 < b4
+  // for last modified: b1 > b2 > b3 > b4
+  let b1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: folder.guid,
+    url: "http://a1.com/",
+    title: "1 title",
+    dateAdded: new Date(now.getTime() + 1000)
+  });
+  let b2 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: folder.guid,
+    url: "http://a2.com/",
+    title: "2 title",
+    dateAdded: new Date(now.getTime() + 2000)
+  });
+  let b3 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: folder.guid,
+    url: "http://a3.com/",
+    title: "3 title",
+    dateAdded: new Date(now.getTime() + 3000)
+  });
+  let b4 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: folder.guid,
+    url: "http://a4.com/",
+    title: "4 title",
+    dateAdded: new Date(now.getTime() + 4000)
+  });
+
+  // make sure lastModified is larger than dateAdded
+  let modifiedTime = new Date(now.getTime() + 5000);
+  yield PlacesUtils.bookmarks.update({
+    guid: b1.guid,
+    lastModified: new Date(modifiedTime.getTime() + 4000)
+  });
+  yield PlacesUtils.bookmarks.update({
+    guid: b2.guid,
+    lastModified: new Date(modifiedTime.getTime() + 3000)
+  });
+  yield PlacesUtils.bookmarks.update({
+    guid: b3.guid,
+    lastModified: new Date(modifiedTime.getTime() + 2000)
+  });
+  yield PlacesUtils.bookmarks.update({
+    guid: b4.guid,
+    lastModified: new Date(modifiedTime.getTime() + 1000)
+  });
+
+  let hs = PlacesUtils.history;
+  let options = hs.getNewQueryOptions();
+  let query = hs.getNewQuery();
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  options.maxResults = 3;
+  let folderIds = [];
+  folderIds.push(yield PlacesUtils.promiseItemId(folder.guid));
+  query.setFolders(folderIds, 1);
+
+  let result = hs.executeQuery(query, options);
+  let rootNode = result.root;
+  rootNode.containerOpen = true;
+
+  // test SORT_BY_DATEADDED_ASCENDING (live update)
+  result.sortingMode = options.SORT_BY_DATEADDED_ASCENDING;
+  Assert.equal(rootNode.childCount, 3);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b1.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b2.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b3.guid);
+  Assert.ok(rootNode.getChild(0).dateAdded <
+                rootNode.getChild(1).dateAdded);
+  Assert.ok(rootNode.getChild(1).dateAdded <
+                rootNode.getChild(2).dateAdded);
+
+  // test SORT_BY_DATEADDED_DESCENDING (live update)
+  result.sortingMode = options.SORT_BY_DATEADDED_DESCENDING;
+  Assert.equal(rootNode.childCount, 3);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b3.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b2.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b1.guid);
+  Assert.ok(rootNode.getChild(0).dateAdded >
+                rootNode.getChild(1).dateAdded);
+  Assert.ok(rootNode.getChild(1).dateAdded >
+                rootNode.getChild(2).dateAdded);
+
+  // test SORT_BY_LASTMODIFIED_ASCENDING (live update)
+  result.sortingMode = options.SORT_BY_LASTMODIFIED_ASCENDING;
+  Assert.equal(rootNode.childCount, 3);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b3.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b2.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b1.guid);
+  Assert.ok(rootNode.getChild(0).lastModified <
+                rootNode.getChild(1).lastModified);
+  Assert.ok(rootNode.getChild(1).lastModified <
+                rootNode.getChild(2).lastModified);
+
+  // test SORT_BY_LASTMODIFIED_DESCENDING (live update)
+  result.sortingMode = options.SORT_BY_LASTMODIFIED_DESCENDING;
+
+  Assert.equal(rootNode.childCount, 3);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b1.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b2.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b3.guid);
+  Assert.ok(rootNode.getChild(0).lastModified >
+                rootNode.getChild(1).lastModified);
+  Assert.ok(rootNode.getChild(1).lastModified >
+                rootNode.getChild(2).lastModified);
+  rootNode.containerOpen = false;
+
+  // test SORT_BY_DATEADDED_ASCENDING
+  options.sortingMode = options.SORT_BY_DATEADDED_ASCENDING;
+  result = hs.executeQuery(query, options);
+  rootNode = result.root;
+  rootNode.containerOpen = true;
+  Assert.equal(rootNode.childCount, 3);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b1.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b2.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b3.guid);
+  Assert.ok(rootNode.getChild(0).dateAdded <
+                rootNode.getChild(1).dateAdded);
+  Assert.ok(rootNode.getChild(1).dateAdded <
+                rootNode.getChild(2).dateAdded);
+  rootNode.containerOpen = false;
+
+  // test SORT_BY_DATEADDED_DESCENDING
+  options.sortingMode = options.SORT_BY_DATEADDED_DESCENDING;
+  result = hs.executeQuery(query, options);
+  rootNode = result.root;
+  rootNode.containerOpen = true;
+  Assert.equal(rootNode.childCount, 3);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b4.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b3.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b2.guid);
+  Assert.ok(rootNode.getChild(0).dateAdded >
+                rootNode.getChild(1).dateAdded);
+  Assert.ok(rootNode.getChild(1).dateAdded >
+                rootNode.getChild(2).dateAdded);
+  rootNode.containerOpen = false;
+
+  // test SORT_BY_LASTMODIFIED_ASCENDING
+  options.sortingMode = options.SORT_BY_LASTMODIFIED_ASCENDING;
+  result = hs.executeQuery(query, options);
+  rootNode = result.root;
+  rootNode.containerOpen = true;
+  Assert.equal(rootNode.childCount, 3);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b4.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b3.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b2.guid);
+  Assert.ok(rootNode.getChild(0).lastModified <
+                rootNode.getChild(1).lastModified);
+  Assert.ok(rootNode.getChild(1).lastModified <
+                rootNode.getChild(2).lastModified);
+  rootNode.containerOpen = false;
+
+  // test SORT_BY_LASTMODIFIED_DESCENDING
+  options.sortingMode = options.SORT_BY_LASTMODIFIED_DESCENDING;
+  result = hs.executeQuery(query, options);
+  rootNode = result.root;
+  rootNode.containerOpen = true;
+  Assert.equal(rootNode.childCount, 3);
+  Assert.equal(rootNode.getChild(0).bookmarkGuid, b1.guid);
+  Assert.equal(rootNode.getChild(1).bookmarkGuid, b2.guid);
+  Assert.equal(rootNode.getChild(2).bookmarkGuid, b3.guid);
+  Assert.ok(rootNode.getChild(0).lastModified >
+                rootNode.getChild(1).lastModified);
+  Assert.ok(rootNode.getChild(1).lastModified >
+                rootNode.getChild(2).lastModified);
+  rootNode.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_388695.js b/toolkit/components/places/tests/bookmarks/test_388695.js
new file mode 100644
index 000000000..4e313c52f
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_388695.js
@@ -0,0 +1,52 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get bookmark service
+try {
+  var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+              getService(Ci.nsINavBookmarksService);
+} catch (ex) {
+  do_throw("Could not get nav-bookmarks-service\n");
+}
+
+var gTestRoot;
+var gURI;
+var gItemId1;
+var gItemId2;
+
+// main
+function run_test() {
+  gURI = uri("http://foo.tld.com/");
+  gTestRoot = bmsvc.createFolder(bmsvc.placesRoot, "test folder",
+                                 bmsvc.DEFAULT_INDEX);
+
+  // test getBookmarkIdsForURI
+  // getBookmarkIdsForURI sorts by the most recently added/modified (descending)
+  //
+  // we cannot rely on dateAdded growing when doing so in a simple iteration,
+  // see PR_Now() documentation
+  do_test_pending();
+
+  gItemId1 = bmsvc.insertBookmark(gTestRoot, gURI, bmsvc.DEFAULT_INDEX, "");
+  do_timeout(100, phase2);
+}
+
+function phase2() {
+  gItemId2 = bmsvc.insertBookmark(gTestRoot, gURI, bmsvc.DEFAULT_INDEX, "");
+  var b = bmsvc.getBookmarkIdsForURI(gURI);
+  do_check_eq(b[0], gItemId2);
+  do_check_eq(b[1], gItemId1);
+  do_timeout(100, phase3);
+}
+
+function phase3() {
+  // trigger last modified change
+  bmsvc.setItemTitle(gItemId1, "");
+  var b = bmsvc.getBookmarkIdsForURI(gURI);
+  do_check_eq(b[0], gItemId1);
+  do_check_eq(b[1], gItemId2);
+  do_test_finished();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_393498.js b/toolkit/components/places/tests/bookmarks/test_393498.js
new file mode 100644
index 000000000..601f77a0a
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_393498.js
@@ -0,0 +1,102 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var observer = {
+  __proto__: NavBookmarkObserver.prototype,
+
+  onItemAdded: function (id, folder, index) {
+    this._itemAddedId = id;
+    this._itemAddedParent = folder;
+    this._itemAddedIndex = index;
+  },
+  onItemChanged: function (id, property, isAnnotationProperty, value) {
+    this._itemChangedId = id;
+    this._itemChangedProperty = property;
+    this._itemChanged_isAnnotationProperty = isAnnotationProperty;
+    this._itemChangedValue = value;
+  }
+};
+PlacesUtils.bookmarks.addObserver(observer, false);
+
+do_register_cleanup(function () {
+  PlacesUtils.bookmarks.removeObserver(observer);
+});
+
+function run_test() {
+  // We set times in the past to workaround a timing bug due to virtual
+  // machines and the skew between PR_Now() and Date.now(), see bug 427142 and
+  // bug 858377 for details.
+  const PAST_PRTIME = (Date.now() - 86400000) * 1000;
+
+  // Insert a new bookmark.
+  let testFolder = PlacesUtils.bookmarks.createFolder(
+    PlacesUtils.placesRootId, "test Folder",
+    PlacesUtils.bookmarks.DEFAULT_INDEX);
+  let bookmarkId = PlacesUtils.bookmarks.insertBookmark(
+    testFolder, uri("http://google.com/"),
+    PlacesUtils.bookmarks.DEFAULT_INDEX, "");
+
+  // Sanity check.
+  do_check_true(observer.itemChangedProperty === undefined);
+
+  // Set dateAdded in the past and verify the bookmarks cache.
+  PlacesUtils.bookmarks.setItemDateAdded(bookmarkId, PAST_PRTIME);
+  do_check_eq(observer._itemChangedProperty, "dateAdded");
+  do_check_eq(observer._itemChangedValue, PAST_PRTIME);
+  let dateAdded = PlacesUtils.bookmarks.getItemDateAdded(bookmarkId);
+  do_check_eq(dateAdded, PAST_PRTIME);
+
+  // After just inserting, modified should be the same as dateAdded.
+  do_check_eq(PlacesUtils.bookmarks.getItemLastModified(bookmarkId), dateAdded);
+
+  // Set lastModified in the past and verify the bookmarks cache.
+  PlacesUtils.bookmarks.setItemLastModified(bookmarkId, PAST_PRTIME);
+  do_check_eq(observer._itemChangedProperty, "lastModified");
+  do_check_eq(observer._itemChangedValue, PAST_PRTIME);
+  do_check_eq(PlacesUtils.bookmarks.getItemLastModified(bookmarkId),
+              PAST_PRTIME);
+
+  // Set bookmark title
+  PlacesUtils.bookmarks.setItemTitle(bookmarkId, "Google");
+
+  // Test notifications.
+  do_check_eq(observer._itemChangedId, bookmarkId);
+  do_check_eq(observer._itemChangedProperty, "title");
+  do_check_eq(observer._itemChangedValue, "Google");
+
+  // Check lastModified has been updated.
+  is_time_ordered(PAST_PRTIME,
+                  PlacesUtils.bookmarks.getItemLastModified(bookmarkId));
+
+  // Check that node properties are updated.
+  let root = PlacesUtils.getFolderContents(testFolder).root;
+  do_check_eq(root.childCount, 1);
+  let childNode = root.getChild(0);
+
+  // confirm current dates match node properties
+  do_check_eq(PlacesUtils.bookmarks.getItemDateAdded(bookmarkId),
+              childNode.dateAdded);
+  do_check_eq(PlacesUtils.bookmarks.getItemLastModified(bookmarkId),
+              childNode.lastModified);
+
+  // Test live update of lastModified when setting title.
+  PlacesUtils.bookmarks.setItemLastModified(bookmarkId, PAST_PRTIME);
+  PlacesUtils.bookmarks.setItemTitle(bookmarkId, "Google");
+
+  // Check lastModified has been updated.
+  is_time_ordered(PAST_PRTIME, childNode.lastModified);
+  // Test that node value matches db value.
+  do_check_eq(PlacesUtils.bookmarks.getItemLastModified(bookmarkId),
+              childNode.lastModified);
+
+  // Test live update of the exposed date apis.
+  PlacesUtils.bookmarks.setItemDateAdded(bookmarkId, PAST_PRTIME);
+  do_check_eq(childNode.dateAdded, PAST_PRTIME);
+  PlacesUtils.bookmarks.setItemLastModified(bookmarkId, PAST_PRTIME);
+  do_check_eq(childNode.lastModified, PAST_PRTIME);
+
+  root.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_395101.js b/toolkit/components/places/tests/bookmarks/test_395101.js
new file mode 100644
index 000000000..a507e7361
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_395101.js
@@ -0,0 +1,87 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get bookmark service
+try {
+  var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].getService(Ci.nsINavBookmarksService);
+} catch (ex) {
+  do_throw("Could not get nav-bookmarks-service\n");
+}
+
+// Get history service
+try {
+  var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].getService(Ci.nsINavHistoryService);
+} catch (ex) {
+  do_throw("Could not get history service\n");
+}
+
+// Get tagging service
+try {
+  var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+                getService(Ci.nsITaggingService);
+} catch (ex) {
+  do_throw("Could not get tagging service\n");
+}
+
+// get bookmarks root id
+var root = bmsvc.bookmarksMenuFolder;
+
+// main
+function run_test() {
+  // test searching for tagged bookmarks
+
+  // test folder
+  var folder = bmsvc.createFolder(root, "bug 395101 test", bmsvc.DEFAULT_INDEX);
+
+  // create a bookmark
+  var testURI = uri("http://a1.com");
+  var b1 = bmsvc.insertBookmark(folder, testURI,
+                                bmsvc.DEFAULT_INDEX, "1 title");
+
+  // tag the bookmarked URI
+  tagssvc.tagURI(testURI, ["elephant", "walrus", "giraffe", "turkey", "hiPPo", "BABOON", "alf"]);
+
+  // search for the bookmark, using a tag
+  var query = histsvc.getNewQuery();
+  query.searchTerms = "elephant";
+  var options = histsvc.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  query.setFolders([folder], 1);
+
+  var result = histsvc.executeQuery(query, options);
+  var rootNode = result.root;
+  rootNode.containerOpen = true;
+
+  do_check_eq(rootNode.childCount, 1);
+  do_check_eq(rootNode.getChild(0).itemId, b1);
+  rootNode.containerOpen = false;
+
+  // partial matches are okay
+  query.searchTerms = "wal";
+  result = histsvc.executeQuery(query, options);
+  rootNode = result.root;
+  rootNode.containerOpen = true;
+  do_check_eq(rootNode.childCount, 1);
+  rootNode.containerOpen = false;
+
+  // case insensitive search term
+  query.searchTerms = "WALRUS";
+  result = histsvc.executeQuery(query, options);
+  rootNode = result.root;
+  rootNode.containerOpen = true;
+  do_check_eq(rootNode.childCount, 1);
+  do_check_eq(rootNode.getChild(0).itemId, b1);
+  rootNode.containerOpen = false;
+
+  // case insensitive tag
+  query.searchTerms = "baboon";
+  result = histsvc.executeQuery(query, options);
+  rootNode = result.root;
+  rootNode.containerOpen = true;
+  do_check_eq(rootNode.childCount, 1);
+  do_check_eq(rootNode.getChild(0).itemId, b1);
+  rootNode.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_395593.js b/toolkit/components/places/tests/bookmarks/test_395593.js
new file mode 100644
index 000000000..46d8f5b80
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_395593.js
@@ -0,0 +1,69 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+
+var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+         getService(Ci.nsINavBookmarksService);
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+
+function check_queries_results(aQueries, aOptions, aExpectedItemIds) {
+  var result = hs.executeQueries(aQueries, aQueries.length, aOptions);
+  var root = result.root;
+  root.containerOpen = true;
+
+  // Dump found nodes.
+  for (let i = 0; i < root.childCount; i++) {
+    dump("nodes[" + i + "]: " + root.getChild(0).title + "\n");
+  }
+
+  do_check_eq(root.childCount, aExpectedItemIds.length);
+  for (let i = 0; i < root.childCount; i++) {
+    do_check_eq(root.getChild(i).itemId, aExpectedItemIds[i]);
+  }
+
+  root.containerOpen = false;
+}
+
+// main
+function run_test() {
+  var id1 = bs.insertBookmark(bs.bookmarksMenuFolder, uri("http://foo.tld"),
+                              bs.DEFAULT_INDEX, "123 0");
+  var id2 = bs.insertBookmark(bs.bookmarksMenuFolder, uri("http://foo.tld"),
+                              bs.DEFAULT_INDEX, "456");
+  var id3 = bs.insertBookmark(bs.bookmarksMenuFolder, uri("http://foo.tld"),
+                              bs.DEFAULT_INDEX, "123 456");
+  var id4 = bs.insertBookmark(bs.bookmarksMenuFolder, uri("http://foo.tld"),
+                              bs.DEFAULT_INDEX, "789 456");
+
+  /**
+   * All of the query objects are ORed together. Within a query, all the terms
+   * are ANDed together. See nsINavHistory.idl.
+   */
+  var queries = [];
+  queries.push(hs.getNewQuery());
+  queries.push(hs.getNewQuery());
+  var options = hs.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+
+  // Test 1
+  dump("Test searching for 123 OR 789\n");
+  queries[0].searchTerms = "123";
+  queries[1].searchTerms = "789";
+  check_queries_results(queries, options, [id1, id3, id4]);
+
+  // Test 2
+  dump("Test searching for 123 OR 456\n");
+  queries[0].searchTerms = "123";
+  queries[1].searchTerms = "456";
+  check_queries_results(queries, options, [id1, id2, id3, id4]);
+
+  // Test 3
+  dump("Test searching for 00 OR 789\n");
+  queries[0].searchTerms = "00";
+  queries[1].searchTerms = "789";
+  check_queries_results(queries, options, [id4]);
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_405938_restore_queries.js b/toolkit/components/places/tests/bookmarks/test_405938_restore_queries.js
new file mode 100644
index 000000000..e317cc2e9
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_405938_restore_queries.js
@@ -0,0 +1,221 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var tests = [];
+
+/*
+
+Backup/restore tests example:
+
+var myTest = {
+  populate: function () { ... add bookmarks ... },
+  validate: function () { ... query for your bookmarks ... }
+}
+
+this.push(myTest);
+
+*/
+
+/*
+
+test summary:
+- create folders with content
+- create a query bookmark for those folders
+- backs up bookmarks
+- restores bookmarks
+- confirms that the query has the new ids for the same folders
+
+scenarios:
+- 1 folder  (folder shortcut)
+- n folders (single query)
+- n folders (multiple queries)
+
+*/
+
+const DEFAULT_INDEX = PlacesUtils.bookmarks.DEFAULT_INDEX;
+
+var test = {
+  _testRootId: null,
+  _testRootTitle: "test root",
+  _folderIds: [],
+  _bookmarkURIs: [],
+  _count: 3,
+
+  populate: function populate() {
+    // folder to hold this test
+    PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.toolbarFolderId);
+    this._testRootId =
+      PlacesUtils.bookmarks.createFolder(PlacesUtils.toolbarFolderId,
+                                         this._testRootTitle, DEFAULT_INDEX);
+
+    // create test folders each with a bookmark
+    for (var i = 0; i < this._count; i++) {
+      var folderId =
+        PlacesUtils.bookmarks.createFolder(this._testRootId, "folder" + i, DEFAULT_INDEX);
+      this._folderIds.push(folderId)
+
+      var bookmarkURI = uri("http://" + i);
+      PlacesUtils.bookmarks.insertBookmark(folderId, bookmarkURI,
+                                           DEFAULT_INDEX, "bookmark" + i);
+      this._bookmarkURIs.push(bookmarkURI);
+    }
+
+    // create a query URI with 1 folder (ie: folder shortcut)
+    this._queryURI1 = uri("place:folder=" + this._folderIds[0] + "&queryType=1");
+    this._queryTitle1 = "query1";
+    PlacesUtils.bookmarks.insertBookmark(this._testRootId, this._queryURI1,
+                                         DEFAULT_INDEX, this._queryTitle1);
+
+    // create a query URI with _count folders
+    this._queryURI2 = uri("place:folder=" + this._folderIds.join("&folder=") + "&queryType=1");
+    this._queryTitle2 = "query2";
+    PlacesUtils.bookmarks.insertBookmark(this._testRootId, this._queryURI2,
+                                         DEFAULT_INDEX, this._queryTitle2);
+
+    // create a query URI with _count queries (each with a folder)
+    // first get a query object for each folder
+    var queries = this._folderIds.map(function(aFolderId) {
+      var query = PlacesUtils.history.getNewQuery();
+      query.setFolders([aFolderId], 1);
+      return query;
+    });
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.queryType = options.QUERY_TYPE_BOOKMARKS;
+    this._queryURI3 =
+      uri(PlacesUtils.history.queriesToQueryString(queries, queries.length, options));
+    this._queryTitle3 = "query3";
+    PlacesUtils.bookmarks.insertBookmark(this._testRootId, this._queryURI3,
+                                         DEFAULT_INDEX, this._queryTitle3);
+  },
+
+  clean: function () {},
+
+  validate: function validate() {
+    // Throw a wrench in the works by inserting some new bookmarks,
+    // ensuring folder ids won't be the same, when restoring.
+    for (let i = 0; i < 10; i++) {
+      PlacesUtils.bookmarks.
+                  insertBookmark(PlacesUtils.bookmarksMenuFolderId, uri("http://aaaa"+i), DEFAULT_INDEX, "");
+    }
+
+    var toolbar =
+      PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId,
+                                    false, true).root;
+    do_check_true(toolbar.childCount, 1);
+
+    var folderNode = toolbar.getChild(0);
+    do_check_eq(folderNode.type, folderNode.RESULT_TYPE_FOLDER);
+    do_check_eq(folderNode.title, this._testRootTitle);
+    folderNode.QueryInterface(Ci.nsINavHistoryQueryResultNode);
+    folderNode.containerOpen = true;
+
+    // |_count| folders + the query node
+    do_check_eq(folderNode.childCount, this._count+3);
+
+    for (let i = 0; i < this._count; i++) {
+      var subFolder = folderNode.getChild(i);
+      do_check_eq(subFolder.title, "folder"+i);
+      subFolder.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+      subFolder.containerOpen = true;
+      do_check_eq(subFolder.childCount, 1);
+      var child = subFolder.getChild(0);
+      do_check_eq(child.title, "bookmark"+i);
+      do_check_true(uri(child.uri).equals(uri("http://" + i)))
+    }
+
+    // validate folder shortcut
+    this.validateQueryNode1(folderNode.getChild(this._count));
+
+    // validate folders query
+    this.validateQueryNode2(folderNode.getChild(this._count + 1));
+
+    // validate multiple queries query
+    this.validateQueryNode3(folderNode.getChild(this._count + 2));
+
+    // clean up
+    folderNode.containerOpen = false;
+    toolbar.containerOpen = false;
+  },
+
+  validateQueryNode1: function validateQueryNode1(aNode) {
+    do_check_eq(aNode.title, this._queryTitle1);
+    do_check_true(PlacesUtils.nodeIsFolder(aNode));
+
+    aNode.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+    aNode.containerOpen = true;
+    do_check_eq(aNode.childCount, 1);
+    var child = aNode.getChild(0);
+    do_check_true(uri(child.uri).equals(uri("http://0")))
+    do_check_eq(child.title, "bookmark0")
+    aNode.containerOpen = false;
+  },
+
+  validateQueryNode2: function validateQueryNode2(aNode) {
+    do_check_eq(aNode.title, this._queryTitle2);
+    do_check_true(PlacesUtils.nodeIsQuery(aNode));
+
+    aNode.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+    aNode.containerOpen = true;
+    do_check_eq(aNode.childCount, this._count);
+    for (var i = 0; i < aNode.childCount; i++) {
+      var child = aNode.getChild(i);
+      do_check_true(uri(child.uri).equals(uri("http://" + i)))
+      do_check_eq(child.title, "bookmark" + i)
+    }
+    aNode.containerOpen = false;
+  },
+
+  validateQueryNode3: function validateQueryNode3(aNode) {
+    do_check_eq(aNode.title, this._queryTitle3);
+    do_check_true(PlacesUtils.nodeIsQuery(aNode));
+
+    aNode.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+    aNode.containerOpen = true;
+    do_check_eq(aNode.childCount, this._count);
+    for (var i = 0; i < aNode.childCount; i++) {
+      var child = aNode.getChild(i);
+      do_check_true(uri(child.uri).equals(uri("http://" + i)))
+      do_check_eq(child.title, "bookmark" + i)
+    }
+    aNode.containerOpen = false;
+  }
+}
+tests.push(test);
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* () {
+  // make json file
+  let jsonFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.json");
+
+  // populate db
+  tests.forEach(function(aTest) {
+    aTest.populate();
+    // sanity
+    aTest.validate();
+  });
+
+  // export json to file
+  yield BookmarkJSONUtils.exportToFile(jsonFile);
+
+  // clean
+  tests.forEach(function(aTest) {
+    aTest.clean();
+  });
+
+  // restore json file
+  yield BookmarkJSONUtils.importFromFile(jsonFile, true);
+
+  // validate
+  tests.forEach(function(aTest) {
+    aTest.validate();
+  });
+
+  // clean up
+  yield OS.File.remove(jsonFile);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_417228-exclude-from-backup.js b/toolkit/components/places/tests/bookmarks/test_417228-exclude-from-backup.js
new file mode 100644
index 000000000..858496856
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_417228-exclude-from-backup.js
@@ -0,0 +1,141 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const EXCLUDE_FROM_BACKUP_ANNO = "places/excludeFromBackup";
+// Menu, Toolbar, Unsorted, Tags, Mobile
+const PLACES_ROOTS_COUNT  = 5;
+var tests = [];
+
+/*
+
+Backup/restore tests example:
+
+var myTest = {
+  populate: function () { ... add bookmarks ... },
+  validate: function () { ... query for your bookmarks ... }
+}
+
+this.push(myTest);
+
+*/
+
+var test = {
+  populate: function populate() {
+    // check initial size
+    var rootNode = PlacesUtils.getFolderContents(PlacesUtils.placesRootId,
+                                                 false, false).root;
+    do_check_eq(rootNode.childCount, PLACES_ROOTS_COUNT );
+    rootNode.containerOpen = false;
+
+    var idx = PlacesUtils.bookmarks.DEFAULT_INDEX;
+
+    // create a root to be restore
+    this._restoreRootTitle = "restore root";
+    var restoreRootId = PlacesUtils.bookmarks
+                                   .createFolder(PlacesUtils.placesRootId,
+                                                 this._restoreRootTitle, idx);
+    // add a test bookmark
+    this._restoreRootURI = uri("http://restore.uri");
+    PlacesUtils.bookmarks.insertBookmark(restoreRootId, this._restoreRootURI,
+                                         idx, "restore uri");
+    // add a test bookmark to be exclude
+    this._restoreRootExcludeURI = uri("http://exclude.uri");
+    var exItemId = PlacesUtils.bookmarks
+                              .insertBookmark(restoreRootId,
+                                              this._restoreRootExcludeURI,
+                                              idx, "exclude uri");
+    // Annotate the bookmark for exclusion.
+    PlacesUtils.annotations.setItemAnnotation(exItemId,
+                                              EXCLUDE_FROM_BACKUP_ANNO, 1, 0,
+                                              PlacesUtils.annotations.EXPIRE_NEVER);
+
+    // create a root to be exclude
+    this._excludeRootTitle = "exclude root";
+    this._excludeRootId = PlacesUtils.bookmarks
+                                     .createFolder(PlacesUtils.placesRootId,
+                                                   this._excludeRootTitle, idx);
+    // Annotate the root for exclusion.
+    PlacesUtils.annotations.setItemAnnotation(this._excludeRootId,
+                                              EXCLUDE_FROM_BACKUP_ANNO, 1, 0,
+                                              PlacesUtils.annotations.EXPIRE_NEVER);
+    // add a test bookmark exclude by exclusion of its parent
+    PlacesUtils.bookmarks.insertBookmark(this._excludeRootId,
+                                         this._restoreRootExcludeURI,
+                                         idx, "exclude uri");
+  },
+
+  validate: function validate(aEmptyBookmarks) {
+    var rootNode = PlacesUtils.getFolderContents(PlacesUtils.placesRootId,
+                                                 false, false).root;
+
+    if (!aEmptyBookmarks) {
+      // since restore does not remove backup exclude items both
+      // roots should still exist.
+      do_check_eq(rootNode.childCount, PLACES_ROOTS_COUNT + 2);
+      // open exclude root and check it still contains one item
+      var restoreRootIndex = PLACES_ROOTS_COUNT;
+      var excludeRootIndex = PLACES_ROOTS_COUNT+1;
+      var excludeRootNode = rootNode.getChild(excludeRootIndex);
+      do_check_eq(this._excludeRootTitle, excludeRootNode.title);
+      excludeRootNode.QueryInterface(Ci.nsINavHistoryQueryResultNode);
+      excludeRootNode.containerOpen = true;
+      do_check_eq(excludeRootNode.childCount, 1);
+      var excludeRootChildNode = excludeRootNode.getChild(0);
+      do_check_eq(excludeRootChildNode.uri, this._restoreRootExcludeURI.spec);
+      excludeRootNode.containerOpen = false;
+    }
+    else {
+      // exclude root should not exist anymore
+      do_check_eq(rootNode.childCount, PLACES_ROOTS_COUNT + 1);
+      restoreRootIndex = PLACES_ROOTS_COUNT;
+    }
+
+    var restoreRootNode = rootNode.getChild(restoreRootIndex);
+    do_check_eq(this._restoreRootTitle, restoreRootNode.title);
+    restoreRootNode.QueryInterface(Ci.nsINavHistoryQueryResultNode);
+    restoreRootNode.containerOpen = true;
+    do_check_eq(restoreRootNode.childCount, 1);
+    var restoreRootChildNode = restoreRootNode.getChild(0);
+    do_check_eq(restoreRootChildNode.uri, this._restoreRootURI.spec);
+    restoreRootNode.containerOpen = false;
+
+    rootNode.containerOpen = false;
+  }
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function*() {
+  // make json file
+  let jsonFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.json");
+
+  // populate db
+  test.populate();
+
+  yield BookmarkJSONUtils.exportToFile(jsonFile);
+
+  // restore json file
+  yield BookmarkJSONUtils.importFromFile(jsonFile, true);
+
+  // validate without removing all bookmarks
+  // restore do not remove backup exclude entries
+  test.validate(false);
+
+  // cleanup
+  yield PlacesUtils.bookmarks.eraseEverything();
+  // manually remove the excluded root
+  PlacesUtils.bookmarks.removeItem(test._excludeRootId);
+  // restore json file
+  yield BookmarkJSONUtils.importFromFile(jsonFile, true);
+
+  // validate after a complete bookmarks cleanup
+  test.validate(true);
+
+  // clean up
+  yield OS.File.remove(jsonFile);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_417228-other-roots.js b/toolkit/components/places/tests/bookmarks/test_417228-other-roots.js
new file mode 100644
index 000000000..1def75d2d
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_417228-other-roots.js
@@ -0,0 +1,158 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var tests = [];
+
+/*
+
+Backup/restore tests example:
+
+var myTest = {
+  populate: function () { ... add bookmarks ... },
+  validate: function () { ... query for your bookmarks ... }
+}
+
+this.push(myTest);
+
+*/
+
+tests.push({
+  excludeItemsFromRestore: [],
+  populate: function populate() {
+    // check initial size
+    var rootNode = PlacesUtils.getFolderContents(PlacesUtils.placesRootId,
+                                                 false, false).root;
+    do_check_eq(rootNode.childCount, 5);
+
+    // create a test root
+    this._folderTitle = "test folder";
+    this._folderId =
+      PlacesUtils.bookmarks.createFolder(PlacesUtils.placesRootId,
+                                         this._folderTitle,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX);
+    do_check_eq(rootNode.childCount, 6);
+
+    // add a tag
+    this._testURI = PlacesUtils._uri("http://test");
+    this._tags = ["a", "b"];
+    PlacesUtils.tagging.tagURI(this._testURI, this._tags);
+
+    // add a child to each root, including our test root
+    this._roots = [PlacesUtils.bookmarksMenuFolderId, PlacesUtils.toolbarFolderId,
+                   PlacesUtils.unfiledBookmarksFolderId, PlacesUtils.mobileFolderId,
+                   this._folderId];
+    this._roots.forEach(function(aRootId) {
+      // clean slate
+      PlacesUtils.bookmarks.removeFolderChildren(aRootId);
+      // add a test bookmark
+      PlacesUtils.bookmarks.insertBookmark(aRootId, this._testURI,
+                                           PlacesUtils.bookmarks.DEFAULT_INDEX, "test");
+    }, this);
+
+    // add a folder to exclude from replacing during restore
+    // this will still be present post-restore
+    var excludedFolderId =
+      PlacesUtils.bookmarks.createFolder(PlacesUtils.placesRootId,
+                                         "excluded",
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX);
+    do_check_eq(rootNode.childCount, 7);
+    this.excludeItemsFromRestore.push(excludedFolderId);
+
+    // add a test bookmark to it
+    PlacesUtils.bookmarks.insertBookmark(excludedFolderId, this._testURI,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX, "test");
+  },
+
+  inbetween: function inbetween() {
+    // add some items that should be removed by the restore
+
+    // add a folder
+    this._litterTitle = "otter";
+    PlacesUtils.bookmarks.createFolder(PlacesUtils.placesRootId,
+                                       this._litterTitle, 0);
+
+    // add some tags
+    PlacesUtils.tagging.tagURI(this._testURI, ["c", "d"]);
+  },
+
+  validate: function validate() {
+    // validate tags restored
+    var tags = PlacesUtils.tagging.getTagsForURI(this._testURI);
+    // also validates that litter tags are gone
+    do_check_eq(this._tags.toString(), tags.toString());
+
+    var rootNode = PlacesUtils.getFolderContents(PlacesUtils.placesRootId,
+                                                 false, false).root;
+
+    // validate litter is gone
+    do_check_neq(rootNode.getChild(0).title, this._litterTitle);
+
+    // test root count is the same
+    do_check_eq(rootNode.childCount, 7);
+
+    var foundTestFolder = 0;
+    for (var i = 0; i < rootNode.childCount; i++) {
+      var node = rootNode.getChild(i);
+
+      do_print("validating " + node.title);
+      if (node.itemId != PlacesUtils.tagsFolderId) {
+        if (node.title == this._folderTitle) {
+          // check the test folder's properties
+          do_check_eq(node.type, node.RESULT_TYPE_FOLDER);
+          do_check_eq(node.title, this._folderTitle);
+          foundTestFolder++;
+        }
+
+        // test contents
+        node.QueryInterface(Ci.nsINavHistoryContainerResultNode).containerOpen = true;
+        do_check_eq(node.childCount, 1);
+        var child = node.getChild(0);
+        do_check_true(PlacesUtils._uri(child.uri).equals(this._testURI));
+
+        // clean up
+        node.containerOpen = false;
+      }
+    }
+    do_check_eq(foundTestFolder, 1);
+    rootNode.containerOpen = false;
+  }
+});
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* () {
+  // make json file
+  let jsonFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.json");
+
+  // populate db
+  tests.forEach(function(aTest) {
+    aTest.populate();
+    // sanity
+    aTest.validate();
+
+    if (aTest.excludedItemsFromRestore)
+      excludedItemsFromRestore = excludedItems.concat(aTest.excludedItemsFromRestore);
+  });
+
+  yield BookmarkJSONUtils.exportToFile(jsonFile);
+
+  tests.forEach(function(aTest) {
+    aTest.inbetween();
+  });
+
+  // restore json file
+  yield BookmarkJSONUtils.importFromFile(jsonFile, true);
+
+  // validate
+  tests.forEach(function(aTest) {
+    aTest.validate();
+  });
+
+  // clean up
+  yield OS.File.remove(jsonFile);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_424958-json-quoted-folders.js b/toolkit/components/places/tests/bookmarks/test_424958-json-quoted-folders.js
new file mode 100644
index 000000000..7da1146cf
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_424958-json-quoted-folders.js
@@ -0,0 +1,91 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var tests = [];
+
+/*
+
+Backup/restore tests example:
+
+var myTest = {
+  populate: function () { ... add bookmarks ... },
+  validate: function () { ... query for your bookmarks ... }
+}
+
+this.push(myTest);
+
+*/
+
+var quotesTest = {
+  _folderTitle: '"quoted folder"',
+  _folderId: null,
+
+  populate: function () {
+    this._folderId =
+      PlacesUtils.bookmarks.createFolder(PlacesUtils.toolbarFolderId,
+                                         this._folderTitle,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX);
+  },
+
+  clean: function () {
+    PlacesUtils.bookmarks.removeItem(this._folderId);
+  },
+
+  validate: function () {
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    var result = PlacesUtils.history.executeQuery(query, PlacesUtils.history.getNewQueryOptions());
+
+    var toolbar = result.root;
+    toolbar.containerOpen = true;
+
+    // test for our quoted folder
+    do_check_true(toolbar.childCount, 1);
+    var folderNode = toolbar.getChild(0);
+    do_check_eq(folderNode.type, folderNode.RESULT_TYPE_FOLDER);
+    do_check_eq(folderNode.title, this._folderTitle);
+
+    // clean up
+    toolbar.containerOpen = false;
+  }
+}
+tests.push(quotesTest);
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* () {
+  // make json file
+  let jsonFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.json");
+
+  // populate db
+  tests.forEach(function(aTest) {
+    aTest.populate();
+    // sanity
+    aTest.validate();
+  });
+
+  // export json to file
+  yield BookmarkJSONUtils.exportToFile(jsonFile);
+
+  // clean
+  tests.forEach(function(aTest) {
+    aTest.clean();
+  });
+
+  // restore json file
+  yield BookmarkJSONUtils.importFromFile(jsonFile, true);
+
+  // validate
+  tests.forEach(function(aTest) {
+    aTest.validate();
+  });
+
+  // clean up
+  yield OS.File.remove(jsonFile);
+
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_448584.js b/toolkit/components/places/tests/bookmarks/test_448584.js
new file mode 100644
index 000000000..6e58bd83a
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_448584.js
@@ -0,0 +1,113 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var tests = [];
+
+// Get database connection
+try {
+  var mDBConn = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
+                                   .DBConnection;
+}
+catch (ex) {
+  do_throw("Could not get database connection\n");
+}
+
+/*
+  This test is:
+    - don't try to add invalid uri nodes to a JSON backup
+*/
+
+var invalidURITest = {
+  _itemTitle: "invalid uri",
+  _itemUrl: "http://test.mozilla.org/",
+  _itemId: null,
+
+  populate: function () {
+    // add a valid bookmark
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.toolbarFolderId,
+                                         PlacesUtils._uri(this._itemUrl),
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         this._itemTitle);
+    // this bookmark will go corrupt
+    this._itemId =
+      PlacesUtils.bookmarks.insertBookmark(PlacesUtils.toolbarFolderId,
+                                           PlacesUtils._uri(this._itemUrl),
+                                           PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                           this._itemTitle);
+  },
+
+  clean: function () {
+    PlacesUtils.bookmarks.removeItem(this._itemId);
+  },
+
+  validate: function (aExpectValidItemsCount) {
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    var options = PlacesUtils.history.getNewQueryOptions();
+    var result = PlacesUtils.history.executeQuery(query, options);
+
+    var toolbar = result.root;
+    toolbar.containerOpen = true;
+
+    // test for our bookmark
+    do_check_eq(toolbar.childCount, aExpectValidItemsCount);
+    for (var i = 0; i < toolbar.childCount; i++) {
+      var folderNode = toolbar.getChild(0);
+      do_check_eq(folderNode.type, folderNode.RESULT_TYPE_URI);
+      do_check_eq(folderNode.title, this._itemTitle);
+    }
+
+    // clean up
+    toolbar.containerOpen = false;
+  }
+}
+tests.push(invalidURITest);
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function*() {
+  // make json file
+  let jsonFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.json");
+
+  // populate db
+  tests.forEach(function(aTest) {
+    aTest.populate();
+    // sanity
+    aTest.validate(2);
+    // Something in the code went wrong and we finish up losing the place, so
+    // the bookmark uri becomes null.
+    var sql = "UPDATE moz_bookmarks SET fk = 1337 WHERE id = ?1";
+    var stmt = mDBConn.createStatement(sql);
+    stmt.bindByIndex(0, aTest._itemId);
+    try {
+      stmt.execute();
+    } finally {
+      stmt.finalize();
+    }
+  });
+
+  yield BookmarkJSONUtils.exportToFile(jsonFile);
+
+  // clean
+  tests.forEach(function(aTest) {
+    aTest.clean();
+  });
+
+  // restore json file
+  try {
+    yield BookmarkJSONUtils.importFromFile(jsonFile, true);
+  } catch (ex) { do_throw("couldn't import the exported file: " + ex); }
+
+  // validate
+  tests.forEach(function(aTest) {
+    aTest.validate(1);
+  });
+
+  // clean up
+  yield OS.File.remove(jsonFile);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_458683.js b/toolkit/components/places/tests/bookmarks/test_458683.js
new file mode 100644
index 000000000..c3722aab5
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_458683.js
@@ -0,0 +1,131 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var tests = [];
+
+// Get database connection
+try {
+  var mDBConn = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
+                                   .DBConnection;
+}
+catch (ex) {
+  do_throw("Could not get database connection\n");
+}
+
+/*
+  This test is:
+    - don't block while doing backup and restore if tag containers contain
+      bogus items (separators, folders)
+*/
+
+var invalidTagChildTest = {
+  _itemTitle: "invalid uri",
+  _itemUrl: "http://test.mozilla.org/",
+  _itemId: -1,
+  _tag: "testTag",
+  _tagItemId: -1,
+
+  populate: function () {
+    // add a valid bookmark
+    this._itemId = PlacesUtils.bookmarks
+                              .insertBookmark(PlacesUtils.toolbarFolderId,
+                                              PlacesUtils._uri(this._itemUrl),
+                                              PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                              this._itemTitle);
+
+    // create a tag
+    PlacesUtils.tagging.tagURI(PlacesUtils._uri(this._itemUrl), [this._tag]);
+    // get tag folder id
+    var options = PlacesUtils.history.getNewQueryOptions();
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.tagsFolder], 1);
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var tagRoot = result.root;
+    tagRoot.containerOpen = true;
+    do_check_eq(tagRoot.childCount, 1);
+    var tagNode = tagRoot.getChild(0)
+                          .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+    this._tagItemId = tagNode.itemId;
+    tagRoot.containerOpen = false;
+
+    // add a separator and a folder inside tag folder
+    PlacesUtils.bookmarks.insertSeparator(this._tagItemId,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX);
+    PlacesUtils.bookmarks.createFolder(this._tagItemId,
+                                       "test folder",
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX);
+
+    // add a separator and a folder inside tag root
+    PlacesUtils.bookmarks.insertSeparator(PlacesUtils.bookmarks.tagsFolder,
+                                          PlacesUtils.bookmarks.DEFAULT_INDEX);
+    PlacesUtils.bookmarks.createFolder(PlacesUtils.bookmarks.tagsFolder,
+                                       "test tags root folder",
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX);
+  },
+
+  clean: function () {
+    PlacesUtils.tagging.untagURI(PlacesUtils._uri(this._itemUrl), [this._tag]);
+    PlacesUtils.bookmarks.removeItem(this._itemId);
+  },
+
+  validate: function () {
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    var options = PlacesUtils.history.getNewQueryOptions();
+    var result = PlacesUtils.history.executeQuery(query, options);
+
+    var toolbar = result.root;
+    toolbar.containerOpen = true;
+
+    // test for our bookmark
+    do_check_eq(toolbar.childCount, 1);
+    for (var i = 0; i < toolbar.childCount; i++) {
+      var folderNode = toolbar.getChild(0);
+      do_check_eq(folderNode.type, folderNode.RESULT_TYPE_URI);
+      do_check_eq(folderNode.title, this._itemTitle);
+    }
+    toolbar.containerOpen = false;
+
+    // test for our tag
+    var tags = PlacesUtils.tagging.getTagsForURI(PlacesUtils._uri(this._itemUrl));
+    do_check_eq(tags.length, 1);
+    do_check_eq(tags[0], this._tag);
+  }
+}
+tests.push(invalidTagChildTest);
+
+function run_test() {
+  run_next_test()
+}
+
+add_task(function* () {
+  let jsonFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.json");
+
+  // populate db
+  tests.forEach(function(aTest) {
+    aTest.populate();
+    // sanity
+    aTest.validate();
+  });
+
+  yield BookmarkJSONUtils.exportToFile(jsonFile);
+
+  // clean
+  tests.forEach(function(aTest) {
+    aTest.clean();
+  });
+
+  // restore json file
+  yield BookmarkJSONUtils.importFromFile(jsonFile, true);
+
+  // validate
+  tests.forEach(function(aTest) {
+    aTest.validate();
+  });
+
+  // clean up
+  yield OS.File.remove(jsonFile);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_466303-json-remove-backups.js b/toolkit/components/places/tests/bookmarks/test_466303-json-remove-backups.js
new file mode 100644
index 000000000..3ce0e6ad7
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_466303-json-remove-backups.js
@@ -0,0 +1,124 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Since PlacesBackups.getbackupFiles() is a lazy getter, these tests must
+// run in the given order, to avoid making it out-of-sync.
+
+add_task(function* check_max_backups_is_respected() {
+  // Get bookmarkBackups directory
+  let backupFolder = yield PlacesBackups.getBackupFolder();
+
+  // Create 2 json dummy backups in the past.
+  let oldJsonPath = OS.Path.join(backupFolder, "bookmarks-2008-01-01.json");
+  let oldJsonFile = yield OS.File.open(oldJsonPath, { truncate: true });
+  oldJsonFile.close();
+  do_check_true(yield OS.File.exists(oldJsonPath));
+
+  let jsonPath = OS.Path.join(backupFolder, "bookmarks-2008-01-31.json");
+  let jsonFile = yield OS.File.open(jsonPath, { truncate: true });
+  jsonFile.close();
+  do_check_true(yield OS.File.exists(jsonPath));
+
+  // Export bookmarks to JSON.
+  // Allow 2 backups, the older one should be removed.
+  yield PlacesBackups.create(2);
+
+  let count = 0;
+  let lastBackupPath = null;
+  let iterator = new OS.File.DirectoryIterator(backupFolder);
+  try {
+    yield iterator.forEach(aEntry => {
+      count++;
+      if (PlacesBackups.filenamesRegex.test(aEntry.name))
+        lastBackupPath = aEntry.path;
+    });
+  } finally {
+    iterator.close();
+  }
+
+  do_check_eq(count, 2);
+  do_check_neq(lastBackupPath, null);
+  do_check_false(yield OS.File.exists(oldJsonPath));
+  do_check_true(yield OS.File.exists(jsonPath));
+});
+
+add_task(function* check_max_backups_greater_than_backups() {
+  // Get bookmarkBackups directory
+  let backupFolder = yield PlacesBackups.getBackupFolder();
+
+  // Export bookmarks to JSON.
+  // Allow 3 backups, none should be removed.
+  yield PlacesBackups.create(3);
+
+  let count = 0;
+  let lastBackupPath = null;
+  let iterator = new OS.File.DirectoryIterator(backupFolder);
+  try {
+    yield iterator.forEach(aEntry => {
+      count++;
+      if (PlacesBackups.filenamesRegex.test(aEntry.name))
+        lastBackupPath = aEntry.path;
+    });
+  } finally {
+    iterator.close();
+  }
+  do_check_eq(count, 2);
+  do_check_neq(lastBackupPath, null);
+});
+
+add_task(function* check_max_backups_null() {
+  // Get bookmarkBackups directory
+  let backupFolder = yield PlacesBackups.getBackupFolder();
+
+  // Export bookmarks to JSON.
+  // Allow infinite backups, none should be removed, a new one is not created
+  // since one for today already exists.
+  yield PlacesBackups.create(null);
+
+  let count = 0;
+  let lastBackupPath = null;
+  let iterator = new OS.File.DirectoryIterator(backupFolder);
+  try {
+    yield iterator.forEach(aEntry => {
+      count++;
+      if (PlacesBackups.filenamesRegex.test(aEntry.name))
+        lastBackupPath = aEntry.path;
+    });
+  } finally {
+    iterator.close();
+  }
+  do_check_eq(count, 2);
+  do_check_neq(lastBackupPath, null);
+});
+
+add_task(function* check_max_backups_undefined() {
+  // Get bookmarkBackups directory
+  let backupFolder = yield PlacesBackups.getBackupFolder();
+
+  // Export bookmarks to JSON.
+  // Allow infinite backups, none should be removed, a new one is not created
+  // since one for today already exists.
+  yield PlacesBackups.create();
+
+  let count = 0;
+  let lastBackupPath = null;
+  let iterator = new OS.File.DirectoryIterator(backupFolder);
+  try {
+    yield iterator.forEach(aEntry => {
+      count++;
+      if (PlacesBackups.filenamesRegex.test(aEntry.name))
+        lastBackupPath = aEntry.path;
+    });
+  } finally {
+    iterator.close();
+  }
+  do_check_eq(count, 2);
+  do_check_neq(lastBackupPath, null);
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_477583_json-backup-in-future.js b/toolkit/components/places/tests/bookmarks/test_477583_json-backup-in-future.js
new file mode 100644
index 000000000..116352666
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_477583_json-backup-in-future.js
@@ -0,0 +1,56 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function run_test() {
+  do_test_pending();
+
+  Task.spawn(function*() {
+    let backupFolder = yield PlacesBackups.getBackupFolder();
+    let bookmarksBackupDir = new FileUtils.File(backupFolder);
+    // Remove all files from backups folder.
+    let files = bookmarksBackupDir.directoryEntries;
+    while (files.hasMoreElements()) {
+      let entry = files.getNext().QueryInterface(Ci.nsIFile);
+      entry.remove(false);
+    }
+
+    // Create a json dummy backup in the future.
+    let dateObj = new Date();
+    dateObj.setYear(dateObj.getFullYear() + 1);
+    let name = PlacesBackups.getFilenameForDate(dateObj);
+    do_check_eq(name, "bookmarks-" + PlacesBackups.toISODateString(dateObj) + ".json");
+    files = bookmarksBackupDir.directoryEntries;
+    while (files.hasMoreElements()) {
+      let entry = files.getNext().QueryInterface(Ci.nsIFile);
+      if (PlacesBackups.filenamesRegex.test(entry.leafName))
+        entry.remove(false);
+    }
+
+    let futureBackupFile = bookmarksBackupDir.clone();
+    futureBackupFile.append(name);
+    futureBackupFile.create(Ci.nsILocalFile.NORMAL_FILE_TYPE, 0o600);
+    do_check_true(futureBackupFile.exists());
+
+    do_check_eq((yield PlacesBackups.getBackupFiles()).length, 0);
+
+    yield PlacesBackups.create();
+    // Check that a backup for today has been created.
+    do_check_eq((yield PlacesBackups.getBackupFiles()).length, 1);
+    let mostRecentBackupFile = yield PlacesBackups.getMostRecentBackup();
+    do_check_neq(mostRecentBackupFile, null);
+    do_check_true(PlacesBackups.filenamesRegex.test(OS.Path.basename(mostRecentBackupFile)));
+
+    // Check that future backup has been removed.
+    do_check_false(futureBackupFile.exists());
+
+    // Cleanup.
+    mostRecentBackupFile = new FileUtils.File(mostRecentBackupFile);
+    mostRecentBackupFile.remove(false);
+    do_check_false(mostRecentBackupFile.exists());
+
+    do_test_finished()
+  });
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_675416.js b/toolkit/components/places/tests/bookmarks/test_675416.js
new file mode 100644
index 000000000..08b1c3620
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_675416.js
@@ -0,0 +1,56 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test() {
+  /**
+   * Requests information to the service, so that bookmark's data is cached.
+   * @param aItemId
+   *        Id of the bookmark to be cached.
+   */
+  function forceBookmarkCaching(aItemId) {
+    PlacesUtils.bookmarks.getFolderIdForItem(aItemId);
+  }
+
+  let observer = {
+    onBeginUpdateBatch: () => forceBookmarkCaching(itemId1),
+    onEndUpdateBatch: () => forceBookmarkCaching(itemId1),
+    onItemAdded: forceBookmarkCaching,
+    onItemChanged: forceBookmarkCaching,
+    onItemMoved: forceBookmarkCaching,
+    onItemRemoved: function(id) {
+      try {
+        forceBookmarkCaching(id);
+        do_throw("trying to fetch a removed bookmark should throw");
+      } catch (ex) {}
+    },
+    onItemVisited: forceBookmarkCaching,
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsINavBookmarkObserver])
+  };
+  PlacesUtils.bookmarks.addObserver(observer, false);
+
+  let folderId1 = PlacesUtils.bookmarks
+                             .createFolder(PlacesUtils.bookmarksMenuFolderId,
+                                           "Bookmarks",
+                                           PlacesUtils.bookmarks.DEFAULT_INDEX);
+  let itemId1 = PlacesUtils.bookmarks
+                           .insertBookmark(folderId1,
+                                           NetUtil.newURI("http:/www.wired.com/wiredscience"),
+                                           PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                           "Wired Science");
+
+  PlacesUtils.bookmarks.removeItem(folderId1);
+
+  let folderId2 = PlacesUtils.bookmarks
+                             .createFolder(PlacesUtils.bookmarksMenuFolderId,
+                                           "Science",
+                                           PlacesUtils.bookmarks.DEFAULT_INDEX);
+  let folderId3 = PlacesUtils.bookmarks
+                             .createFolder(folderId2,
+                                           "Blogs",
+                                           PlacesUtils.bookmarks.DEFAULT_INDEX);
+  // Check title is correctly reported.
+  do_check_eq(PlacesUtils.bookmarks.getItemTitle(folderId3), "Blogs");
+  do_check_eq(PlacesUtils.bookmarks.getItemTitle(folderId2), "Science");
+
+  PlacesUtils.bookmarks.removeObserver(observer, false);
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_711914.js b/toolkit/components/places/tests/bookmarks/test_711914.js
new file mode 100644
index 000000000..3712c8a77
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_711914.js
@@ -0,0 +1,56 @@
+/* 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/. */
+
+function run_test() {
+  /**
+   * Requests information to the service, so that bookmark's data is cached.
+   * @param aItemId
+   *        Id of the bookmark to be cached.
+   */
+  function forceBookmarkCaching(aItemId) {
+    let parent = PlacesUtils.bookmarks.getFolderIdForItem(aItemId);
+    PlacesUtils.bookmarks.getFolderIdForItem(parent);
+  }
+
+  let observer = {
+    onBeginUpdateBatch: () => forceBookmarkCaching(itemId1),
+    onEndUpdateBatch: () => forceBookmarkCaching(itemId1),
+    onItemAdded: forceBookmarkCaching,
+    onItemChanged: forceBookmarkCaching,
+    onItemMoved: forceBookmarkCaching,
+    onItemRemoved: function (id) {
+      try {
+        forceBookmarkCaching(id);
+        do_throw("trying to fetch a removed bookmark should throw");
+      } catch (ex) {}
+    },
+    onItemVisited: forceBookmarkCaching,
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsINavBookmarkObserver])
+  };
+  PlacesUtils.bookmarks.addObserver(observer, false);
+
+  let folder1 = PlacesUtils.bookmarks
+                           .createFolder(PlacesUtils.bookmarksMenuFolderId,
+                                         "Folder1",
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX);
+  let folder2 = PlacesUtils.bookmarks
+                           .createFolder(folder1,
+                                         "Folder2",
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX);
+  PlacesUtils.bookmarks.insertBookmark(folder2,
+                                       NetUtil.newURI("http://mozilla.org/"),
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "Mozilla");
+
+  PlacesUtils.bookmarks.removeFolderChildren(folder1);
+
+  // Check title is correctly reported.
+  do_check_eq(PlacesUtils.bookmarks.getItemTitle(folder1), "Folder1");
+  try {
+    PlacesUtils.bookmarks.getItemTitle(folder2);
+    do_throw("trying to fetch a removed bookmark should throw");
+  } catch (ex) {}
+
+  PlacesUtils.bookmarks.removeObserver(observer, false);
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_818584-discard-duplicate-backups.js b/toolkit/components/places/tests/bookmarks/test_818584-discard-duplicate-backups.js
new file mode 100644
index 000000000..c88323478
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_818584-discard-duplicate-backups.js
@@ -0,0 +1,59 @@
+/* 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/. */
+
+/**
+ * Checks that automatically created bookmark backups are discarded if they are
+ * duplicate of an existing ones.
+ */
+function run_test() {
+  run_next_test();
+}
+
+add_task(function*() {
+  // Create a backup for yesterday in the backups folder.
+  let backupFolder = yield PlacesBackups.getBackupFolder();
+  let dateObj = new Date();
+  dateObj.setDate(dateObj.getDate() - 1);
+  let oldBackupName = PlacesBackups.getFilenameForDate(dateObj);
+  let oldBackup = OS.Path.join(backupFolder, oldBackupName);
+  let {count: count, hash: hash} = yield BookmarkJSONUtils.exportToFile(oldBackup);
+  do_check_true(count > 0);
+  do_check_eq(hash.length, 24);
+  oldBackupName = oldBackupName.replace(/\.json/, "_" + count + "_" + hash + ".json");
+  yield OS.File.move(oldBackup, OS.Path.join(backupFolder, oldBackupName));
+
+  // Create a backup.
+  // This should just rename the existing backup, so in the end there should be
+  // only one backup with today's date.
+  yield PlacesBackups.create();
+
+  // Get the hash of the generated backup
+  let backupFiles = yield PlacesBackups.getBackupFiles();
+  do_check_eq(backupFiles.length, 1);
+
+  let matches = OS.Path.basename(backupFiles[0]).match(PlacesBackups.filenamesRegex);
+  do_check_eq(matches[1], PlacesBackups.toISODateString(new Date()));
+  do_check_eq(matches[2], count);
+  do_check_eq(matches[3], hash);
+
+  // Add a bookmark and create another backup.
+  let bookmarkId = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.bookmarks.bookmarksMenuFolder,
+                                                        uri("http://foo.com"),
+                                                        PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                        "foo");
+  // We must enforce a backup since one for today already exists.  The forced
+  // backup will replace the existing one.
+  yield PlacesBackups.create(undefined, true);
+  do_check_eq(backupFiles.length, 1);
+  recentBackup = yield PlacesBackups.getMostRecentBackup();
+  do_check_neq(recentBackup, OS.Path.join(backupFolder, oldBackupName));
+  matches = OS.Path.basename(recentBackup).match(PlacesBackups.filenamesRegex);
+  do_check_eq(matches[1], PlacesBackups.toISODateString(new Date()));
+  do_check_eq(matches[2], count + 1);
+  do_check_neq(matches[3], hash);
+
+  // Clean up
+  PlacesUtils.bookmarks.removeItem(bookmarkId);
+  yield PlacesBackups.create(0);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_818587_compress-bookmarks-backups.js b/toolkit/components/places/tests/bookmarks/test_818587_compress-bookmarks-backups.js
new file mode 100644
index 000000000..2c84990b3
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_818587_compress-bookmarks-backups.js
@@ -0,0 +1,57 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* compress_bookmark_backups_test() {
+  // Check for jsonlz4 extension
+  let todayFilename = PlacesBackups.getFilenameForDate(new Date(2014, 4, 15), true);
+  do_check_eq(todayFilename, "bookmarks-2014-05-15.jsonlz4");
+
+  yield PlacesBackups.create();
+
+  // Check that a backup for today has been created and the regex works fine for lz4.
+  do_check_eq((yield PlacesBackups.getBackupFiles()).length, 1);
+  let mostRecentBackupFile = yield PlacesBackups.getMostRecentBackup();
+  do_check_neq(mostRecentBackupFile, null);
+  do_check_true(PlacesBackups.filenamesRegex.test(OS.Path.basename(mostRecentBackupFile)));
+
+  // The most recent backup file has to be removed since saveBookmarksToJSONFile
+  // will otherwise over-write the current backup, since it will be made on the
+  // same date
+  yield OS.File.remove(mostRecentBackupFile);
+  do_check_false((yield OS.File.exists(mostRecentBackupFile)));
+
+  // Check that, if the user created a custom backup out of the default
+  // backups folder, it gets copied (compressed) into it.
+  let jsonFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.json");
+  yield PlacesBackups.saveBookmarksToJSONFile(jsonFile);
+  do_check_eq((yield PlacesBackups.getBackupFiles()).length, 1);
+
+  // Check if import works from lz4 compressed json
+  let uri = NetUtil.newURI("http://www.mozilla.org/en-US/");
+  let bm  = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                 uri,
+                                                 PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                 "bookmark");
+
+  // Force create a compressed backup, Remove the bookmark, the restore the backup
+  yield PlacesBackups.create(undefined, true);
+  let recentBackup = yield PlacesBackups.getMostRecentBackup();
+  PlacesUtils.bookmarks.removeItem(bm);
+  yield BookmarkJSONUtils.importFromFile(recentBackup, true);
+  let root = PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+  let node = root.getChild(0);
+  do_check_eq(node.uri, uri.spec);
+
+  root.containerOpen = false;
+  PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.unfiledBookmarksFolderId);
+
+  // Cleanup.
+  yield OS.File.remove(jsonFile);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_818593-store-backup-metadata.js b/toolkit/components/places/tests/bookmarks/test_818593-store-backup-metadata.js
new file mode 100644
index 000000000..4ea07fb39
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_818593-store-backup-metadata.js
@@ -0,0 +1,57 @@
+/* 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/. */
+
+/**
+ * To confirm that metadata i.e. bookmark count is set and retrieved for
+ * automatic backups.
+ */
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_saveBookmarksToJSONFile_and_create()
+{
+  // Add a bookmark
+  let uri = NetUtil.newURI("http://getfirefox.com/");
+  let bookmarkId =
+    PlacesUtils.bookmarks.insertBookmark(
+      PlacesUtils.unfiledBookmarksFolderId, uri,
+      PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
+
+  // Test saveBookmarksToJSONFile()
+  let backupFile = FileUtils.getFile("TmpD", ["bookmarks.json"]);
+  backupFile.create(Ci.nsILocalFile.NORMAL_FILE_TYPE, parseInt("0600", 8));
+
+  let nodeCount = yield PlacesBackups.saveBookmarksToJSONFile(backupFile, true);
+  do_check_true(nodeCount > 0);
+  do_check_true(backupFile.exists());
+  do_check_eq(backupFile.leafName, "bookmarks.json");
+
+  // Ensure the backup would be copied to our backups folder when the original
+  // backup is saved somewhere else.
+  let recentBackup = yield PlacesBackups.getMostRecentBackup();
+  let matches = OS.Path.basename(recentBackup).match(PlacesBackups.filenamesRegex);
+  do_check_eq(matches[2], nodeCount);
+  do_check_eq(matches[3].length, 24);
+
+  // Clear all backups in our backups folder.
+  yield PlacesBackups.create(0);
+  do_check_eq((yield PlacesBackups.getBackupFiles()).length, 0);
+
+  // Test create() which saves bookmarks with metadata on the filename.
+  yield PlacesBackups.create();
+  do_check_eq((yield PlacesBackups.getBackupFiles()).length, 1);
+
+  mostRecentBackupFile = yield PlacesBackups.getMostRecentBackup();
+  do_check_neq(mostRecentBackupFile, null);
+  matches = OS.Path.basename(recentBackup).match(PlacesBackups.filenamesRegex);
+  do_check_eq(matches[2], nodeCount);
+  do_check_eq(matches[3].length, 24);
+
+  // Cleanup
+  backupFile.remove(false);
+  yield PlacesBackups.create(0);
+  PlacesUtils.bookmarks.removeItem(bookmarkId);
+});
+
diff --git a/toolkit/components/places/tests/bookmarks/test_992901-backup-unsorted-hierarchy.js b/toolkit/components/places/tests/bookmarks/test_992901-backup-unsorted-hierarchy.js
new file mode 100644
index 000000000..f5e9f8187
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_992901-backup-unsorted-hierarchy.js
@@ -0,0 +1,48 @@
+/* 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/. */
+
+/**
+ * Checks that backups properly include all of the bookmarks if the hierarchy
+ * in the database is unordered so that a hierarchy is defined before its
+ * ancestor in the bookmarks table.
+ */
+function run_test() {
+  run_next_test();
+}
+
+add_task(function*() {
+  let bm = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                NetUtil.newURI("http://mozilla.org/"),
+                                                PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                "bookmark");
+  let f2 = PlacesUtils.bookmarks.createFolder(PlacesUtils.unfiledBookmarksFolderId, "f2",
+                                              PlacesUtils.bookmarks.DEFAULT_INDEX);
+  PlacesUtils.bookmarks.moveItem(bm, f2, PlacesUtils.bookmarks.DEFAULT_INDEX);
+  let f1 = PlacesUtils.bookmarks.createFolder(PlacesUtils.unfiledBookmarksFolderId, "f1",
+                                              PlacesUtils.bookmarks.DEFAULT_INDEX);
+  PlacesUtils.bookmarks.moveItem(f2, f1, PlacesUtils.bookmarks.DEFAULT_INDEX);
+
+  // Create a backup.
+  yield PlacesBackups.create();
+
+  // Remove the bookmarks, then restore the backup.
+  PlacesUtils.bookmarks.removeItem(f1);
+  yield BookmarkJSONUtils.importFromFile((yield PlacesBackups.getMostRecentBackup()), true);
+
+  do_print("Checking first level");
+  let root = PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+  let level1 = root.getChild(0);
+  do_check_eq(level1.title, "f1");
+  do_print("Checking second level");
+  PlacesUtils.asContainer(level1).containerOpen = true
+  let level2 = level1.getChild(0);
+  do_check_eq(level2.title, "f2");
+  do_print("Checking bookmark");
+  PlacesUtils.asContainer(level2).containerOpen = true
+  let bookmark = level2.getChild(0);
+  do_check_eq(bookmark.title, "bookmark");
+  level2.containerOpen = false;
+  level1.containerOpen = false;
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_997030-bookmarks-html-encode.js b/toolkit/components/places/tests/bookmarks/test_997030-bookmarks-html-encode.js
new file mode 100644
index 000000000..b900887b5
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_997030-bookmarks-html-encode.js
@@ -0,0 +1,37 @@
+/* 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/. */
+
+/**
+ * Checks that we don't encodeURI twice when creating bookmarks.html.
+ */
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* () {
+  let uri = NetUtil.newURI("http://bt.ktxp.com/search.php?keyword=%E5%A6%84%E6%83%B3%E5%AD%A6%E7%94%9F%E4%BC%9A");
+  let bm = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                uri,
+                                                PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                "bookmark");
+
+  let file =  OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.exported.997030.html");
+  if ((yield OS.File.exists(file))) {
+    yield OS.File.remove(file);
+  }
+  yield BookmarkHTMLUtils.exportToFile(file);
+
+  // Remove the bookmarks, then restore the backup.
+  PlacesUtils.bookmarks.removeItem(bm);
+  yield BookmarkHTMLUtils.importFromFile(file, true);
+
+  do_print("Checking first level");
+  let root = PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+  let node = root.getChild(0);
+  do_check_eq(node.uri, uri.spec);
+
+  root.containerOpen = false;
+  PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.unfiledBookmarksFolderId);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_async_observers.js b/toolkit/components/places/tests/bookmarks/test_async_observers.js
new file mode 100644
index 000000000..86d48ac24
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_async_observers.js
@@ -0,0 +1,177 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/* This test checks that bookmarks service is correctly forwarding async
+ * events like visit or favicon additions. */
+
+const NOW = Date.now() * 1000;
+
+var observer = {
+  bookmarks: [],
+  observedBookmarks: 0,
+  observedVisitId: 0,
+  deferred: null,
+
+  /**
+   * Returns a promise that is resolved when the observer determines that the
+   * test can continue.  This is required rather than calling run_next_test
+   * directly in the observer because there are cases where we must wait for
+   * other asynchronous events to be completed in addition to this.
+   */
+  setupCompletionPromise: function ()
+  {
+    this.observedBookmarks = 0;
+    this.deferred = Promise.defer();
+    return this.deferred.promise;
+  },
+
+  onBeginUpdateBatch: function () {},
+  onEndUpdateBatch: function () {},
+  onItemAdded: function () {},
+  onItemRemoved: function () {},
+  onItemMoved: function () {},
+  onItemChanged: function(aItemId, aProperty, aIsAnnotation, aNewValue,
+                          aLastModified, aItemType)
+  {
+    do_print("Check that we got the correct change information.");
+    do_check_neq(this.bookmarks.indexOf(aItemId), -1);
+    if (aProperty == "favicon") {
+      do_check_false(aIsAnnotation);
+      do_check_eq(aNewValue, SMALLPNG_DATA_URI.spec);
+      do_check_eq(aLastModified, 0);
+      do_check_eq(aItemType, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+    }
+    else if (aProperty == "cleartime") {
+      do_check_false(aIsAnnotation);
+      do_check_eq(aNewValue, "");
+      do_check_eq(aLastModified, 0);
+      do_check_eq(aItemType, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+    }
+    else {
+      do_throw("Unexpected property change " + aProperty);
+    }
+
+    if (++this.observedBookmarks == this.bookmarks.length) {
+      this.deferred.resolve();
+    }
+  },
+  onItemVisited: function(aItemId, aVisitId, aTime)
+  {
+    do_print("Check that we got the correct visit information.");
+    do_check_neq(this.bookmarks.indexOf(aItemId), -1);
+    this.observedVisitId = aVisitId;
+    do_check_eq(aTime, NOW);
+    if (++this.observedBookmarks == this.bookmarks.length) {
+      this.deferred.resolve();
+    }
+  },
+
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsINavBookmarkObserver,
+  ])
+};
+PlacesUtils.bookmarks.addObserver(observer, false);
+
+add_task(function* test_add_visit()
+{
+  let observerPromise = observer.setupCompletionPromise();
+
+  // Add a visit to the bookmark and wait for the observer.
+  let visitId;
+  let deferUpdatePlaces = Promise.defer();
+  PlacesUtils.asyncHistory.updatePlaces({
+    uri: NetUtil.newURI("http://book.ma.rk/"),
+    visits: [{ transitionType: TRANSITION_TYPED, visitDate: NOW }]
+  }, {
+    handleError: function TAV_handleError() {
+      deferUpdatePlaces.reject(new Error("Unexpected error in adding visit."));
+    },
+    handleResult: function (aPlaceInfo) {
+      visitId = aPlaceInfo.visits[0].visitId;
+    },
+    handleCompletion: function TAV_handleCompletion() {
+      deferUpdatePlaces.resolve();
+    }
+  });
+
+  // Wait for both the observer and the asynchronous update, in any order.
+  yield deferUpdatePlaces.promise;
+  yield observerPromise;
+
+  // Check that both asynchronous results are consistent.
+  do_check_eq(observer.observedVisitId, visitId);
+});
+
+add_task(function* test_add_icon()
+{
+  let observerPromise = observer.setupCompletionPromise();
+  PlacesUtils.favicons.setAndFetchFaviconForPage(NetUtil.newURI("http://book.ma.rk/"),
+                                                 SMALLPNG_DATA_URI, true,
+                                                 PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+                                                 null,
+                                                 Services.scriptSecurityManager.getSystemPrincipal());
+  yield observerPromise;
+});
+
+add_task(function* test_remove_page()
+{
+  let observerPromise = observer.setupCompletionPromise();
+  PlacesUtils.history.removePage(NetUtil.newURI("http://book.ma.rk/"));
+  yield observerPromise;
+});
+
+add_task(function cleanup()
+{
+  PlacesUtils.bookmarks.removeObserver(observer, false);
+});
+
+add_task(function* shutdown()
+{
+  // Check that async observers don't try to create async statements after
+  // shutdown.  That would cause assertions, since the async thread is gone
+  // already.  Note that in such a case the notifications are not fired, so we
+  // cannot test for them.
+  // Put an history notification that triggers AsyncGetBookmarksForURI between
+  // asyncClose() and the actual connection closing.  Enqueuing a main-thread
+  // event just after places-will-close-connection should ensure it runs before
+  // places-connection-closed.
+  // Notice this code is not using helpers cause it depends on a very specific
+  // order, a change in the helpers code could make this test useless.
+  let deferred = Promise.defer();
+
+  Services.obs.addObserver(function onNotification() {
+    Services.obs.removeObserver(onNotification, "places-will-close-connection");
+    do_check_true(true, "Observed fake places shutdown");
+
+    Services.tm.mainThread.dispatch(() => {
+      // WARNING: this is very bad, never use out of testing code.
+      PlacesUtils.bookmarks.QueryInterface(Ci.nsINavHistoryObserver)
+                           .onPageChanged(NetUtil.newURI("http://book.ma.rk/"),
+                                          Ci.nsINavHistoryObserver.ATTRIBUTE_FAVICON,
+                                          "test", "test");
+      deferred.resolve(promiseTopicObserved("places-connection-closed"));
+    }, Ci.nsIThread.DISPATCH_NORMAL);
+  }, "places-will-close-connection", false);
+  shutdownPlaces();
+
+  yield deferred.promise;
+});
+
+function run_test()
+{
+  // Add multiple bookmarks to the same uri.
+  observer.bookmarks.push(
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         NetUtil.newURI("http://book.ma.rk/"),
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "Bookmark")
+  );
+  observer.bookmarks.push(
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.toolbarFolderId,
+                                         NetUtil.newURI("http://book.ma.rk/"),
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "Bookmark")
+  );
+
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_bmindex.js b/toolkit/components/places/tests/bookmarks/test_bmindex.js
new file mode 100644
index 000000000..c764e4310
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bmindex.js
@@ -0,0 +1,124 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+const NUM_BOOKMARKS = 20;
+const NUM_SEPARATORS = 5;
+const NUM_FOLDERS = 10;
+const NUM_ITEMS = NUM_BOOKMARKS + NUM_SEPARATORS + NUM_FOLDERS;
+const MIN_RAND = -5;
+const MAX_RAND = 40;
+
+var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+         getService(Ci.nsINavBookmarksService);
+
+function check_contiguous_indexes(aBookmarks) {
+  var indexes = [];
+  aBookmarks.forEach(function(aBookmarkId) {
+    let bmIndex = bs.getItemIndex(aBookmarkId);
+    dump("Index: " + bmIndex + "\n");
+    dump("Checking duplicates\n");
+    do_check_eq(indexes.indexOf(bmIndex), -1);
+    dump("Checking out of range, found " + aBookmarks.length + " items\n");
+    do_check_true(bmIndex >= 0 && bmIndex < aBookmarks.length);
+    indexes.push(bmIndex);
+  });
+  dump("Checking all valid indexes have been used\n");
+  do_check_eq(indexes.length, aBookmarks.length);
+}
+
+// main
+function run_test() {
+  var bookmarks = [];
+  // Insert bookmarks with random indexes.
+  for (let i = 0; bookmarks.length < NUM_BOOKMARKS; i++) {
+    let randIndex = Math.round(MIN_RAND + (Math.random() * (MAX_RAND - MIN_RAND)));
+    try {
+      let id = bs.insertBookmark(bs.unfiledBookmarksFolder,
+                                 uri("http://" + i + ".mozilla.org/"),
+                                 randIndex, "Test bookmark " + i);
+      if (randIndex < -1)
+        do_throw("Creating a bookmark at an invalid index should throw");
+      bookmarks.push(id);
+    }
+    catch (ex) {
+      if (randIndex >= -1)
+        do_throw("Creating a bookmark at a valid index should not throw");
+    }
+  }
+  check_contiguous_indexes(bookmarks);
+
+  // Insert separators with random indexes.
+  for (let i = 0; bookmarks.length < NUM_BOOKMARKS + NUM_SEPARATORS; i++) {
+    let randIndex = Math.round(MIN_RAND + (Math.random() * (MAX_RAND - MIN_RAND)));
+    try {
+      let id = bs.insertSeparator(bs.unfiledBookmarksFolder, randIndex);
+      if (randIndex < -1)
+        do_throw("Creating a separator at an invalid index should throw");
+      bookmarks.push(id);
+    }
+    catch (ex) {
+      if (randIndex >= -1)
+        do_throw("Creating a separator at a valid index should not throw");
+    }
+  }
+  check_contiguous_indexes(bookmarks);
+
+  // Insert folders with random indexes.
+  for (let i = 0; bookmarks.length < NUM_ITEMS; i++) {
+    let randIndex = Math.round(MIN_RAND + (Math.random() * (MAX_RAND - MIN_RAND)));
+    try {
+      let id = bs.createFolder(bs.unfiledBookmarksFolder,
+                               "Test folder " + i, randIndex);
+      if (randIndex < -1)
+        do_throw("Creating a folder at an invalid index should throw");
+      bookmarks.push(id);
+    }
+    catch (ex) {
+      if (randIndex >= -1)
+        do_throw("Creating a folder at a valid index should not throw");
+    }
+  }
+  check_contiguous_indexes(bookmarks);
+
+  // Execute some random bookmark delete.
+  for (let i = 0; i < Math.ceil(NUM_ITEMS / 4); i++) {
+    let id = bookmarks.splice(Math.floor(Math.random() * bookmarks.length), 1);
+    dump("Removing item with id " + id + "\n");
+    bs.removeItem(id);
+  }
+  check_contiguous_indexes(bookmarks);
+
+  // Execute some random bookmark move.  This will also try to move it to
+  // invalid index values.
+  for (let i = 0; i < Math.ceil(NUM_ITEMS / 4); i++) {
+    let randIndex = Math.floor(Math.random() * bookmarks.length);
+    let id = bookmarks[randIndex];
+    let newIndex = Math.round(MIN_RAND + (Math.random() * (MAX_RAND - MIN_RAND)));
+    dump("Moving item with id " + id + " to index " + newIndex + "\n");
+    try {
+      bs.moveItem(id, bs.unfiledBookmarksFolder, newIndex);
+      if (newIndex < -1)
+        do_throw("Moving an item to a negative index should throw\n");
+    }
+    catch (ex) {
+      if (newIndex >= -1)
+        do_throw("Moving an item to a valid index should not throw\n");
+    }
+
+  }
+  check_contiguous_indexes(bookmarks);
+
+  // Ensure setItemIndex throws if we pass it a negative index.
+  try {
+    bs.setItemIndex(bookmarks[0], -1);
+    do_throw("setItemIndex should throw for a negative index");
+  } catch (ex) {}
+  // Ensure setItemIndex throws if we pass it a bad itemId.
+  try {
+    bs.setItemIndex(0, 5);
+    do_throw("setItemIndex should throw for a bad itemId");
+  } catch (ex) {}
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks.js b/toolkit/components/places/tests/bookmarks/test_bookmarks.js
new file mode 100644
index 000000000..b67482223
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks.js
@@ -0,0 +1,718 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var bs = PlacesUtils.bookmarks;
+var hs = PlacesUtils.history;
+var anno = PlacesUtils.annotations;
+
+
+var bookmarksObserver = {
+  onBeginUpdateBatch: function() {
+    this._beginUpdateBatch = true;
+  },
+  onEndUpdateBatch: function() {
+    this._endUpdateBatch = true;
+  },
+  onItemAdded: function(id, folder, index, itemType, uri, title, dateAdded,
+                        guid) {
+    this._itemAddedId = id;
+    this._itemAddedParent = folder;
+    this._itemAddedIndex = index;
+    this._itemAddedURI = uri;
+    this._itemAddedTitle = title;
+
+    // Ensure that we've created a guid for this item.
+    let stmt = DBConn().createStatement(
+      `SELECT guid
+       FROM moz_bookmarks
+       WHERE id = :item_id`
+    );
+    stmt.params.item_id = id;
+    do_check_true(stmt.executeStep());
+    do_check_false(stmt.getIsNull(0));
+    do_check_valid_places_guid(stmt.row.guid);
+    do_check_eq(stmt.row.guid, guid);
+    stmt.finalize();
+  },
+  onItemRemoved: function(id, folder, index, itemType) {
+    this._itemRemovedId = id;
+    this._itemRemovedFolder = folder;
+    this._itemRemovedIndex = index;
+  },
+  onItemChanged: function(id, property, isAnnotationProperty, value,
+                          lastModified, itemType, parentId, guid, parentGuid,
+                          oldValue) {
+    this._itemChangedId = id;
+    this._itemChangedProperty = property;
+    this._itemChanged_isAnnotationProperty = isAnnotationProperty;
+    this._itemChangedValue = value;
+    this._itemChangedOldValue = oldValue;
+  },
+  onItemVisited: function(id, visitID, time) {
+    this._itemVisitedId = id;
+    this._itemVisitedVistId = visitID;
+    this._itemVisitedTime = time;
+  },
+  onItemMoved: function(id, oldParent, oldIndex, newParent, newIndex,
+                        itemType) {
+    this._itemMovedId = id
+    this._itemMovedOldParent = oldParent;
+    this._itemMovedOldIndex = oldIndex;
+    this._itemMovedNewParent = newParent;
+    this._itemMovedNewIndex = newIndex;
+  },
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsINavBookmarkObserver,
+  ])
+};
+
+
+// Get bookmarks menu folder id.
+var root = bs.bookmarksMenuFolder;
+// Index at which items should begin.
+var bmStartIndex = 0;
+
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_bookmarks() {
+  bs.addObserver(bookmarksObserver, false);
+
+  // test special folders
+  do_check_true(bs.placesRoot > 0);
+  do_check_true(bs.bookmarksMenuFolder > 0);
+  do_check_true(bs.tagsFolder > 0);
+  do_check_true(bs.toolbarFolder > 0);
+  do_check_true(bs.unfiledBookmarksFolder > 0);
+
+  // test getFolderIdForItem() with bogus item id will throw
+  try {
+    bs.getFolderIdForItem(0);
+    do_throw("getFolderIdForItem accepted bad input");
+  } catch (ex) {}
+
+  // test getFolderIdForItem() with bogus item id will throw
+  try {
+    bs.getFolderIdForItem(-1);
+    do_throw("getFolderIdForItem accepted bad input");
+  } catch (ex) {}
+
+  // test root parentage
+  do_check_eq(bs.getFolderIdForItem(bs.bookmarksMenuFolder), bs.placesRoot);
+  do_check_eq(bs.getFolderIdForItem(bs.tagsFolder), bs.placesRoot);
+  do_check_eq(bs.getFolderIdForItem(bs.toolbarFolder), bs.placesRoot);
+  do_check_eq(bs.getFolderIdForItem(bs.unfiledBookmarksFolder), bs.placesRoot);
+
+  // create a folder to hold all the tests
+  // this makes the tests more tolerant of changes to default_places.html
+  let testRoot = bs.createFolder(root, "places bookmarks xpcshell tests",
+                                 bs.DEFAULT_INDEX);
+  do_check_eq(bookmarksObserver._itemAddedId, testRoot);
+  do_check_eq(bookmarksObserver._itemAddedParent, root);
+  do_check_eq(bookmarksObserver._itemAddedIndex, bmStartIndex);
+  do_check_eq(bookmarksObserver._itemAddedURI, null);
+  let testStartIndex = 0;
+
+  // test getItemIndex for folders
+  do_check_eq(bs.getItemIndex(testRoot), bmStartIndex);
+
+  // test getItemType for folders
+  do_check_eq(bs.getItemType(testRoot), bs.TYPE_FOLDER);
+
+  // insert a bookmark.
+  // the time before we insert, in microseconds
+  let beforeInsert = Date.now() * 1000;
+  do_check_true(beforeInsert > 0);
+
+  let newId = bs.insertBookmark(testRoot, uri("http://google.com/"),
+                                bs.DEFAULT_INDEX, "");
+  do_check_eq(bookmarksObserver._itemAddedId, newId);
+  do_check_eq(bookmarksObserver._itemAddedParent, testRoot);
+  do_check_eq(bookmarksObserver._itemAddedIndex, testStartIndex);
+  do_check_true(bookmarksObserver._itemAddedURI.equals(uri("http://google.com/")));
+  do_check_eq(bs.getBookmarkURI(newId).spec, "http://google.com/");
+
+  let dateAdded = bs.getItemDateAdded(newId);
+  // dateAdded can equal beforeInsert
+  do_check_true(is_time_ordered(beforeInsert, dateAdded));
+
+  // after just inserting, modified should not be set
+  let lastModified = bs.getItemLastModified(newId);
+  do_check_eq(lastModified, dateAdded);
+
+  // The time before we set the title, in microseconds.
+  let beforeSetTitle = Date.now() * 1000;
+  do_check_true(beforeSetTitle >= beforeInsert);
+
+  // Workaround possible VM timers issues moving lastModified and dateAdded
+  // to the past.
+  lastModified -= 1000;
+  bs.setItemLastModified(newId, lastModified);
+  dateAdded -= 1000;
+  bs.setItemDateAdded(newId, dateAdded);
+
+  // set bookmark title
+  bs.setItemTitle(newId, "Google");
+  do_check_eq(bookmarksObserver._itemChangedId, newId);
+  do_check_eq(bookmarksObserver._itemChangedProperty, "title");
+  do_check_eq(bookmarksObserver._itemChangedValue, "Google");
+
+  // check that dateAdded hasn't changed
+  let dateAdded2 = bs.getItemDateAdded(newId);
+  do_check_eq(dateAdded2, dateAdded);
+
+  // check lastModified after we set the title
+  let lastModified2 = bs.getItemLastModified(newId);
+  do_print("test setItemTitle");
+  do_print("dateAdded = " + dateAdded);
+  do_print("beforeSetTitle = " + beforeSetTitle);
+  do_print("lastModified = " + lastModified);
+  do_print("lastModified2 = " + lastModified2);
+  do_check_true(is_time_ordered(lastModified, lastModified2));
+  do_check_true(is_time_ordered(dateAdded, lastModified2));
+
+  // get item title
+  let title = bs.getItemTitle(newId);
+  do_check_eq(title, "Google");
+
+  // test getItemType for bookmarks
+  do_check_eq(bs.getItemType(newId), bs.TYPE_BOOKMARK);
+
+  // get item title bad input
+  try {
+    bs.getItemTitle(-3);
+    do_throw("getItemTitle accepted bad input");
+  } catch (ex) {}
+
+  // get the folder that the bookmark is in
+  let folderId = bs.getFolderIdForItem(newId);
+  do_check_eq(folderId, testRoot);
+
+  // test getItemIndex for bookmarks
+  do_check_eq(bs.getItemIndex(newId), testStartIndex);
+
+  // create a folder at a specific index
+  let workFolder = bs.createFolder(testRoot, "Work", 0);
+  do_check_eq(bookmarksObserver._itemAddedId, workFolder);
+  do_check_eq(bookmarksObserver._itemAddedParent, testRoot);
+  do_check_eq(bookmarksObserver._itemAddedIndex, 0);
+  do_check_eq(bookmarksObserver._itemAddedURI, null);
+
+  do_check_eq(bs.getItemTitle(workFolder), "Work");
+  bs.setItemTitle(workFolder, "Work #");
+  do_check_eq(bs.getItemTitle(workFolder), "Work #");
+
+  // add item into subfolder, specifying index
+  let newId2 = bs.insertBookmark(workFolder,
+                                 uri("http://developer.mozilla.org/"),
+                                 0, "");
+  do_check_eq(bookmarksObserver._itemAddedId, newId2);
+  do_check_eq(bookmarksObserver._itemAddedParent, workFolder);
+  do_check_eq(bookmarksObserver._itemAddedIndex, 0);
+
+  // change item
+  bs.setItemTitle(newId2, "DevMo");
+  do_check_eq(bookmarksObserver._itemChangedProperty, "title");
+
+  // insert item into subfolder
+  let newId3 = bs.insertBookmark(workFolder,
+                                 uri("http://msdn.microsoft.com/"),
+                                 bs.DEFAULT_INDEX, "");
+  do_check_eq(bookmarksObserver._itemAddedId, newId3);
+  do_check_eq(bookmarksObserver._itemAddedParent, workFolder);
+  do_check_eq(bookmarksObserver._itemAddedIndex, 1);
+
+  // change item
+  bs.setItemTitle(newId3, "MSDN");
+  do_check_eq(bookmarksObserver._itemChangedProperty, "title");
+
+  // remove item
+  bs.removeItem(newId2);
+  do_check_eq(bookmarksObserver._itemRemovedId, newId2);
+  do_check_eq(bookmarksObserver._itemRemovedFolder, workFolder);
+  do_check_eq(bookmarksObserver._itemRemovedIndex, 0);
+
+  // insert item into subfolder
+  let newId4 = bs.insertBookmark(workFolder,
+                                 uri("http://developer.mozilla.org/"),
+                                 bs.DEFAULT_INDEX, "");
+  do_check_eq(bookmarksObserver._itemAddedId, newId4);
+  do_check_eq(bookmarksObserver._itemAddedParent, workFolder);
+  do_check_eq(bookmarksObserver._itemAddedIndex, 1);
+
+  // create folder
+  let homeFolder = bs.createFolder(testRoot, "Home", bs.DEFAULT_INDEX);
+  do_check_eq(bookmarksObserver._itemAddedId, homeFolder);
+  do_check_eq(bookmarksObserver._itemAddedParent, testRoot);
+  do_check_eq(bookmarksObserver._itemAddedIndex, 2);
+
+  // insert item
+  let newId5 = bs.insertBookmark(homeFolder, uri("http://espn.com/"),
+                                 bs.DEFAULT_INDEX, "");
+  do_check_eq(bookmarksObserver._itemAddedId, newId5);
+  do_check_eq(bookmarksObserver._itemAddedParent, homeFolder);
+  do_check_eq(bookmarksObserver._itemAddedIndex, 0);
+
+  // change item
+  bs.setItemTitle(newId5, "ESPN");
+  do_check_eq(bookmarksObserver._itemChangedId, newId5);
+  do_check_eq(bookmarksObserver._itemChangedProperty, "title");
+
+  // insert query item
+  let uri6 = uri("place:domain=google.com&type="+
+                 Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY);
+  let newId6 = bs.insertBookmark(testRoot, uri6, bs.DEFAULT_INDEX, "");
+  do_check_eq(bookmarksObserver._itemAddedParent, testRoot);
+  do_check_eq(bookmarksObserver._itemAddedIndex, 3);
+
+  // change item
+  bs.setItemTitle(newId6, "Google Sites");
+  do_check_eq(bookmarksObserver._itemChangedProperty, "title");
+
+  // test getIdForItemAt
+  do_check_eq(bs.getIdForItemAt(testRoot, 0), workFolder);
+  // wrong parent, should return -1
+  do_check_eq(bs.getIdForItemAt(1337, 0), -1);
+  // wrong index, should return -1
+  do_check_eq(bs.getIdForItemAt(testRoot, 1337), -1);
+  // wrong parent and index, should return -1
+  do_check_eq(bs.getIdForItemAt(1337, 1337), -1);
+
+  // move folder, appending, to different folder
+  let oldParentCC = getChildCount(testRoot);
+  bs.moveItem(workFolder, homeFolder, bs.DEFAULT_INDEX);
+  do_check_eq(bookmarksObserver._itemMovedId, workFolder);
+  do_check_eq(bookmarksObserver._itemMovedOldParent, testRoot);
+  do_check_eq(bookmarksObserver._itemMovedOldIndex, 0);
+  do_check_eq(bookmarksObserver._itemMovedNewParent, homeFolder);
+  do_check_eq(bookmarksObserver._itemMovedNewIndex, 1);
+
+  // test that the new index is properly stored
+  do_check_eq(bs.getItemIndex(workFolder), 1);
+  do_check_eq(bs.getFolderIdForItem(workFolder), homeFolder);
+
+  // try to get index of the item from within the old parent folder
+  // check that it has been really removed from there
+  do_check_neq(bs.getIdForItemAt(testRoot, 0), workFolder);
+  // check the last item from within the old parent folder
+  do_check_neq(bs.getIdForItemAt(testRoot, -1), workFolder);
+  // check the index of the item within the new parent folder
+  do_check_eq(bs.getIdForItemAt(homeFolder, 1), workFolder);
+  // try to get index of the last item within the new parent folder
+  do_check_eq(bs.getIdForItemAt(homeFolder, -1), workFolder);
+  // XXX expose FolderCount, and check that the old parent has one less child?
+  do_check_eq(getChildCount(testRoot), oldParentCC-1);
+
+  // move item, appending, to different folder
+  bs.moveItem(newId5, testRoot, bs.DEFAULT_INDEX);
+  do_check_eq(bookmarksObserver._itemMovedId, newId5);
+  do_check_eq(bookmarksObserver._itemMovedOldParent, homeFolder);
+  do_check_eq(bookmarksObserver._itemMovedOldIndex, 0);
+  do_check_eq(bookmarksObserver._itemMovedNewParent, testRoot);
+  do_check_eq(bookmarksObserver._itemMovedNewIndex, 3);
+
+  // test get folder's index
+  let tmpFolder = bs.createFolder(testRoot, "tmp", 2);
+  do_check_eq(bs.getItemIndex(tmpFolder), 2);
+
+  // test setKeywordForBookmark
+  let kwTestItemId = bs.insertBookmark(testRoot, uri("http://keywordtest.com"),
+                                       bs.DEFAULT_INDEX, "");
+  bs.setKeywordForBookmark(kwTestItemId, "bar");
+
+  // test getKeywordForBookmark
+  let k = bs.getKeywordForBookmark(kwTestItemId);
+  do_check_eq("bar", k);
+
+  // test getURIForKeyword
+  let u = bs.getURIForKeyword("bar");
+  do_check_eq("http://keywordtest.com/", u.spec);
+
+  // test removeFolderChildren
+  // 1) add/remove each child type (bookmark, separator, folder)
+  tmpFolder = bs.createFolder(testRoot, "removeFolderChildren",
+                              bs.DEFAULT_INDEX);
+  bs.insertBookmark(tmpFolder, uri("http://foo9.com/"), bs.DEFAULT_INDEX, "");
+  bs.createFolder(tmpFolder, "subfolder", bs.DEFAULT_INDEX);
+  bs.insertSeparator(tmpFolder, bs.DEFAULT_INDEX);
+  // 2) confirm that folder has 3 children
+  let options = hs.getNewQueryOptions();
+  let query = hs.getNewQuery();
+  query.setFolders([tmpFolder], 1);
+  try {
+    let result = hs.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    do_check_eq(rootNode.childCount, 3);
+    rootNode.containerOpen = false;
+  } catch (ex) {
+    do_throw("test removeFolderChildren() - querying for children failed: " + ex);
+  }
+  // 3) remove all children
+  bs.removeFolderChildren(tmpFolder);
+  // 4) confirm that folder has 0 children
+  try {
+    result = hs.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    do_check_eq(rootNode.childCount, 0);
+    rootNode.containerOpen = false;
+  } catch (ex) {
+    do_throw("removeFolderChildren(): " + ex);
+  }
+
+  // XXX - test folderReadOnly
+
+  // test bookmark id in query output
+  try {
+    options = hs.getNewQueryOptions();
+    query = hs.getNewQuery();
+    query.setFolders([testRoot], 1);
+    let result = hs.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    let cc = rootNode.childCount;
+    do_print("bookmark itemId test: CC = " + cc);
+    do_check_true(cc > 0);
+    for (let i=0; i < cc; ++i) {
+      let node = rootNode.getChild(i);
+      if (node.type == node.RESULT_TYPE_FOLDER ||
+          node.type == node.RESULT_TYPE_URI ||
+          node.type == node.RESULT_TYPE_SEPARATOR ||
+          node.type == node.RESULT_TYPE_QUERY) {
+        do_check_true(node.itemId > 0);
+      }
+      else {
+        do_check_eq(node.itemId, -1);
+      }
+    }
+    rootNode.containerOpen = false;
+  }
+  catch (ex) {
+    do_throw("bookmarks query: " + ex);
+  }
+
+  // test that multiple bookmarks with same URI show up right in bookmark
+  // folder queries, todo: also to do for complex folder queries
+  try {
+    // test uri
+    let mURI = uri("http://multiple.uris.in.query");
+
+    let testFolder = bs.createFolder(testRoot, "test Folder", bs.DEFAULT_INDEX);
+    // add 2 bookmarks
+    bs.insertBookmark(testFolder, mURI, bs.DEFAULT_INDEX, "title 1");
+    bs.insertBookmark(testFolder, mURI, bs.DEFAULT_INDEX, "title 2");
+
+    // query
+    options = hs.getNewQueryOptions();
+    query = hs.getNewQuery();
+    query.setFolders([testFolder], 1);
+    let result = hs.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    let cc = rootNode.childCount;
+    do_check_eq(cc, 2);
+    do_check_eq(rootNode.getChild(0).title, "title 1");
+    do_check_eq(rootNode.getChild(1).title, "title 2");
+    rootNode.containerOpen = false;
+  }
+  catch (ex) {
+    do_throw("bookmarks query: " + ex);
+  }
+
+  // test change bookmark uri
+  let newId10 = bs.insertBookmark(testRoot, uri("http://foo10.com/"),
+                                  bs.DEFAULT_INDEX, "");
+  dateAdded = bs.getItemDateAdded(newId10);
+  // after just inserting, modified should not be set
+  lastModified = bs.getItemLastModified(newId10);
+  do_check_eq(lastModified, dateAdded);
+
+  // Workaround possible VM timers issues moving lastModified and dateAdded
+  // to the past.
+  lastModified -= 1000;
+  bs.setItemLastModified(newId10, lastModified);
+  dateAdded -= 1000;
+  bs.setItemDateAdded(newId10, dateAdded);
+
+  bs.changeBookmarkURI(newId10, uri("http://foo11.com/"));
+
+  // check that lastModified is set after we change the bookmark uri
+  lastModified2 = bs.getItemLastModified(newId10);
+  do_print("test changeBookmarkURI");
+  do_print("dateAdded = " + dateAdded);
+  do_print("lastModified = " + lastModified);
+  do_print("lastModified2 = " + lastModified2);
+  do_check_true(is_time_ordered(lastModified, lastModified2));
+  do_check_true(is_time_ordered(dateAdded, lastModified2));
+
+  do_check_eq(bookmarksObserver._itemChangedId, newId10);
+  do_check_eq(bookmarksObserver._itemChangedProperty, "uri");
+  do_check_eq(bookmarksObserver._itemChangedValue, "http://foo11.com/");
+  do_check_eq(bookmarksObserver._itemChangedOldValue, "http://foo10.com/");
+
+  // test getBookmarkURI
+  let newId11 = bs.insertBookmark(testRoot, uri("http://foo11.com/"),
+                                  bs.DEFAULT_INDEX, "");
+  let bmURI = bs.getBookmarkURI(newId11);
+  do_check_eq("http://foo11.com/", bmURI.spec);
+
+  // test getBookmarkURI with non-bookmark items
+  try {
+    bs.getBookmarkURI(testRoot);
+    do_throw("getBookmarkURI() should throw for non-bookmark items!");
+  } catch (ex) {}
+
+  // test getItemIndex
+  let newId12 = bs.insertBookmark(testRoot, uri("http://foo11.com/"), 1, "");
+  let bmIndex = bs.getItemIndex(newId12);
+  do_check_eq(1, bmIndex);
+
+  // insert a bookmark with title ZZZXXXYYY and then search for it.
+  // this test confirms that we can find bookmarks that we haven't visited
+  // (which are "hidden") and that we can find by title.
+  // see bug #369887 for more details
+  let newId13 = bs.insertBookmark(testRoot, uri("http://foobarcheese.com/"),
+                                  bs.DEFAULT_INDEX, "");
+  do_check_eq(bookmarksObserver._itemAddedId, newId13);
+  do_check_eq(bookmarksObserver._itemAddedParent, testRoot);
+  do_check_eq(bookmarksObserver._itemAddedIndex, 11);
+
+  // set bookmark title
+  bs.setItemTitle(newId13, "ZZZXXXYYY");
+  do_check_eq(bookmarksObserver._itemChangedId, newId13);
+  do_check_eq(bookmarksObserver._itemChangedProperty, "title");
+  do_check_eq(bookmarksObserver._itemChangedValue, "ZZZXXXYYY");
+
+  // check if setting an item annotation triggers onItemChanged
+  bookmarksObserver._itemChangedId = -1;
+  anno.setItemAnnotation(newId3, "test-annotation", "foo", 0, 0);
+  do_check_eq(bookmarksObserver._itemChangedId, newId3);
+  do_check_eq(bookmarksObserver._itemChangedProperty, "test-annotation");
+  do_check_true(bookmarksObserver._itemChanged_isAnnotationProperty);
+  do_check_eq(bookmarksObserver._itemChangedValue, "");
+
+  // test search on bookmark title ZZZXXXYYY
+  try {
+    options = hs.getNewQueryOptions();
+    options.excludeQueries = 1;
+    options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+    query = hs.getNewQuery();
+    query.searchTerms = "ZZZXXXYYY";
+    let result = hs.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    let cc = rootNode.childCount;
+    do_check_eq(cc, 1);
+    let node = rootNode.getChild(0);
+    do_check_eq(node.title, "ZZZXXXYYY");
+    do_check_true(node.itemId > 0);
+    rootNode.containerOpen = false;
+  }
+  catch (ex) {
+    do_throw("bookmarks query: " + ex);
+  }
+
+  // test dateAdded and lastModified properties
+  // for a search query
+  try {
+    options = hs.getNewQueryOptions();
+    options.excludeQueries = 1;
+    options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+    query = hs.getNewQuery();
+    query.searchTerms = "ZZZXXXYYY";
+    let result = hs.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    let cc = rootNode.childCount;
+    do_check_eq(cc, 1);
+    let node = rootNode.getChild(0);
+
+    do_check_eq(typeof node.dateAdded, "number");
+    do_check_true(node.dateAdded > 0);
+
+    do_check_eq(typeof node.lastModified, "number");
+    do_check_true(node.lastModified > 0);
+
+    rootNode.containerOpen = false;
+  }
+  catch (ex) {
+    do_throw("bookmarks query: " + ex);
+  }
+
+  // test dateAdded and lastModified properties
+  // for a folder query
+  try {
+    options = hs.getNewQueryOptions();
+    query = hs.getNewQuery();
+    query.setFolders([testRoot], 1);
+    let result = hs.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    let cc = rootNode.childCount;
+    do_check_true(cc > 0);
+    for (let i = 0; i < cc; i++) {
+      let node = rootNode.getChild(i);
+
+      if (node.type == node.RESULT_TYPE_URI) {
+        do_check_eq(typeof node.dateAdded, "number");
+        do_check_true(node.dateAdded > 0);
+
+        do_check_eq(typeof node.lastModified, "number");
+        do_check_true(node.lastModified > 0);
+        break;
+      }
+    }
+    rootNode.containerOpen = false;
+  }
+  catch (ex) {
+    do_throw("bookmarks query: " + ex);
+  }
+
+  // check setItemLastModified() and setItemDateAdded()
+  let newId14 = bs.insertBookmark(testRoot, uri("http://bar.tld/"),
+                                  bs.DEFAULT_INDEX, "");
+  dateAdded = bs.getItemDateAdded(newId14);
+  lastModified = bs.getItemLastModified(newId14);
+  do_check_eq(lastModified, dateAdded);
+  bs.setItemLastModified(newId14, 1234000000000000);
+  let fakeLastModified = bs.getItemLastModified(newId14);
+  do_check_eq(fakeLastModified, 1234000000000000);
+  bs.setItemDateAdded(newId14, 4321000000000000);
+  let fakeDateAdded = bs.getItemDateAdded(newId14);
+  do_check_eq(fakeDateAdded, 4321000000000000);
+
+  // ensure that removing an item removes its annotations
+  do_check_true(anno.itemHasAnnotation(newId3, "test-annotation"));
+  bs.removeItem(newId3);
+  do_check_false(anno.itemHasAnnotation(newId3, "test-annotation"));
+
+  // bug 378820
+  let uri1 = uri("http://foo.tld/a");
+  bs.insertBookmark(testRoot, uri1, bs.DEFAULT_INDEX, "");
+  yield PlacesTestUtils.addVisits(uri1);
+
+  // bug 646993 - test bookmark titles longer than the maximum allowed length
+  let title15 = Array(TITLE_LENGTH_MAX + 5).join("X");
+  let title15expected = title15.substring(0, TITLE_LENGTH_MAX);
+  let newId15 = bs.insertBookmark(testRoot, uri("http://evil.com/"),
+                                  bs.DEFAULT_INDEX, title15);
+
+  do_check_eq(bs.getItemTitle(newId15).length,
+              title15expected.length);
+  do_check_eq(bookmarksObserver._itemAddedTitle, title15expected);
+  // test title length after updates
+  bs.setItemTitle(newId15, title15 + " updated");
+  do_check_eq(bs.getItemTitle(newId15).length,
+              title15expected.length);
+  do_check_eq(bookmarksObserver._itemChangedId, newId15);
+  do_check_eq(bookmarksObserver._itemChangedProperty, "title");
+  do_check_eq(bookmarksObserver._itemChangedValue, title15expected);
+
+  testSimpleFolderResult();
+});
+
+function testSimpleFolderResult() {
+  // the time before we create a folder, in microseconds
+  // Workaround possible VM timers issues subtracting 1us.
+  let beforeCreate = Date.now() * 1000 - 1;
+  do_check_true(beforeCreate > 0);
+
+  // create a folder
+  let parent = bs.createFolder(root, "test", bs.DEFAULT_INDEX);
+
+  let dateCreated = bs.getItemDateAdded(parent);
+  do_print("check that the folder was created with a valid dateAdded");
+  do_print("beforeCreate = " + beforeCreate);
+  do_print("dateCreated = " + dateCreated);
+  do_check_true(is_time_ordered(beforeCreate, dateCreated));
+
+  // the time before we insert, in microseconds
+  // Workaround possible VM timers issues subtracting 1ms.
+  let beforeInsert = Date.now() * 1000 - 1;
+  do_check_true(beforeInsert > 0);
+
+  // insert a separator
+  let sep = bs.insertSeparator(parent, bs.DEFAULT_INDEX);
+
+  let dateAdded = bs.getItemDateAdded(sep);
+  do_print("check that the separator was created with a valid dateAdded");
+  do_print("beforeInsert = " + beforeInsert);
+  do_print("dateAdded = " + dateAdded);
+  do_check_true(is_time_ordered(beforeInsert, dateAdded));
+
+  // re-set item title separately so can test nodes' last modified
+  let item = bs.insertBookmark(parent, uri("about:blank"),
+                               bs.DEFAULT_INDEX, "");
+  bs.setItemTitle(item, "test bookmark");
+
+  // see above
+  let folder = bs.createFolder(parent, "test folder", bs.DEFAULT_INDEX);
+  bs.setItemTitle(folder, "test folder");
+
+  let longName = Array(TITLE_LENGTH_MAX + 5).join("A");
+  let folderLongName = bs.createFolder(parent, longName, bs.DEFAULT_INDEX);
+  do_check_eq(bookmarksObserver._itemAddedTitle, longName.substring(0, TITLE_LENGTH_MAX));
+
+  let options = hs.getNewQueryOptions();
+  let query = hs.getNewQuery();
+  query.setFolders([parent], 1);
+  let result = hs.executeQuery(query, options);
+  let rootNode = result.root;
+  rootNode.containerOpen = true;
+  do_check_eq(rootNode.childCount, 4);
+
+  let node = rootNode.getChild(0);
+  do_check_true(node.dateAdded > 0);
+  do_check_eq(node.lastModified, node.dateAdded);
+  do_check_eq(node.itemId, sep);
+  do_check_eq(node.title, "");
+  node = rootNode.getChild(1);
+  do_check_eq(node.itemId, item);
+  do_check_true(node.dateAdded > 0);
+  do_check_true(node.lastModified > 0);
+  do_check_eq(node.title, "test bookmark");
+  node = rootNode.getChild(2);
+  do_check_eq(node.itemId, folder);
+  do_check_eq(node.title, "test folder");
+  do_check_true(node.dateAdded > 0);
+  do_check_true(node.lastModified > 0);
+  node = rootNode.getChild(3);
+  do_check_eq(node.itemId, folderLongName);
+  do_check_eq(node.title, longName.substring(0, TITLE_LENGTH_MAX));
+  do_check_true(node.dateAdded > 0);
+  do_check_true(node.lastModified > 0);
+
+  // update with another long title
+  bs.setItemTitle(folderLongName, longName + " updated");
+  do_check_eq(bookmarksObserver._itemChangedId, folderLongName);
+  do_check_eq(bookmarksObserver._itemChangedProperty, "title");
+  do_check_eq(bookmarksObserver._itemChangedValue, longName.substring(0, TITLE_LENGTH_MAX));
+
+  node = rootNode.getChild(3);
+  do_check_eq(node.title, longName.substring(0, TITLE_LENGTH_MAX));
+
+  rootNode.containerOpen = false;
+}
+
+function getChildCount(aFolderId) {
+  let cc = -1;
+  try {
+    let options = hs.getNewQueryOptions();
+    let query = hs.getNewQuery();
+    query.setFolders([aFolderId], 1);
+    let result = hs.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    cc = rootNode.childCount;
+    rootNode.containerOpen = false;
+  } catch (ex) {
+    do_throw("getChildCount failed: " + ex);
+  }
+  return cc;
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_eraseEverything.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_eraseEverything.js
new file mode 100644
index 000000000..e8414359b
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_eraseEverything.js
@@ -0,0 +1,116 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* test_eraseEverything() {
+  yield PlacesTestUtils.addVisits({ uri: NetUtil.newURI("http://example.com/") });
+  yield PlacesTestUtils.addVisits({ uri: NetUtil.newURI("http://mozilla.org/") });
+  let frecencyForExample = frecencyForUrl("http://example.com/");
+  let frecencyForMozilla = frecencyForUrl("http://example.com/");
+  Assert.ok(frecencyForExample > 0);
+  Assert.ok(frecencyForMozilla > 0);
+  let unfiledFolder = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                           type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  checkBookmarkObject(unfiledFolder);
+  let unfiledBookmark = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                             type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                             url: "http://example.com/" });
+  checkBookmarkObject(unfiledBookmark);
+  let unfiledBookmarkInFolder =
+    yield PlacesUtils.bookmarks.insert({ parentGuid: unfiledFolder.guid,
+                                         type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                         url: "http://mozilla.org/" });
+  checkBookmarkObject(unfiledBookmarkInFolder);
+  PlacesUtils.annotations.setItemAnnotation((yield PlacesUtils.promiseItemId(unfiledBookmarkInFolder.guid)),
+                                            "testanno1", "testvalue1", 0, 0);
+
+  let menuFolder = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.menuGuid,
+                                                        type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  checkBookmarkObject(menuFolder);
+  let menuBookmark = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.menuGuid,
+                                                          type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                          url: "http://example.com/" });
+  checkBookmarkObject(menuBookmark);
+  let menuBookmarkInFolder =
+    yield PlacesUtils.bookmarks.insert({ parentGuid: menuFolder.guid,
+                                         type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                         url: "http://mozilla.org/" });
+  checkBookmarkObject(menuBookmarkInFolder);
+  PlacesUtils.annotations.setItemAnnotation((yield PlacesUtils.promiseItemId(menuBookmarkInFolder.guid)),
+                                            "testanno1", "testvalue1", 0, 0);
+
+  let toolbarFolder = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+                                                           type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  checkBookmarkObject(toolbarFolder);
+  let toolbarBookmark = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+                                                             type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                             url: "http://example.com/" });
+  checkBookmarkObject(toolbarBookmark);
+  let toolbarBookmarkInFolder =
+    yield PlacesUtils.bookmarks.insert({ parentGuid: toolbarFolder.guid,
+                                         type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                         url: "http://mozilla.org/" });
+  checkBookmarkObject(toolbarBookmarkInFolder);
+  PlacesUtils.annotations.setItemAnnotation((yield PlacesUtils.promiseItemId(toolbarBookmarkInFolder.guid)),
+                                            "testanno1", "testvalue1", 0, 0);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  Assert.ok(frecencyForUrl("http://example.com/") > frecencyForExample);
+  Assert.ok(frecencyForUrl("http://example.com/") > frecencyForMozilla);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  Assert.equal(frecencyForUrl("http://example.com/"), frecencyForExample);
+  Assert.equal(frecencyForUrl("http://example.com/"), frecencyForMozilla);
+
+  // Check there are no orphan annotations.
+  let conn = yield PlacesUtils.promiseDBConnection();
+  let annoAttrs = yield conn.execute(`SELECT id, name FROM moz_anno_attributes`);
+  // Bug 1306445 will eventually remove the mobile root anno.
+  Assert.equal(annoAttrs.length, 1);
+  Assert.equal(annoAttrs[0].getResultByName("name"), PlacesUtils.MOBILE_ROOT_ANNO);
+  let annos = rows = yield conn.execute(`SELECT item_id, anno_attribute_id FROM moz_items_annos`);
+  Assert.equal(annos.length, 1);
+  Assert.equal(annos[0].getResultByName("item_id"), PlacesUtils.mobileFolderId);
+  Assert.equal(annos[0].getResultByName("anno_attribute_id"), annoAttrs[0].getResultByName("id"));
+});
+
+add_task(function* test_eraseEverything_roots() {
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  // Ensure the roots have not been removed.
+  Assert.ok(yield PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.unfiledGuid));
+  Assert.ok(yield PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.toolbarGuid));
+  Assert.ok(yield PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.menuGuid));
+  Assert.ok(yield PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.tagsGuid));
+  Assert.ok(yield PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.rootGuid));
+});
+
+add_task(function* test_eraseEverything_reparented() {
+  // Create a folder with 1 bookmark in it...
+  let folder1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER
+  });
+  let bookmark1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: folder1.guid,
+    url: "http://example.com/"
+  });
+  // ...and a second folder.
+  let folder2 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER
+  });
+
+  // Reparent the bookmark to the 2nd folder.
+  bookmark1.parentGuid = folder2.guid;
+  yield PlacesUtils.bookmarks.update(bookmark1);
+
+  // Erase everything.
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  // All the above items should no longer be in the GUIDHelper cache.
+  for (let guid of [folder1.guid, bookmark1.guid, folder2.guid]) {
+    yield Assert.rejects(PlacesUtils.promiseItemId(guid),
+                         /no item found for the given GUID/);
+  }
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_fetch.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_fetch.js
new file mode 100644
index 000000000..9527f02e6
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_fetch.js
@@ -0,0 +1,310 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var gAccumulator = {
+  get callback() {
+    this.results = [];
+    return result => this.results.push(result);
+  }
+};
+
+add_task(function* invalid_input_throws() {
+  Assert.throws(() => PlacesUtils.bookmarks.fetch(),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch(null),
+                /Input should be a valid object/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ guid: "123456789012",
+                                                    parentGuid: "012345678901" }),
+                /The following properties were expected: index/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ guid: "123456789012",
+                                                    index: 0 }),
+                /The following properties were expected: parentGuid/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({}),
+                /Unexpected number of conditions provided: 0/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ guid: "123456789012",
+                                                    parentGuid: "012345678901",
+                                                    index: 0 }),
+                /Unexpected number of conditions provided: 2/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ guid: "123456789012",
+                                                    url: "http://example.com"}),
+                /Unexpected number of conditions provided: 2/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.fetch("test"),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch(123),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ guid: "test" }),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ guid: null }),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ guid: 123 }),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ parentGuid: "test",
+                                                    index: 0 }),
+                /Invalid value for property 'parentGuid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ parentGuid: null,
+                                                    index: 0 }),
+                /Invalid value for property 'parentGuid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ parentGuid: 123,
+                                                    index: 0 }),
+                /Invalid value for property 'parentGuid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ parentGuid: "123456789012",
+                                                    index: "0" }),
+                /Invalid value for property 'index'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ parentGuid: "123456789012",
+                                                    index: null }),
+                /Invalid value for property 'index'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ parentGuid: "123456789012",
+                                                    index: -10 }),
+                /Invalid value for property 'index'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ url: "http://te st/" }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ url: null }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch({ url: -10 }),
+                /Invalid value for property 'url'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.fetch("123456789012", "test"),
+                /onResult callback must be a valid function/);
+  Assert.throws(() => PlacesUtils.bookmarks.fetch("123456789012", {}),
+                /onResult callback must be a valid function/);
+});
+
+add_task(function* fetch_nonexistent_guid() {
+  let bm = yield PlacesUtils.bookmarks.fetch({ guid: "123456789012" },
+                                               gAccumulator.callback);
+  Assert.equal(bm, null);
+  Assert.equal(gAccumulator.results.length, 0);
+});
+
+add_task(function* fetch_bookmark() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.fetch(bm1.guid,
+                                              gAccumulator.callback);
+  checkBookmarkObject(bm2);
+  Assert.equal(gAccumulator.results.length, 1);
+  checkBookmarkObject(gAccumulator.results[0]);
+  Assert.deepEqual(gAccumulator.results[0], bm1);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm2.index, 0);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+  Assert.equal(bm2.url.href, "http://example.com/");
+  Assert.equal(bm2.title, "a bookmark");
+
+  yield PlacesUtils.bookmarks.remove(bm1.guid);
+});
+
+add_task(function* fetch_bookmar_empty_title() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://example.com/",
+                                                 title: "" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.fetch(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.index, 0);
+  Assert.ok(!("title" in bm2));
+
+  yield PlacesUtils.bookmarks.remove(bm1.guid);
+});
+
+add_task(function* fetch_folder() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                 title: "a folder" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.fetch(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm2.index, 0);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_FOLDER);
+  Assert.equal(bm2.title, "a folder");
+  Assert.ok(!("url" in bm2));
+
+  yield PlacesUtils.bookmarks.remove(bm1.guid);
+});
+
+add_task(function* fetch_folder_empty_title() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                 title: "" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.fetch(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.index, 0);
+  Assert.ok(!("title" in bm2));
+
+  yield PlacesUtils.bookmarks.remove(bm1.guid);
+});
+
+add_task(function* fetch_separator() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_SEPARATOR });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.fetch(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm2.index, 0);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
+  Assert.ok(!("url" in bm2));
+  Assert.ok(!("title" in bm2));
+
+  yield PlacesUtils.bookmarks.remove(bm1.guid);
+});
+
+add_task(function* fetch_byposition_nonexisting_parentGuid() {
+  let bm = yield PlacesUtils.bookmarks.fetch({ parentGuid: "123456789012",
+                                               index: 0 },
+                                             gAccumulator.callback);
+  Assert.equal(bm, null);
+  Assert.equal(gAccumulator.results.length, 0);
+});
+
+add_task(function* fetch_byposition_nonexisting_index() {
+  let bm = yield PlacesUtils.bookmarks.fetch({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                               index: 100 },
+                                             gAccumulator.callback);
+  Assert.equal(bm, null);
+  Assert.equal(gAccumulator.results.length, 0);
+});
+
+add_task(function* fetch_byposition() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.fetch({ parentGuid: bm1.parentGuid,
+                                                index: bm1.index },
+                                              gAccumulator.callback);
+  checkBookmarkObject(bm2);
+  Assert.equal(gAccumulator.results.length, 1);
+  checkBookmarkObject(gAccumulator.results[0]);
+  Assert.deepEqual(gAccumulator.results[0], bm1);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm2.index, 0);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+  Assert.equal(bm2.url.href, "http://example.com/");
+  Assert.equal(bm2.title, "a bookmark");
+});
+
+add_task(function* fetch_byposition_default_index() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://example.com/last",
+                                                 title: "last child" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.fetch({ parentGuid: bm1.parentGuid,
+                                                index: PlacesUtils.bookmarks.DEFAULT_INDEX },
+                                              gAccumulator.callback);
+  checkBookmarkObject(bm2);
+  Assert.equal(gAccumulator.results.length, 1);
+  checkBookmarkObject(gAccumulator.results[0]);
+  Assert.deepEqual(gAccumulator.results[0], bm1);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm2.index, 1);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+  Assert.equal(bm2.url.href, "http://example.com/last");
+  Assert.equal(bm2.title, "last child");
+
+  yield PlacesUtils.bookmarks.remove(bm1.guid);
+});
+
+add_task(function* fetch_byurl_nonexisting() {
+  let bm = yield PlacesUtils.bookmarks.fetch({ url: "http://nonexisting.com/" },
+                                             gAccumulator.callback);
+  Assert.equal(bm, null);
+  Assert.equal(gAccumulator.results.length, 0);
+});
+
+add_task(function* fetch_byurl() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://byurl.com/",
+                                                 title: "a bookmark" });
+  checkBookmarkObject(bm1);
+
+  // Also ensure that fecth-by-url excludes the tags folder.
+  PlacesUtils.tagging.tagURI(uri(bm1.url.href), ["Test Tag"]);
+
+  let bm2 = yield PlacesUtils.bookmarks.fetch({ url: bm1.url },
+                                              gAccumulator.callback);
+  checkBookmarkObject(bm2);
+  Assert.equal(gAccumulator.results.length, 1);
+  checkBookmarkObject(gAccumulator.results[0]);
+  Assert.deepEqual(gAccumulator.results[0], bm1);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+  Assert.equal(bm2.url.href, "http://byurl.com/");
+  Assert.equal(bm2.title, "a bookmark");
+
+  let bm3 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://byurl.com/",
+                                                 title: "a bookmark" });
+  let bm4 = yield PlacesUtils.bookmarks.fetch({ url: bm1.url },
+                                              gAccumulator.callback);
+  checkBookmarkObject(bm4);
+  Assert.deepEqual(bm3, bm4);
+  Assert.equal(gAccumulator.results.length, 2);
+  gAccumulator.results.forEach(checkBookmarkObject);
+  Assert.deepEqual(gAccumulator.results[0], bm4);
+
+  // After an update the returned bookmark should change.
+  yield PlacesUtils.bookmarks.update({ guid: bm1.guid, title: "new title" });
+  let bm5 = yield PlacesUtils.bookmarks.fetch({ url: bm1.url },
+                                              gAccumulator.callback);
+  checkBookmarkObject(bm5);
+  // Cannot use deepEqual cause lastModified changed.
+  Assert.equal(bm1.guid, bm5.guid);
+  Assert.ok(bm5.lastModified > bm1.lastModified);
+  Assert.equal(gAccumulator.results.length, 2);
+  gAccumulator.results.forEach(checkBookmarkObject);
+  Assert.deepEqual(gAccumulator.results[0], bm5);
+
+  // cleanup
+  PlacesUtils.tagging.untagURI(uri(bm1.url.href), ["Test Tag"]);
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_getRecent.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_getRecent.js
new file mode 100644
index 000000000..35166bd95
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_getRecent.js
@@ -0,0 +1,44 @@
+add_task(function* invalid_input_throws() {
+  Assert.throws(() => PlacesUtils.bookmarks.getRecent(),
+                /numberOfItems argument is required/);
+  Assert.throws(() => PlacesUtils.bookmarks.getRecent("abc"),
+                /numberOfItems argument must be an integer/);
+  Assert.throws(() => PlacesUtils.bookmarks.getRecent(1.2),
+                /numberOfItems argument must be an integer/);
+  Assert.throws(() => PlacesUtils.bookmarks.getRecent(0),
+                /numberOfItems argument must be greater than zero/);
+  Assert.throws(() => PlacesUtils.bookmarks.getRecent(-1),
+                /numberOfItems argument must be greater than zero/);
+});
+
+add_task(function* getRecent_returns_recent_bookmarks() {
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  let bm2 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.org/path",
+                                                 title: "another bookmark" });
+  let bm3 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.net/",
+                                                 title: "another bookmark" });
+  let bm4 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.net/path",
+                                                 title: "yet another bookmark" });
+  checkBookmarkObject(bm1);
+  checkBookmarkObject(bm2);
+  checkBookmarkObject(bm3);
+  checkBookmarkObject(bm4);
+
+  let results = yield PlacesUtils.bookmarks.getRecent(3);
+  Assert.equal(results.length, 3);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm4, results[0]);
+  checkBookmarkObject(results[1]);
+  Assert.deepEqual(bm3, results[1]);
+  checkBookmarkObject(results[2]);
+  Assert.deepEqual(bm2, results[2]);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_insert.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_insert.js
new file mode 100644
index 000000000..0f772a92f
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_insert.js
@@ -0,0 +1,264 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* invalid_input_throws() {
+  Assert.throws(() => PlacesUtils.bookmarks.insert(),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert(null),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({}),
+                /The following properties were expected/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ guid: "test" }),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ guid: null }),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ guid: 123 }),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ parentGuid: "test" }),
+                /Invalid value for property 'parentGuid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ parentGuid: null }),
+                /Invalid value for property 'parentGuid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ parentGuid: 123 }),
+                /Invalid value for property 'parentGuid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ index: "1" }),
+                /Invalid value for property 'index'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ index: -10 }),
+                /Invalid value for property 'index'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ dateAdded: -10 }),
+                /Invalid value for property 'dateAdded'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ dateAdded: "today" }),
+                /Invalid value for property 'dateAdded'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ dateAdded: Date.now() }),
+                /Invalid value for property 'dateAdded'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ lastModified: -10 }),
+                /Invalid value for property 'lastModified'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ lastModified: "today" }),
+                /Invalid value for property 'lastModified'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ lastModified: Date.now() }),
+                /Invalid value for property 'lastModified'/);
+  let time = new Date();
+  let future = new Date(time + 86400000);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ dateAdded: future,
+                                                     lastModified: time }),
+                /Invalid value for property 'dateAdded'/);
+  let past = new Date(time - 86400000);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ lastModified: past }),
+                /Invalid value for property 'lastModified'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: -1 }),
+                /Invalid value for property 'type'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: 100 }),
+                /Invalid value for property 'type'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: "bookmark" }),
+                /Invalid value for property 'type'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                     title: -1 }),
+                /Invalid value for property 'title'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                     url: 10 }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                     url: "http://te st" }),
+                /Invalid value for property 'url'/);
+  let longurl = "http://www.example.com/";
+  for (let i = 0; i < 65536; i++) {
+    longurl += "a";
+  }
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                     url: longurl }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                     url: NetUtil.newURI(longurl) }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                     url: "te st" }),
+                /Invalid value for property 'url'/);
+});
+
+add_task(function* invalid_properties_for_bookmark_type() {
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     url: "http://www.moz.com/" }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                                     url: "http://www.moz.com/" }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                                     title: "test" }),
+                /Invalid value for property 'title'/);
+});
+
+add_task(function* long_title_trim() {
+  let longtitle = "a";
+  for (let i = 0; i < 4096; i++) {
+    longtitle += "a";
+  }
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                title: longtitle });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm.index, 0);
+  Assert.equal(bm.dateAdded, bm.lastModified);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_FOLDER);
+  Assert.equal(bm.title.length, 4096, "title should have been trimmed");
+  Assert.ok(!("url" in bm), "url should not be set");
+});
+
+add_task(function* create_separator() {
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                                index: PlacesUtils.bookmarks.DEFAULT_INDEX });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm.index, 1);
+  Assert.equal(bm.dateAdded, bm.lastModified);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
+  Assert.ok(!("title" in bm), "title should not be set");
+});
+
+add_task(function* create_separator_w_title_fail() {
+  try {
+    yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                         type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                         title: "a separator" });
+    Assert.ok(false, "Trying to set title for a separator should reject");
+  } catch (ex) {}
+});
+
+add_task(function* create_separator_invalid_parent_fail() {
+  try {
+    yield PlacesUtils.bookmarks.insert({ parentGuid: "123456789012",
+                                         type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                         title: "a separator" });
+    Assert.ok(false, "Trying to create an item in a non existing parent reject");
+  } catch (ex) {}
+});
+
+add_task(function* create_separator_given_guid() {
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                                index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                guid: "123456789012" });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.guid, "123456789012");
+  Assert.equal(bm.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm.index, 2);
+  Assert.equal(bm.dateAdded, bm.lastModified);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
+  Assert.ok(!("title" in bm), "title should not be set");
+});
+
+add_task(function* create_item_given_guid_no_type_fail() {
+  try {
+    yield PlacesUtils.bookmarks.insert({ parentGuid: "123456789012" });
+    Assert.ok(false, "Trying to create an item with a given guid but no type should reject");
+  } catch (ex) {}
+});
+
+add_task(function* create_separator_big_index() {
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                                index: 9999 });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm.index, 3);
+  Assert.equal(bm.dateAdded, bm.lastModified);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
+  Assert.ok(!("title" in bm), "title should not be set");
+});
+
+add_task(function* create_separator_given_dateAdded() {
+  let time = new Date();
+  let past = new Date(time - 86400000);
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                                dateAdded: past });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.dateAdded, past);
+  Assert.equal(bm.lastModified, past);
+});
+
+add_task(function* create_folder() {
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm.dateAdded, bm.lastModified);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_FOLDER);
+  Assert.ok(!("title" in bm), "title should not be set");
+
+  // And then create a nested folder.
+  let parentGuid = bm.guid;
+  bm = yield PlacesUtils.bookmarks.insert({ parentGuid: parentGuid,
+                                            type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                            title: "a folder" });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, parentGuid);
+  Assert.equal(bm.index, 0);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_FOLDER);
+  Assert.strictEqual(bm.title, "a folder");
+});
+
+add_task(function* create_bookmark() {
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  let parentGuid = bm.guid;
+
+  bm = yield PlacesUtils.bookmarks.insert({ parentGuid: parentGuid,
+                                            type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                            url: "http://example.com/",
+                                            title: "a bookmark" });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, parentGuid);
+  Assert.equal(bm.index, 0);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+  Assert.equal(bm.url.href, "http://example.com/");
+  Assert.equal(bm.title, "a bookmark");
+
+  // Check parent lastModified.
+  let parent = yield PlacesUtils.bookmarks.fetch({ guid: bm.parentGuid });
+  Assert.deepEqual(parent.lastModified, bm.dateAdded);
+
+  bm = yield PlacesUtils.bookmarks.insert({ parentGuid: parentGuid,
+                                            type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                            url: new URL("http://example.com/") });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, parentGuid);
+  Assert.equal(bm.index, 1);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+  Assert.equal(bm.url.href, "http://example.com/");
+  Assert.ok(!("title" in bm), "title should not be set");
+});
+
+add_task(function* create_bookmark_frecency() {
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                url: "http://example.com/",
+                                                title: "a bookmark" });
+  checkBookmarkObject(bm);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  Assert.ok(frecencyForUrl(bm.url) > 0, "Check frecency has been updated")
+});
+
+add_task(function* create_bookmark_without_type() {
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: "http://example.com/",
+                                                title: "a bookmark" });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+  Assert.equal(bm.url.href, "http://example.com/");
+  Assert.equal(bm.title, "a bookmark");
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_notifications.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_notifications.js
new file mode 100644
index 000000000..02787425d
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_notifications.js
@@ -0,0 +1,527 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* insert_separator_notification() {
+  let observer = expectNotifications();
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid});
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+  observer.check([ { name: "onItemAdded",
+                     arguments: [ itemId, parentId, bm.index, bm.type,
+                                  null, null, bm.dateAdded,
+                                  bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* insert_folder_notification() {
+  let observer = expectNotifications();
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                title: "a folder" });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+  observer.check([ { name: "onItemAdded",
+                     arguments: [ itemId, parentId, bm.index, bm.type,
+                                  null, bm.title, bm.dateAdded,
+                                  bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* insert_folder_notitle_notification() {
+  let observer = expectNotifications();
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+  observer.check([ { name: "onItemAdded",
+                     arguments: [ itemId, parentId, bm.index, bm.type,
+                                  null, null, bm.dateAdded,
+                                  bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* insert_bookmark_notification() {
+  let observer = expectNotifications();
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://example.com/"),
+                                                title: "a bookmark" });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+  observer.check([ { name: "onItemAdded",
+                     arguments: [ itemId, parentId, bm.index, bm.type,
+                                  bm.url, bm.title, bm.dateAdded,
+                                  bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* insert_bookmark_notitle_notification() {
+  let observer = expectNotifications();
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://example.com/") });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+  observer.check([ { name: "onItemAdded",
+                     arguments: [ itemId, parentId, bm.index, bm.type,
+                                  bm.url, null, bm.dateAdded,
+                                  bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* insert_bookmark_tag_notification() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://tag.example.com/") });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  let tagFolder = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                       parentGuid: PlacesUtils.bookmarks.tagsGuid,
+                                                       title: "tag" });
+  let observer = expectNotifications();
+  let tag = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 parentGuid: tagFolder.guid,
+                                                 url: new URL("http://tag.example.com/") });
+  let tagId = yield PlacesUtils.promiseItemId(tag.guid);
+  let tagParentId = yield PlacesUtils.promiseItemId(tag.parentGuid);
+
+  observer.check([ { name: "onItemAdded",
+                     arguments: [ tagId, tagParentId, tag.index, tag.type,
+                                  tag.url, null, tag.dateAdded,
+                                  tag.guid, tag.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemChanged",
+                     arguments: [ itemId, "tags", false, "",
+                                  bm.lastModified, bm.type, parentId,
+                                  bm.guid, bm.parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* update_bookmark_lastModified() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://lastmod.example.com/") });
+  let observer = expectNotifications();
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            lastModified: new Date() });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  observer.check([ { name: "onItemChanged",
+                     arguments: [ itemId, "lastModified", false,
+                                  `${bm.lastModified * 1000}`, bm.lastModified,
+                                  bm.type, parentId, bm.guid, bm.parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* update_bookmark_title() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://title.example.com/") });
+  let observer = expectNotifications();
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            title: "new title" });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  observer.check([ { name: "onItemChanged",
+                     arguments: [ itemId, "title", false, bm.title,
+                                  bm.lastModified, bm.type, parentId, bm.guid,
+                                  bm.parentGuid, "", Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* update_bookmark_uri() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://url.example.com/") });
+  let observer = expectNotifications();
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            url: "http://mozilla.org/" });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  observer.check([ { name: "onItemChanged",
+                     arguments: [ itemId, "uri", false, bm.url.href,
+                                  bm.lastModified, bm.type, parentId, bm.guid,
+                                  bm.parentGuid, "http://url.example.com/",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* update_move_same_folder() {
+  // Ensure there are at least two items in place (others test do so for us,
+  // but we don't have to depend on that).
+  yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                       parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://move.example.com/") });
+  let bmItemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let bmParentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+  let bmOldIndex = bm.index;
+
+  let observer = expectNotifications();
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                            index: 0 });
+  Assert.equal(bm.index, 0);
+  observer.check([ { name: "onItemMoved",
+                     arguments: [ bmItemId, bmParentId, bmOldIndex, bmParentId, bm.index,
+                                  bm.type, bm.guid, bm.parentGuid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+
+  // Test that we get the right index for DEFAULT_INDEX input.
+  bmOldIndex = 0;
+  observer = expectNotifications();
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                            index: PlacesUtils.bookmarks.DEFAULT_INDEX });
+  Assert.ok(bm.index > 0);
+  observer.check([ { name: "onItemMoved",
+                     arguments: [ bmItemId, bmParentId, bmOldIndex, bmParentId, bm.index,
+                                  bm.type, bm.guid, bm.parentGuid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* update_move_different_folder() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://move.example.com/") });
+  let folder = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                    parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let bmItemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let bmOldParentId = PlacesUtils.unfiledBookmarksFolderId;
+  let bmOldIndex = bm.index;
+
+  let observer = expectNotifications();
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            parentGuid: folder.guid,
+                                            index: PlacesUtils.bookmarks.DEFAULT_INDEX });
+  Assert.equal(bm.index, 0);
+  let bmNewParentId = yield PlacesUtils.promiseItemId(folder.guid);
+  observer.check([ { name: "onItemMoved",
+                     arguments: [ bmItemId, bmOldParentId, bmOldIndex, bmNewParentId,
+                                  bm.index, bm.type, bm.guid,
+                                  PlacesUtils.bookmarks.unfiledGuid,
+                                  bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* remove_bookmark() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://remove.example.com/") });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  let observer = expectNotifications();
+  bm = yield PlacesUtils.bookmarks.remove(bm.guid);
+  // TODO (Bug 653910): onItemAnnotationRemoved notified even if there were no
+  // annotations.
+  observer.check([ { name: "onItemRemoved",
+                     arguments: [ itemId, parentId, bm.index, bm.type, bm.url,
+                                  bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* remove_folder() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  let observer = expectNotifications();
+  bm = yield PlacesUtils.bookmarks.remove(bm.guid);
+  observer.check([ { name: "onItemRemoved",
+                     arguments: [ itemId, parentId, bm.index, bm.type, null,
+                                  bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* remove_bookmark_tag_notification() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: new URL("http://untag.example.com/") });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  let tagFolder = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                       parentGuid: PlacesUtils.bookmarks.tagsGuid,
+                                                       title: "tag" });
+  let tag = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 parentGuid: tagFolder.guid,
+                                                 url: new URL("http://untag.example.com/") });
+  let tagId = yield PlacesUtils.promiseItemId(tag.guid);
+  let tagParentId = yield PlacesUtils.promiseItemId(tag.parentGuid);
+
+  let observer = expectNotifications();
+  yield PlacesUtils.bookmarks.remove(tag.guid);
+
+  observer.check([ { name: "onItemRemoved",
+                     arguments: [ tagId, tagParentId, tag.index, tag.type,
+                                  tag.url, tag.guid, tag.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemChanged",
+                     arguments: [ itemId, "tags", false, "",
+                                  bm.lastModified, bm.type, parentId,
+                                  bm.guid, bm.parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* remove_folder_notification() {
+  let folder1 = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let folder1Id = yield PlacesUtils.promiseItemId(folder1.guid);
+  let folder1ParentId = yield PlacesUtils.promiseItemId(folder1.parentGuid);
+
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: folder1.guid,
+                                                url: new URL("http://example.com/") });
+  let bmItemId = yield PlacesUtils.promiseItemId(bm.guid);
+
+  let folder2 = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     parentGuid: folder1.guid });
+  let folder2Id = yield PlacesUtils.promiseItemId(folder2.guid);
+
+  let bm2 = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 parentGuid: folder2.guid,
+                                                 url: new URL("http://example.com/") });
+  let bm2ItemId = yield PlacesUtils.promiseItemId(bm2.guid);
+
+  let observer = expectNotifications();
+  yield PlacesUtils.bookmarks.remove(folder1.guid);
+
+  observer.check([ { name: "onItemRemoved",
+                     arguments: [ bm2ItemId, folder2Id, bm2.index, bm2.type,
+                                  bm2.url, bm2.guid, bm2.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemRemoved",
+                     arguments: [ folder2Id, folder1Id, folder2.index,
+                                  folder2.type, null, folder2.guid,
+                                  folder2.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemRemoved",
+                     arguments: [ bmItemId, folder1Id, bm.index, bm.type,
+                                  bm.url, bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemRemoved",
+                     arguments: [ folder1Id, folder1ParentId, folder1.index,
+                                  folder1.type, null, folder1.guid,
+                                  folder1.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+});
+
+add_task(function* eraseEverything_notification() {
+  // Let's start from a clean situation.
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  let folder1 = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let folder1Id = yield PlacesUtils.promiseItemId(folder1.guid);
+  let folder1ParentId = yield PlacesUtils.promiseItemId(folder1.parentGuid);
+
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: folder1.guid,
+                                                url: new URL("http://example.com/") });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  let folder2 = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let folder2Id = yield PlacesUtils.promiseItemId(folder2.guid);
+  let folder2ParentId = yield PlacesUtils.promiseItemId(folder2.parentGuid);
+
+  let toolbarBm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                       parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+                                                       url: new URL("http://example.com/") });
+  let toolbarBmId = yield PlacesUtils.promiseItemId(toolbarBm.guid);
+  let toolbarBmParentId = yield PlacesUtils.promiseItemId(toolbarBm.parentGuid);
+
+  let menuBm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                    parentGuid: PlacesUtils.bookmarks.menuGuid,
+                                                    url: new URL("http://example.com/") });
+  let menuBmId = yield PlacesUtils.promiseItemId(menuBm.guid);
+  let menuBmParentId = yield PlacesUtils.promiseItemId(menuBm.parentGuid);
+
+  let observer = expectNotifications();
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  // Bookmarks should always be notified before their parents.
+  observer.check([ { name: "onItemRemoved",
+                     arguments: [ itemId, parentId, bm.index, bm.type,
+                                  bm.url, bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemRemoved",
+                     arguments: [ folder2Id, folder2ParentId, folder2.index,
+                                  folder2.type, null, folder2.guid,
+                                  folder2.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemRemoved",
+                     arguments: [ folder1Id, folder1ParentId, folder1.index,
+                                  folder1.type, null, folder1.guid,
+                                  folder1.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemRemoved",
+                     arguments: [ menuBmId, menuBmParentId,
+                                  menuBm.index, menuBm.type,
+                                  menuBm.url, menuBm.guid,
+                                  menuBm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                    { name: "onItemRemoved",
+                     arguments: [ toolbarBmId, toolbarBmParentId,
+                                  toolbarBm.index, toolbarBm.type,
+                                  toolbarBm.url, toolbarBm.guid,
+                                  toolbarBm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                 ]);
+});
+
+add_task(function* eraseEverything_reparented_notification() {
+  // Let's start from a clean situation.
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  let folder1 = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let folder1Id = yield PlacesUtils.promiseItemId(folder1.guid);
+  let folder1ParentId = yield PlacesUtils.promiseItemId(folder1.parentGuid);
+
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: folder1.guid,
+                                                url: new URL("http://example.com/") });
+  let itemId = yield PlacesUtils.promiseItemId(bm.guid);
+
+  let folder2 = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let folder2Id = yield PlacesUtils.promiseItemId(folder2.guid);
+  let folder2ParentId = yield PlacesUtils.promiseItemId(folder2.parentGuid);
+
+  bm.parentGuid = folder2.guid;
+  bm = yield PlacesUtils.bookmarks.update(bm);
+  let parentId = yield PlacesUtils.promiseItemId(bm.parentGuid);
+
+  let observer = expectNotifications();
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  // Bookmarks should always be notified before their parents.
+  observer.check([ { name: "onItemRemoved",
+                     arguments: [ itemId, parentId, bm.index, bm.type,
+                                  bm.url, bm.guid, bm.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemRemoved",
+                     arguments: [ folder2Id, folder2ParentId, folder2.index,
+                                  folder2.type, null, folder2.guid,
+                                  folder2.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                   { name: "onItemRemoved",
+                     arguments: [ folder1Id, folder1ParentId, folder1.index,
+                                  folder1.type, null, folder1.guid,
+                                  folder1.parentGuid,
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                 ]);
+});
+
+add_task(function* reorder_notification() {
+  let bookmarks = [
+    { type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+      url: "http://example1.com/",
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+    { type: PlacesUtils.bookmarks.TYPE_FOLDER,
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+    { type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+    { type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+      url: "http://example2.com/",
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+    { type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+      url: "http://example3.com/",
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+  ];
+  let sorted = [];
+  for (let bm of bookmarks) {
+    sorted.push(yield PlacesUtils.bookmarks.insert(bm));
+  }
+
+  // Randomly reorder the array.
+  sorted.sort(() => 0.5 - Math.random());
+
+  let observer = expectNotifications();
+  yield PlacesUtils.bookmarks.reorder(PlacesUtils.bookmarks.unfiledGuid,
+                                      sorted.map(bm => bm.guid));
+
+  let expectedNotifications = [];
+  for (let i = 0; i < sorted.length; ++i) {
+    let child = sorted[i];
+    let childId = yield PlacesUtils.promiseItemId(child.guid);
+    expectedNotifications.push({ name: "onItemMoved",
+                                 arguments: [ childId,
+                                              PlacesUtils.unfiledBookmarksFolderId,
+                                              child.index,
+                                              PlacesUtils.unfiledBookmarksFolderId,
+                                              i,
+                                              child.type,
+                                              child.guid,
+                                              child.parentGuid,
+                                              child.parentGuid,
+                                              Ci.nsINavBookmarksService.SOURCE_DEFAULT
+                                            ] });
+  }
+  observer.check(expectedNotifications);
+});
+
+function expectNotifications() {
+  let notifications = [];
+  let observer = new Proxy(NavBookmarkObserver, {
+    get(target, name) {
+      if (name == "check") {
+        PlacesUtils.bookmarks.removeObserver(observer);
+        return expectedNotifications =>
+          Assert.deepEqual(notifications, expectedNotifications);
+      }
+
+      if (name.startsWith("onItem")) {
+        return (...origArgs) => {
+          let args = Array.from(origArgs, arg => {
+            if (arg && arg instanceof Ci.nsIURI)
+              return new URL(arg.spec);
+            if (arg && typeof(arg) == "number" && arg >= Date.now() * 1000)
+              return new Date(parseInt(arg/1000));
+            return arg;
+          });
+          notifications.push({ name: name, arguments: args });
+        }
+      }
+
+      if (name in target)
+        return target[name];
+      return undefined;
+    }
+  });
+  PlacesUtils.bookmarks.addObserver(observer, false);
+  return observer;
+}
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_remove.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_remove.js
new file mode 100644
index 000000000..19085a282
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_remove.js
@@ -0,0 +1,204 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* invalid_input_throws() {
+  Assert.throws(() => PlacesUtils.bookmarks.remove(),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.bookmarks.remove(null),
+                /Input should be a valid object/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.remove("test"),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.remove(123),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ guid: "test" }),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ guid: null }),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ guid: 123 }),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ parentGuid: "test" }),
+                /Invalid value for property 'parentGuid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ parentGuid: null }),
+                /Invalid value for property 'parentGuid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ parentGuid: 123 }),
+                /Invalid value for property 'parentGuid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ url: "http://te st/" }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ url: null }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.remove({ url: -10 }),
+                /Invalid value for property 'url'/);
+});
+
+add_task(function* remove_nonexistent_guid() {
+  try {
+    yield PlacesUtils.bookmarks.remove({ guid: "123456789012"});
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/No bookmarks found for the provided GUID/.test(ex));
+  }
+});
+
+add_task(function* remove_roots_fail() {
+  let guids = [PlacesUtils.bookmarks.rootGuid,
+               PlacesUtils.bookmarks.unfiledGuid,
+               PlacesUtils.bookmarks.menuGuid,
+               PlacesUtils.bookmarks.toolbarGuid,
+               PlacesUtils.bookmarks.tagsGuid,
+               PlacesUtils.bookmarks.mobileGuid];
+  for (let guid of guids) {
+    Assert.throws(() => PlacesUtils.bookmarks.remove(guid),
+                  /It's not possible to remove Places root folders/);
+  }
+});
+
+add_task(function* remove_normal_folder_under_root_succeeds() {
+  let folder = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.rootGuid,
+                                                    type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  checkBookmarkObject(folder);
+  let removed_folder = yield PlacesUtils.bookmarks.remove(folder);
+  Assert.deepEqual(folder, removed_folder);
+  Assert.strictEqual((yield PlacesUtils.bookmarks.fetch(folder.guid)), null);
+});
+
+add_task(function* remove_bookmark() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.remove(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm2.index, 0);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+  Assert.equal(bm2.url.href, "http://example.com/");
+  Assert.equal(bm2.title, "a bookmark");
+});
+
+
+add_task(function* remove_bookmark_orphans() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  checkBookmarkObject(bm1);
+  PlacesUtils.annotations.setItemAnnotation((yield PlacesUtils.promiseItemId(bm1.guid)),
+                                            "testanno", "testvalue", 0, 0);
+
+  let bm2 = yield PlacesUtils.bookmarks.remove(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  // Check there are no orphan annotations.
+  let conn = yield PlacesUtils.promiseDBConnection();
+  let annoAttrs = yield conn.execute(`SELECT id, name FROM moz_anno_attributes`);
+  // Bug 1306445 will eventually remove the mobile root anno.
+  Assert.equal(annoAttrs.length, 1);
+  Assert.equal(annoAttrs[0].getResultByName("name"), PlacesUtils.MOBILE_ROOT_ANNO);
+  let annos = rows = yield conn.execute(`SELECT item_id, anno_attribute_id FROM moz_items_annos`);
+  Assert.equal(annos.length, 1);
+  Assert.equal(annos[0].getResultByName("item_id"), PlacesUtils.mobileFolderId);
+  Assert.equal(annos[0].getResultByName("anno_attribute_id"), annoAttrs[0].getResultByName("id"));
+});
+
+add_task(function* remove_bookmark_empty_title() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                 url: "http://example.com/",
+                                                 title: "" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.remove(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.index, 0);
+  Assert.ok(!("title" in bm2));
+});
+
+add_task(function* remove_folder() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                 title: "a folder" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.remove(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm2.index, 0);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_FOLDER);
+  Assert.equal(bm2.title, "a folder");
+  Assert.ok(!("url" in bm2));
+});
+
+add_task(function* test_nested_contents_removed() {
+  let folder1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                     type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     title: "a folder" });
+  let folder2 = yield PlacesUtils.bookmarks.insert({ parentGuid: folder1.guid,
+                                                     type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     title: "a folder" });
+  let sep = yield PlacesUtils.bookmarks.insert({ parentGuid: folder2.guid,
+                                                 type: PlacesUtils.bookmarks.TYPE_SEPARATOR });
+  yield PlacesUtils.bookmarks.remove(folder1);
+  Assert.strictEqual((yield PlacesUtils.bookmarks.fetch(folder1.guid)), null);
+  Assert.strictEqual((yield PlacesUtils.bookmarks.fetch(folder2.guid)), null);
+  Assert.strictEqual((yield PlacesUtils.bookmarks.fetch(sep.guid)), null);
+});
+
+add_task(function* remove_folder_empty_title() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                 title: "" });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.remove(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.index, 0);
+  Assert.ok(!("title" in bm2));
+});
+
+add_task(function* remove_separator() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_SEPARATOR });
+  checkBookmarkObject(bm1);
+
+  let bm2 = yield PlacesUtils.bookmarks.remove(bm1.guid);
+  checkBookmarkObject(bm2);
+
+  Assert.deepEqual(bm1, bm2);
+  Assert.equal(bm2.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  Assert.equal(bm2.index, 0);
+  Assert.deepEqual(bm2.dateAdded, bm2.lastModified);
+  Assert.equal(bm2.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
+  Assert.ok(!("url" in bm2));
+  Assert.ok(!("title" in bm2));
+});
+
+add_task(function* test_nested_content_fails_when_not_allowed() {
+  let folder1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                     type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                     title: "a folder" });
+  yield PlacesUtils.bookmarks.insert({ parentGuid: folder1.guid,
+                                       type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                       title: "a folder" });
+  yield Assert.rejects(PlacesUtils.bookmarks.remove(folder1, {preventRemovalOfNonEmptyFolders: true}),
+                       /Cannot remove a non-empty folder./);
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_reorder.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_reorder.js
new file mode 100644
index 000000000..4f6617280
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_reorder.js
@@ -0,0 +1,177 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* invalid_input_throws() {
+  Assert.throws(() => PlacesUtils.bookmarks.reorder(),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.reorder(null),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("test"),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.reorder(123),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.reorder({ guid: "test" }),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("123456789012"),
+                /Must provide a sorted array of children GUIDs./);
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("123456789012", {}),
+                /Must provide a sorted array of children GUIDs./);
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("123456789012", null),
+                /Must provide a sorted array of children GUIDs./);
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("123456789012", []),
+                /Must provide a sorted array of children GUIDs./);
+
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("123456789012", [ null ]),
+                /Invalid GUID found in the sorted children array/);
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("123456789012", [ "" ]),
+                /Invalid GUID found in the sorted children array/);
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("123456789012", [ {} ]),
+                /Invalid GUID found in the sorted children array/);
+  Assert.throws(() => PlacesUtils.bookmarks.reorder("123456789012", [ "012345678901", null ]),
+                /Invalid GUID found in the sorted children array/);
+});
+
+add_task(function* reorder_nonexistent_guid() {
+  yield Assert.rejects(PlacesUtils.bookmarks.reorder("123456789012", [ "012345678901" ]),
+                       /No folder found for the provided GUID/,
+                       "Should throw for nonexisting guid");
+});
+
+add_task(function* reorder() {
+  let bookmarks = [
+    { url: "http://example1.com/",
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+    { type: PlacesUtils.bookmarks.TYPE_FOLDER,
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+    { type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+    { url: "http://example2.com/",
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    },
+    { url: "http://example3.com/",
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    }
+  ];
+
+  let sorted = [];
+  for (let bm of bookmarks) {
+    sorted.push(yield PlacesUtils.bookmarks.insert(bm));
+  }
+
+  // Check the initial append sorting.
+  Assert.ok(sorted.every((bm, i) => bm.index == i),
+            "Initial bookmarks sorting is correct");
+
+  // Apply random sorting and run multiple tests.
+  for (let t = 0; t < 4; t++) {
+    sorted.sort(() => 0.5 - Math.random());
+    let sortedGuids = sorted.map(child => child.guid);
+    dump("Expected order: " + sortedGuids.join() + "\n");
+    // Add a nonexisting guid to the array, to ensure nothing will break.
+    sortedGuids.push("123456789012");
+    yield PlacesUtils.bookmarks.reorder(PlacesUtils.bookmarks.unfiledGuid,
+                                        sortedGuids);
+    for (let i = 0; i < sorted.length; ++i) {
+      let item = yield PlacesUtils.bookmarks.fetch(sorted[i].guid);
+      Assert.equal(item.index, i);
+    }
+  }
+
+  do_print("Test partial sorting");
+  // Try a partial sorting by passing only 2 entries.
+  // The unspecified entries should retain the original order.
+  sorted = [ sorted[1], sorted[0] ].concat(sorted.slice(2));
+  let sortedGuids = [ sorted[0].guid, sorted[1].guid ];
+  dump("Expected order: " + sorted.map(b => b.guid).join() + "\n");
+  yield PlacesUtils.bookmarks.reorder(PlacesUtils.bookmarks.unfiledGuid,
+                                      sortedGuids);
+  for (let i = 0; i < sorted.length; ++i) {
+    let item = yield PlacesUtils.bookmarks.fetch(sorted[i].guid);
+    Assert.equal(item.index, i);
+  }
+
+  // Use triangular numbers to detect skipped position.
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.execute(
+    `SELECT parent
+     FROM moz_bookmarks
+     GROUP BY parent
+     HAVING (SUM(DISTINCT position + 1) - (count(*) * (count(*) + 1) / 2)) <> 0`);
+  Assert.equal(rows.length, 0, "All the bookmarks should have consistent positions");
+});
+
+add_task(function* move_and_reorder() {
+  // Start clean.
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  let bm1 = yield PlacesUtils.bookmarks.insert({
+    url: "http://example1.com/",
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid
+  });
+  let f1 = yield PlacesUtils.bookmarks.insert({
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid
+  });
+  let bm2 = yield PlacesUtils.bookmarks.insert({
+    url: "http://example2.com/",
+    parentGuid: f1.guid
+  });
+  let f2 = yield PlacesUtils.bookmarks.insert({
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid
+  });
+  let bm3 = yield PlacesUtils.bookmarks.insert({
+    url: "http://example3.com/",
+    parentGuid: f2.guid
+  });
+  let bm4 = yield PlacesUtils.bookmarks.insert({
+    url: "http://example4.com/",
+    parentGuid: f2.guid
+  });
+  let bm5 = yield PlacesUtils.bookmarks.insert({
+    url: "http://example5.com/",
+    parentGuid: f2.guid
+  });
+
+  // Invert f2 children.
+  // This is critical to reproduce the bug, cause it inverts the position
+  // compared to the natural insertion order.
+  yield PlacesUtils.bookmarks.reorder(f2.guid, [bm5.guid, bm4.guid, bm3.guid]);
+
+  bm1.parentGuid = f1.guid;
+  bm1.index = 0;
+  yield PlacesUtils.bookmarks.update(bm1);
+
+  bm1 = yield PlacesUtils.bookmarks.fetch(bm1.guid);
+  Assert.equal(bm1.index, 0);
+  bm2 = yield PlacesUtils.bookmarks.fetch(bm2.guid);
+  Assert.equal(bm2.index, 1);
+  bm3 = yield PlacesUtils.bookmarks.fetch(bm3.guid);
+  Assert.equal(bm3.index, 2);
+  bm4 = yield PlacesUtils.bookmarks.fetch(bm4.guid);
+  Assert.equal(bm4.index, 1);
+  bm5 = yield PlacesUtils.bookmarks.fetch(bm5.guid);
+  Assert.equal(bm5.index, 0);
+
+  // No-op reorder on f1 children.
+  // Nothing should change. Though, due to bug 1293365 this was causing children
+  // of other folders to get messed up.
+  yield PlacesUtils.bookmarks.reorder(f1.guid, [bm1.guid, bm2.guid]);
+
+  bm1 = yield PlacesUtils.bookmarks.fetch(bm1.guid);
+  Assert.equal(bm1.index, 0);
+  bm2 = yield PlacesUtils.bookmarks.fetch(bm2.guid);
+  Assert.equal(bm2.index, 1);
+  bm3 = yield PlacesUtils.bookmarks.fetch(bm3.guid);
+  Assert.equal(bm3.index, 2);
+  bm4 = yield PlacesUtils.bookmarks.fetch(bm4.guid);
+  Assert.equal(bm4.index, 1);
+  bm5 = yield PlacesUtils.bookmarks.fetch(bm5.guid);
+  Assert.equal(bm5.index, 0);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_search.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_search.js
new file mode 100644
index 000000000..02f7c5460
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_search.js
@@ -0,0 +1,223 @@
+add_task(function* invalid_input_throws() {
+  Assert.throws(() => PlacesUtils.bookmarks.search(),
+                /Query object is required/);
+  Assert.throws(() => PlacesUtils.bookmarks.search(null),
+                /Query object is required/);
+  Assert.throws(() => PlacesUtils.bookmarks.search({title: 50}),
+                /Title option must be a string/);
+  Assert.throws(() => PlacesUtils.bookmarks.search({url: {url: "wombat"}}),
+                /Url option must be a string or a URL object/);
+  Assert.throws(() => PlacesUtils.bookmarks.search(50),
+                /Query must be an object or a string/);
+  Assert.throws(() => PlacesUtils.bookmarks.search(true),
+                /Query must be an object or a string/);
+});
+
+add_task(function* search_bookmark() {
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  let bm2 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.org/",
+                                                 title: "another bookmark" });
+  let bm3 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.menuGuid,
+                                                 url: "http://menu.org/",
+                                                 title: "an on-menu bookmark" });
+  let bm4 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+                                                 url: "http://toolbar.org/",
+                                                 title: "an on-toolbar bookmark" });
+  checkBookmarkObject(bm1);
+  checkBookmarkObject(bm2);
+  checkBookmarkObject(bm3);
+  checkBookmarkObject(bm4);
+
+  // finds a result by query
+  let results = yield PlacesUtils.bookmarks.search("example.com");
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm1, results[0]);
+
+  // finds multiple results
+  results = yield PlacesUtils.bookmarks.search("example");
+  Assert.equal(results.length, 2);
+  checkBookmarkObject(results[0]);
+  checkBookmarkObject(results[1]);
+
+  // finds menu bookmarks
+  results = yield PlacesUtils.bookmarks.search("an on-menu bookmark");
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm3, results[0]);
+
+  // finds toolbar bookmarks
+  results = yield PlacesUtils.bookmarks.search("an on-toolbar bookmark");
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm4, results[0]);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* search_bookmark_by_query_object() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  let bm2 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.org/",
+                                                 title: "another bookmark" });
+  checkBookmarkObject(bm1);
+  checkBookmarkObject(bm2);
+
+  let results = yield PlacesUtils.bookmarks.search({query: "example.com"});
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+
+  Assert.deepEqual(bm1, results[0]);
+
+  results = yield PlacesUtils.bookmarks.search({query: "example"});
+  Assert.equal(results.length, 2);
+  checkBookmarkObject(results[0]);
+  checkBookmarkObject(results[1]);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* search_bookmark_by_url() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  let bm2 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.org/path",
+                                                 title: "another bookmark" });
+  let bm3 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.org/path",
+                                                 title: "third bookmark" });
+  checkBookmarkObject(bm1);
+  checkBookmarkObject(bm2);
+  checkBookmarkObject(bm3);
+
+  // finds the correct result by url
+  let results = yield PlacesUtils.bookmarks.search({url: "http://example.com/"});
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm1, results[0]);
+
+  // normalizes the url
+  results = yield PlacesUtils.bookmarks.search({url: "http:/example.com"});
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm1, results[0]);
+
+  // returns multiple matches
+  results = yield PlacesUtils.bookmarks.search({url: "http://example.org/path"});
+  Assert.equal(results.length, 2);
+
+  // requires exact match
+  results = yield PlacesUtils.bookmarks.search({url: "http://example.org/"});
+  Assert.equal(results.length, 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* search_bookmark_by_title() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  let bm2 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.org/path",
+                                                 title: "another bookmark" });
+  let bm3 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.net/",
+                                                 title: "another bookmark" });
+  checkBookmarkObject(bm1);
+  checkBookmarkObject(bm2);
+  checkBookmarkObject(bm3);
+
+  // finds the correct result by title
+  let results = yield PlacesUtils.bookmarks.search({title: "a bookmark"});
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm1, results[0]);
+
+  // returns multiple matches
+  results = yield PlacesUtils.bookmarks.search({title: "another bookmark"});
+  Assert.equal(results.length, 2);
+
+  // requires exact match
+  results = yield PlacesUtils.bookmarks.search({title: "bookmark"});
+  Assert.equal(results.length, 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* search_bookmark_combinations() {
+  let bm1 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  let bm2 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.org/path",
+                                                 title: "another bookmark" });
+  let bm3 = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                 url: "http://example.net/",
+                                                 title: "third bookmark" });
+  checkBookmarkObject(bm1);
+  checkBookmarkObject(bm2);
+  checkBookmarkObject(bm3);
+
+  // finds the correct result if title and url match
+  let results = yield PlacesUtils.bookmarks.search({url: "http://example.com/", title: "a bookmark"});
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm1, results[0]);
+
+  // does not match if query is not matching but url and title match
+  results = yield PlacesUtils.bookmarks.search({url: "http://example.com/", title: "a bookmark", query: "nonexistent"});
+  Assert.equal(results.length, 0);
+
+  // does not match if one parameter is not matching
+  results = yield PlacesUtils.bookmarks.search({url: "http://what.ever", title: "a bookmark"});
+  Assert.equal(results.length, 0);
+
+  // query only matches if other fields match as well
+  results = yield PlacesUtils.bookmarks.search({query: "bookmark", url: "http://example.net/"});
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm3, results[0]);
+
+  // non-matching query will also return no results
+  results = yield PlacesUtils.bookmarks.search({query: "nonexistent", url: "http://example.net/"});
+  Assert.equal(results.length, 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* search_folder() {
+  let folder = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.menuGuid,
+                                                 type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                 title: "a test folder" });
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: folder.guid,
+                                                 url: "http://example.com/",
+                                                 title: "a bookmark" });
+  checkBookmarkObject(folder);
+  checkBookmarkObject(bm);
+
+  // also finds folders
+  let results = yield PlacesUtils.bookmarks.search("a test folder");
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.equal(folder.title, results[0].title);
+  Assert.equal(folder.type, results[0].type);
+  Assert.equal(folder.parentGuid, results[0].parentGuid);
+
+  // finds elements in folders
+  results = yield PlacesUtils.bookmarks.search("example.com");
+  Assert.equal(results.length, 1);
+  checkBookmarkObject(results[0]);
+  Assert.deepEqual(bm, results[0]);
+  Assert.equal(folder.guid, results[0].parentGuid);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarks_update.js b/toolkit/components/places/tests/bookmarks/test_bookmarks_update.js
new file mode 100644
index 000000000..d077fd6f3
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarks_update.js
@@ -0,0 +1,414 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* invalid_input_throws() {
+  Assert.throws(() => PlacesUtils.bookmarks.update(),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.bookmarks.update(null),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({}),
+                /The following properties were expected/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ guid: "test" }),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ guid: null }),
+                /Invalid value for property 'guid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ guid: 123 }),
+                /Invalid value for property 'guid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ parentGuid: "test" }),
+                /Invalid value for property 'parentGuid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ parentGuid: null }),
+                /Invalid value for property 'parentGuid'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ parentGuid: 123 }),
+                /Invalid value for property 'parentGuid'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ index: "1" }),
+                /Invalid value for property 'index'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ index: -10 }),
+                /Invalid value for property 'index'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ dateAdded: -10 }),
+                /Invalid value for property 'dateAdded'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ dateAdded: "today" }),
+                /Invalid value for property 'dateAdded'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ dateAdded: Date.now() }),
+                /Invalid value for property 'dateAdded'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ lastModified: -10 }),
+                /Invalid value for property 'lastModified'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ lastModified: "today" }),
+                /Invalid value for property 'lastModified'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ lastModified: Date.now() }),
+                /Invalid value for property 'lastModified'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ type: -1 }),
+                /Invalid value for property 'type'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ type: 100 }),
+                /Invalid value for property 'type'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ type: "bookmark" }),
+                /Invalid value for property 'type'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ url: 10 }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ url: "http://te st" }),
+                /Invalid value for property 'url'/);
+  let longurl = "http://www.example.com/";
+  for (let i = 0; i < 65536; i++) {
+    longurl += "a";
+  }
+  Assert.throws(() => PlacesUtils.bookmarks.update({ url: longurl }),
+                /Invalid value for property 'url'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ url: NetUtil.newURI(longurl) }),
+                /Invalid value for property 'url'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ url: "te st" }),
+                /Invalid value for property 'url'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ title: -1 }),
+                /Invalid value for property 'title'/);
+  Assert.throws(() => PlacesUtils.bookmarks.update({ title: {} }),
+                /Invalid value for property 'title'/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ guid: "123456789012" }),
+                /Not enough properties to update/);
+
+  Assert.throws(() => PlacesUtils.bookmarks.update({ guid: "123456789012",
+                                                     parentGuid: "012345678901" }),
+                /The following properties were expected: index/);
+});
+
+add_task(function* nonexisting_bookmark_throws() {
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: "123456789012",
+                                         title: "test" });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/No bookmarks found for the provided GUID/.test(ex));
+  }
+});
+
+add_task(function* invalid_properties_for_existing_bookmark() {
+  let bm = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                url: "http://example.com/" });
+
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                         type: PlacesUtils.bookmarks.TYPE_FOLDER });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/The bookmark type cannot be changed/.test(ex));
+  }
+
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                         dateAdded: new Date() });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/The bookmark dateAdded cannot be changed/.test(ex));
+  }
+
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                         dateAdded: new Date() });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/The bookmark dateAdded cannot be changed/.test(ex));
+  }
+
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                         parentGuid: "123456789012",
+                                         index: 1 });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/No bookmarks found for the provided parentGuid/.test(ex));
+  }
+
+  let past = new Date(Date.now() - 86400000);
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                         lastModified: past });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/Invalid value for property 'lastModified'/.test(ex));
+  }
+
+  let folder = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                    parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: folder.guid,
+                                         url: "http://example.com/" });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/Invalid value for property 'url'/.test(ex));
+  }
+
+  let separator = yield PlacesUtils.bookmarks.insert({ type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+                                                       parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: separator.guid,
+                                         url: "http://example.com/" });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/Invalid value for property 'url'/.test(ex));
+  }
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: separator.guid,
+                                         title: "test" });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/Invalid value for property 'title'/.test(ex));
+  }
+});
+
+add_task(function* long_title_trim() {
+  let longtitle = "a";
+  for (let i = 0; i < 4096; i++) {
+    longtitle += "a";
+  }
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                title: "title" });
+  checkBookmarkObject(bm);
+
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            title: longtitle });
+  let newTitle = bm.title;
+  Assert.equal(newTitle.length, 4096, "title should have been trimmed");
+
+  bm = yield PlacesUtils.bookmarks.fetch(bm.guid);
+  Assert.equal(bm.title, newTitle);
+});
+
+add_task(function* update_lastModified() {
+  let yesterday = new Date(Date.now() - 86400000);
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_FOLDER,
+                                                title: "title",
+                                                dateAdded: yesterday });
+  checkBookmarkObject(bm);
+  Assert.deepEqual(bm.lastModified, yesterday);
+
+  let time = new Date();
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            lastModified: time });
+  checkBookmarkObject(bm);
+  Assert.deepEqual(bm.lastModified, time);
+
+  bm = yield PlacesUtils.bookmarks.fetch(bm.guid);
+  Assert.deepEqual(bm.lastModified, time);
+
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            lastModified: yesterday });
+  Assert.deepEqual(bm.lastModified, yesterday);
+
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            title: "title2" });
+  Assert.ok(bm.lastModified >= time);
+
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            title: "" });
+  Assert.ok(!("title" in bm));
+
+  bm = yield PlacesUtils.bookmarks.fetch(bm.guid);
+  Assert.ok(!("title" in bm));
+});
+
+add_task(function* update_url() {
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                url: "http://example.com/",
+                                                title: "title" });
+  checkBookmarkObject(bm);
+  let lastModified = bm.lastModified;
+  let frecency = frecencyForUrl(bm.url);
+  Assert.ok(frecency > 0, "Check frecency has been updated");
+
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            url: "http://mozilla.org/" });
+  checkBookmarkObject(bm);
+  Assert.ok(bm.lastModified >= lastModified);
+  Assert.equal(bm.url.href, "http://mozilla.org/");
+
+  bm = yield PlacesUtils.bookmarks.fetch(bm.guid);
+  Assert.equal(bm.url.href, "http://mozilla.org/");
+  Assert.ok(bm.lastModified >= lastModified);
+
+  Assert.equal(frecencyForUrl("http://example.com/"), frecency, "Check frecency for example.com");
+  Assert.equal(frecencyForUrl("http://mozilla.org/"), frecency, "Check frecency for mozilla.org");
+});
+
+add_task(function* update_index() {
+  let parent = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                    type: PlacesUtils.bookmarks.TYPE_FOLDER }) ;
+  let f1 = yield PlacesUtils.bookmarks.insert({ parentGuid: parent.guid,
+                                                type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  Assert.equal(f1.index, 0);
+  let f2 = yield PlacesUtils.bookmarks.insert({ parentGuid: parent.guid,
+                                                type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  Assert.equal(f2.index, 1);
+  let f3 = yield PlacesUtils.bookmarks.insert({ parentGuid: parent.guid,
+                                                type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  Assert.equal(f3.index, 2);
+  let lastModified = f1.lastModified;
+
+  f1 = yield PlacesUtils.bookmarks.update({ guid: f1.guid,
+                                            parentGuid: f1.parentGuid,
+                                            index: 1});
+  checkBookmarkObject(f1);
+  Assert.equal(f1.index, 1);
+  Assert.ok(f1.lastModified >= lastModified);
+
+  parent = yield PlacesUtils.bookmarks.fetch(f1.parentGuid);
+  Assert.deepEqual(parent.lastModified, f1.lastModified);
+
+  f2 = yield PlacesUtils.bookmarks.fetch(f2.guid);
+  Assert.equal(f2.index, 0);
+
+  f3 = yield PlacesUtils.bookmarks.fetch(f3.guid);
+  Assert.equal(f3.index, 2);
+
+  f3 = yield PlacesUtils.bookmarks.update({ guid: f3.guid,
+                                            index: 0 });
+  f1 = yield PlacesUtils.bookmarks.fetch(f1.guid);
+  Assert.equal(f1.index, 2);
+
+  f2 = yield PlacesUtils.bookmarks.fetch(f2.guid);
+  Assert.equal(f2.index, 1);
+});
+
+add_task(function* update_move_folder_into_descendant_throws() {
+  let parent = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                    type: PlacesUtils.bookmarks.TYPE_FOLDER }) ;
+  let descendant = yield PlacesUtils.bookmarks.insert({ parentGuid: parent.guid,
+                                                        type: PlacesUtils.bookmarks.TYPE_FOLDER });
+
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: parent.guid,
+                                         parentGuid: parent.guid,
+                                         index: 0 });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/Cannot insert a folder into itself or one of its descendants/.test(ex));
+  }
+
+  try {
+    yield PlacesUtils.bookmarks.update({ guid: parent.guid,
+                                         parentGuid: descendant.guid,
+                                         index: 0 });
+    Assert.ok(false, "Should have thrown");
+  } catch (ex) {
+    Assert.ok(/Cannot insert a folder into itself or one of its descendants/.test(ex));
+  }
+});
+
+add_task(function* update_move() {
+  let parent = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                                    type: PlacesUtils.bookmarks.TYPE_FOLDER }) ;
+  let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: parent.guid,
+                                                url: "http://example.com/",
+                                                type: PlacesUtils.bookmarks.TYPE_BOOKMARK }) ;
+  let descendant = yield PlacesUtils.bookmarks.insert({ parentGuid: parent.guid,
+                                                        type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  Assert.equal(descendant.index, 1);
+  let lastModified = bm.lastModified;
+
+  // This is moving to a nonexisting index by purpose, it will be appended.
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            parentGuid: descendant.guid,
+                                            index: 1 });
+  checkBookmarkObject(bm);
+  Assert.equal(bm.parentGuid, descendant.guid);
+  Assert.equal(bm.index, 0);
+  Assert.ok(bm.lastModified >= lastModified);
+
+  parent = yield PlacesUtils.bookmarks.fetch(parent.guid);
+  descendant = yield PlacesUtils.bookmarks.fetch(descendant.guid);
+  Assert.deepEqual(parent.lastModified, bm.lastModified);
+  Assert.deepEqual(descendant.lastModified, bm.lastModified);
+  Assert.equal(descendant.index, 0);
+
+  bm = yield PlacesUtils.bookmarks.fetch(bm.guid);
+  Assert.equal(bm.parentGuid, descendant.guid);
+  Assert.equal(bm.index, 0);
+
+  bm = yield PlacesUtils.bookmarks.update({ guid: bm.guid,
+                                            parentGuid: parent.guid,
+                                            index: 0 });
+  Assert.equal(bm.parentGuid, parent.guid);
+  Assert.equal(bm.index, 0);
+
+  descendant = yield PlacesUtils.bookmarks.fetch(descendant.guid);
+  Assert.equal(descendant.index, 1);
+});
+
+add_task(function* update_move_append() {
+  let folder_a =
+    yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                         type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  checkBookmarkObject(folder_a);
+  let folder_b =
+    yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                         type: PlacesUtils.bookmarks.TYPE_FOLDER });
+  checkBookmarkObject(folder_b);
+
+  /* folder_a: [sep_1, sep_2, sep_3], folder_b: [] */
+  let sep_1 = yield PlacesUtils.bookmarks.insert({ parentGuid: folder_a.guid,
+                                                   type: PlacesUtils.bookmarks.TYPE_SEPARATOR });
+  checkBookmarkObject(sep_1);
+  let sep_2 = yield PlacesUtils.bookmarks.insert({ parentGuid: folder_a.guid,
+                                                   type: PlacesUtils.bookmarks.TYPE_SEPARATOR });
+  checkBookmarkObject(sep_2);
+  let sep_3 = yield PlacesUtils.bookmarks.insert({ parentGuid: folder_a.guid,
+                                                   type: PlacesUtils.bookmarks.TYPE_SEPARATOR });
+  checkBookmarkObject(sep_3);
+
+  function ensurePosition(info, parentGuid, index) {
+    checkBookmarkObject(info);
+    Assert.equal(info.parentGuid, parentGuid);
+    Assert.equal(info.index, index);
+  }
+
+  // folder_a: [sep_2, sep_3, sep_1], folder_b: []
+  sep_1.index = PlacesUtils.bookmarks.DEFAULT_INDEX;
+  // Note sep_1 includes parentGuid even though we're not moving the item to
+  // another folder
+  sep_1 = yield PlacesUtils.bookmarks.update(sep_1);
+  ensurePosition(sep_1, folder_a.guid, 2);
+  sep_2 = yield PlacesUtils.bookmarks.fetch(sep_2.guid);
+  ensurePosition(sep_2, folder_a.guid, 0);
+  sep_3 = yield PlacesUtils.bookmarks.fetch(sep_3.guid);
+  ensurePosition(sep_3, folder_a.guid, 1);
+  sep_1 = yield PlacesUtils.bookmarks.fetch(sep_1.guid);
+  ensurePosition(sep_1, folder_a.guid, 2);
+
+  // folder_a: [sep_2, sep_1], folder_b: [sep_3]
+  sep_3.index = PlacesUtils.bookmarks.DEFAULT_INDEX;
+  sep_3.parentGuid = folder_b.guid;
+  sep_3 = yield PlacesUtils.bookmarks.update(sep_3);
+  ensurePosition(sep_3, folder_b.guid, 0);
+  sep_2 = yield PlacesUtils.bookmarks.fetch(sep_2.guid);
+  ensurePosition(sep_2, folder_a.guid, 0);
+  sep_1 = yield PlacesUtils.bookmarks.fetch(sep_1.guid);
+  ensurePosition(sep_1, folder_a.guid, 1);
+  sep_3 = yield PlacesUtils.bookmarks.fetch(sep_3.guid);
+  ensurePosition(sep_3, folder_b.guid, 0);
+
+  // folder_a: [sep_1], folder_b: [sep_3, sep_2]
+  sep_2.index = Number.MAX_SAFE_INTEGER;
+  sep_2.parentGuid = folder_b.guid;
+  sep_2 = yield PlacesUtils.bookmarks.update(sep_2);
+  ensurePosition(sep_2, folder_b.guid, 1);
+  sep_1 = yield PlacesUtils.bookmarks.fetch(sep_1.guid);
+  ensurePosition(sep_1, folder_a.guid, 0);
+  sep_3 = yield PlacesUtils.bookmarks.fetch(sep_3.guid);
+  ensurePosition(sep_3, folder_b.guid, 0);
+  sep_2 = yield PlacesUtils.bookmarks.fetch(sep_2.guid);
+  ensurePosition(sep_2, folder_b.guid, 1);
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_bookmarkstree_cache.js b/toolkit/components/places/tests/bookmarks/test_bookmarkstree_cache.js
new file mode 100644
index 000000000..f5cf34641
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_bookmarkstree_cache.js
@@ -0,0 +1,18 @@
+
+// Bug 1192692 - promiseBookmarksTree caches items without adding observers to
+// invalidate the cache.
+add_task(function* boookmarks_tree_cache() {
+  // Note that for this test to be effective, it needs to use the "old" sync
+  // bookmarks methods - using, eg, PlacesUtils.bookmarks.insert() doesn't
+  // demonstrate the problem as it indirectly arranges for the observers to
+  // be added.
+  let id = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                uri("http://example.com"),
+                                                PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                "A title");
+  yield PlacesUtils.promiseBookmarksTree();
+
+  PlacesUtils.bookmarks.removeItem(id);
+
+  yield Assert.rejects(PlacesUtils.promiseItemGuid(id));
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_changeBookmarkURI.js b/toolkit/components/places/tests/bookmarks/test_changeBookmarkURI.js
new file mode 100644
index 000000000..55ffecf2f
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_changeBookmarkURI.js
@@ -0,0 +1,68 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get bookmark service
+var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+            getService(Ci.nsINavBookmarksService);
+
+/**
+ * Ensures that the Places APIs recognize that aBookmarkedUri is bookmarked
+ * via aBookmarkId and that aUnbookmarkedUri is not bookmarked at all.
+ *
+ * @param aBookmarkId
+ *        an item ID whose corresponding URI is aBookmarkedUri
+ * @param aBookmarkedUri
+ *        a bookmarked URI that has a corresponding item ID aBookmarkId
+ * @param aUnbookmarkedUri
+ *        a URI that is not currently bookmarked at all
+ */
+function checkUris(aBookmarkId, aBookmarkedUri, aUnbookmarkedUri)
+{
+  // Ensure that aBookmarkedUri equals some URI that is bookmarked
+  var uri = bmsvc.getBookmarkedURIFor(aBookmarkedUri);
+  do_check_neq(uri, null);
+  do_check_true(uri.equals(aBookmarkedUri));
+
+  // Ensure that aBookmarkedUri is considered bookmarked
+  do_check_true(bmsvc.isBookmarked(aBookmarkedUri));
+
+  // Ensure that the URI corresponding to aBookmarkId equals aBookmarkedUri
+  do_check_true(bmsvc.getBookmarkURI(aBookmarkId).equals(aBookmarkedUri));
+
+  // Ensure that aUnbookmarkedUri does not equal any URI that is bookmarked
+  uri = bmsvc.getBookmarkedURIFor(aUnbookmarkedUri);
+  do_check_eq(uri, null);
+
+  // Ensure that aUnbookmarkedUri is not considered bookmarked
+  do_check_false(bmsvc.isBookmarked(aUnbookmarkedUri));
+}
+
+// main
+function run_test() {
+  // Create a folder
+  var folderId = bmsvc.createFolder(bmsvc.toolbarFolder,
+                                    "test",
+                                    bmsvc.DEFAULT_INDEX);
+
+  // Create 2 URIs
+  var uri1 = uri("http://www.dogs.com");
+  var uri2 = uri("http://www.cats.com");
+
+  // Bookmark the first one
+  var bookmarkId = bmsvc.insertBookmark(folderId,
+                                        uri1,
+                                        bmsvc.DEFAULT_INDEX,
+                                        "Dogs");
+
+  // uri1 is bookmarked via bookmarkId, uri2 is not
+  checkUris(bookmarkId, uri1, uri2);
+
+  // Change the URI of the bookmark to uri2
+  bmsvc.changeBookmarkURI(bookmarkId, uri2);
+
+  // uri2 is now bookmarked via bookmarkId, uri1 is not
+  checkUris(bookmarkId, uri2, uri1);
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_getBookmarkedURIFor.js b/toolkit/components/places/tests/bookmarks/test_getBookmarkedURIFor.js
new file mode 100644
index 000000000..c43e8e283
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_getBookmarkedURIFor.js
@@ -0,0 +1,84 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+ /**
+  * Test bookmarksService.getBookmarkedURIFor(aURI);
+  */
+
+var hs = PlacesUtils.history;
+var bs = PlacesUtils.bookmarks;
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_getBookmarkedURIFor() {
+  let now = Date.now() * 1000;
+  const sourceURI = uri("http://test.mozilla.org/");
+  // Add a visit and a bookmark.
+  yield PlacesTestUtils.addVisits({ uri: sourceURI, visitDate: now });
+  do_check_eq(bs.getBookmarkedURIFor(sourceURI), null);
+
+  let sourceItemId = bs.insertBookmark(bs.unfiledBookmarksFolder,
+                                       sourceURI,
+                                       bs.DEFAULT_INDEX,
+                                       "bookmark");
+  do_check_true(bs.getBookmarkedURIFor(sourceURI).equals(sourceURI));
+
+  // Add a redirected visit.
+  const permaURI = uri("http://perma.mozilla.org/");
+  yield PlacesTestUtils.addVisits({
+    uri: permaURI,
+    transition: TRANSITION_REDIRECT_PERMANENT,
+    visitDate: now++,
+    referrer: sourceURI
+  });
+  do_check_true(bs.getBookmarkedURIFor(sourceURI).equals(sourceURI));
+  do_check_true(bs.getBookmarkedURIFor(permaURI).equals(sourceURI));
+  // Add a bookmark to the destination.
+  let permaItemId = bs.insertBookmark(bs.unfiledBookmarksFolder,
+                                      permaURI,
+                                      bs.DEFAULT_INDEX,
+                                      "bookmark");
+  do_check_true(bs.getBookmarkedURIFor(sourceURI).equals(sourceURI));
+  do_check_true(bs.getBookmarkedURIFor(permaURI).equals(permaURI));
+  // Now remove the bookmark on the destination.
+  bs.removeItem(permaItemId);
+  // We should see the source as bookmark.
+  do_check_true(bs.getBookmarkedURIFor(permaURI).equals(sourceURI));
+
+  // Add another redirected visit.
+  const tempURI = uri("http://perma.mozilla.org/");
+  yield PlacesTestUtils.addVisits({
+    uri: tempURI,
+    transition: TRANSITION_REDIRECT_TEMPORARY,
+    visitDate: now++,
+    referrer: permaURI
+  });
+
+  do_check_true(bs.getBookmarkedURIFor(sourceURI).equals(sourceURI));
+  do_check_true(bs.getBookmarkedURIFor(tempURI).equals(sourceURI));
+  // Add a bookmark to the destination.
+  let tempItemId = bs.insertBookmark(bs.unfiledBookmarksFolder,
+                                     tempURI,
+                                     bs.DEFAULT_INDEX,
+                                     "bookmark");
+  do_check_true(bs.getBookmarkedURIFor(sourceURI).equals(sourceURI));
+  do_check_true(bs.getBookmarkedURIFor(tempURI).equals(tempURI));
+
+  // Now remove the bookmark on the destination.
+  bs.removeItem(tempItemId);
+  // We should see the source as bookmark.
+  do_check_true(bs.getBookmarkedURIFor(tempURI).equals(sourceURI));
+  // Remove the source bookmark as well.
+  bs.removeItem(sourceItemId);
+  do_check_eq(bs.getBookmarkedURIFor(tempURI), null);
+
+  // Try to pass in a never seen URI, should return null and a new entry should
+  // not be added to the database.
+  do_check_eq(bs.getBookmarkedURIFor(uri("http://does.not.exist/")), null);
+  do_check_false(page_in_database("http://does.not.exist/"));
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_keywords.js b/toolkit/components/places/tests/bookmarks/test_keywords.js
new file mode 100644
index 000000000..149d6d0b0
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_keywords.js
@@ -0,0 +1,310 @@
+const URI1 = NetUtil.newURI("http://test1.mozilla.org/");
+const URI2 = NetUtil.newURI("http://test2.mozilla.org/");
+const URI3 = NetUtil.newURI("http://test3.mozilla.org/");
+
+function check_keyword(aURI, aKeyword) {
+  if (aKeyword)
+    aKeyword = aKeyword.toLowerCase();
+
+  for (let bm of PlacesUtils.getBookmarksForURI(aURI)) {
+    let keyword = PlacesUtils.bookmarks.getKeywordForBookmark(bm);
+    if (keyword && !aKeyword) {
+      throw (`${aURI.spec} should not have a keyword`);
+    } else if (aKeyword && keyword == aKeyword) {
+      Assert.equal(keyword, aKeyword);
+    }
+  }
+
+  if (aKeyword) {
+    let uri = PlacesUtils.bookmarks.getURIForKeyword(aKeyword);
+    Assert.equal(uri.spec, aURI.spec);
+    // Check case insensitivity.
+    uri = PlacesUtils.bookmarks.getURIForKeyword(aKeyword.toUpperCase());
+    Assert.equal(uri.spec, aURI.spec);
+  }
+}
+
+function* check_orphans() {
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.executeCached(
+    `SELECT id FROM moz_keywords k
+     WHERE NOT EXISTS (SELECT 1 FROM moz_places WHERE id = k.place_id)
+    `);
+  Assert.equal(rows.length, 0);
+}
+
+function expectNotifications() {
+  let notifications = [];
+  let observer = new Proxy(NavBookmarkObserver, {
+    get(target, name) {
+      if (name == "check") {
+        PlacesUtils.bookmarks.removeObserver(observer);
+        return expectedNotifications =>
+          Assert.deepEqual(notifications, expectedNotifications);
+      }
+
+      if (name.startsWith("onItemChanged")) {
+        return function(id, prop, isAnno, val, lastMod, itemType, parentId, guid, parentGuid, oldVal) {
+          if (prop != "keyword")
+            return;
+          let args = Array.from(arguments, arg => {
+            if (arg && arg instanceof Ci.nsIURI)
+              return new URL(arg.spec);
+            if (arg && typeof(arg) == "number" && arg >= Date.now() * 1000)
+              return new Date(parseInt(arg/1000));
+            return arg;
+          });
+          notifications.push({ name: name, arguments: args });
+        }
+      }
+
+      return target[name];
+    }
+  });
+  PlacesUtils.bookmarks.addObserver(observer, false);
+  return observer;
+}
+
+add_task(function test_invalid_input() {
+  Assert.throws(() => PlacesUtils.bookmarks.getURIForKeyword(null),
+                /NS_ERROR_ILLEGAL_VALUE/);
+  Assert.throws(() => PlacesUtils.bookmarks.getURIForKeyword(""),
+                /NS_ERROR_ILLEGAL_VALUE/);
+  Assert.throws(() => PlacesUtils.bookmarks.getKeywordForBookmark(null),
+                /NS_ERROR_ILLEGAL_VALUE/);
+  Assert.throws(() => PlacesUtils.bookmarks.getKeywordForBookmark(0),
+                /NS_ERROR_ILLEGAL_VALUE/);
+  Assert.throws(() => PlacesUtils.bookmarks.setKeywordForBookmark(null, "k"),
+                /NS_ERROR_ILLEGAL_VALUE/);
+  Assert.throws(() => PlacesUtils.bookmarks.setKeywordForBookmark(0, "k"),
+                /NS_ERROR_ILLEGAL_VALUE/);
+});
+
+add_task(function* test_addBookmarkAndKeyword() {
+  check_keyword(URI1, null);
+  let fc = yield foreign_count(URI1);
+  let observer = expectNotifications();
+
+  let itemId =
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         URI1,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "test");
+
+  PlacesUtils.bookmarks.setKeywordForBookmark(itemId, "keyword");
+  let bookmark = yield PlacesUtils.bookmarks.fetch({ url: URI1 });
+  observer.check([ { name: "onItemChanged",
+                     arguments: [ itemId, "keyword", false, "keyword",
+                                  bookmark.lastModified, bookmark.type,
+                                  (yield PlacesUtils.promiseItemId(bookmark.parentGuid)),
+                                  bookmark.guid, bookmark.parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  check_keyword(URI1, "keyword");
+  Assert.equal((yield foreign_count(URI1)), fc + 2); // + 1 bookmark + 1 keyword
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield check_orphans();
+});
+
+add_task(function* test_addBookmarkToURIHavingKeyword() {
+  // The uri has already a keyword.
+  check_keyword(URI1, "keyword");
+  let fc = yield foreign_count(URI1);
+
+  let itemId =
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         URI1,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "test");
+  check_keyword(URI1, "keyword");
+  Assert.equal((yield foreign_count(URI1)), fc + 1); // + 1 bookmark
+
+  PlacesUtils.bookmarks.removeItem(itemId);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  check_orphans();
+});
+
+add_task(function* test_sameKeywordDifferentURI() {
+  let fc1 = yield foreign_count(URI1);
+  let fc2 = yield foreign_count(URI2);
+  let observer = expectNotifications();
+
+  let itemId =
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         URI2,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "test2");
+  check_keyword(URI1, "keyword");
+  check_keyword(URI2, null);
+
+  PlacesUtils.bookmarks.setKeywordForBookmark(itemId, "kEyWoRd");
+
+  let bookmark1 = yield PlacesUtils.bookmarks.fetch({ url: URI1 });
+  let bookmark2 = yield PlacesUtils.bookmarks.fetch({ url: URI2 });
+  observer.check([ { name: "onItemChanged",
+                     arguments: [ (yield PlacesUtils.promiseItemId(bookmark1.guid)),
+                                  "keyword", false, "",
+                                  bookmark1.lastModified, bookmark1.type,
+                                  (yield PlacesUtils.promiseItemId(bookmark1.parentGuid)),
+                                  bookmark1.guid, bookmark1.parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                    { name: "onItemChanged",
+                     arguments: [ itemId, "keyword", false, "keyword",
+                                  bookmark2.lastModified, bookmark2.type,
+                                  (yield PlacesUtils.promiseItemId(bookmark2.parentGuid)),
+                                  bookmark2.guid, bookmark2.parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  // The keyword should have been "moved" to the new URI.
+  check_keyword(URI1, null);
+  Assert.equal((yield foreign_count(URI1)), fc1 - 1); // - 1 keyword
+  check_keyword(URI2, "keyword");
+  Assert.equal((yield foreign_count(URI2)), fc2 + 2); // + 1 bookmark + 1 keyword
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  check_orphans();
+});
+
+add_task(function* test_sameURIDifferentKeyword() {
+  let fc = yield foreign_count(URI2);
+  let observer = expectNotifications();
+
+  let itemId =
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         URI2,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "test2");
+  check_keyword(URI2, "keyword");
+
+  PlacesUtils.bookmarks.setKeywordForBookmark(itemId, "keyword2");
+
+  let bookmarks = [];
+  yield PlacesUtils.bookmarks.fetch({ url: URI2 }, bookmark => bookmarks.push(bookmark));
+  observer.check([ { name: "onItemChanged",
+                     arguments: [ (yield PlacesUtils.promiseItemId(bookmarks[0].guid)),
+                                  "keyword", false, "keyword2",
+                                  bookmarks[0].lastModified, bookmarks[0].type,
+                                  (yield PlacesUtils.promiseItemId(bookmarks[0].parentGuid)),
+                                  bookmarks[0].guid, bookmarks[0].parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                    { name: "onItemChanged",
+                     arguments: [ (yield PlacesUtils.promiseItemId(bookmarks[1].guid)),
+                                  "keyword", false, "keyword2",
+                                  bookmarks[1].lastModified, bookmarks[1].type,
+                                  (yield PlacesUtils.promiseItemId(bookmarks[1].parentGuid)),
+                                  bookmarks[1].guid, bookmarks[1].parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  check_keyword(URI2, "keyword2");
+  Assert.equal((yield foreign_count(URI2)), fc + 2); // + 1 bookmark + 1 keyword
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  check_orphans();
+});
+
+add_task(function* test_removeBookmarkWithKeyword() {
+  let fc = yield foreign_count(URI2);
+  let itemId =
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         URI2,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "test");
+
+   // The keyword should not be removed, since there are other bookmarks yet.
+   PlacesUtils.bookmarks.removeItem(itemId);
+
+  check_keyword(URI2, "keyword2");
+  Assert.equal((yield foreign_count(URI2)), fc); // + 1 bookmark - 1 bookmark
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  check_orphans();
+});
+
+add_task(function* test_unsetKeyword() {
+  let fc = yield foreign_count(URI2);
+  let observer = expectNotifications();
+
+  let itemId =
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         URI2,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "test");
+
+  // The keyword should be removed from any bookmark.
+  PlacesUtils.bookmarks.setKeywordForBookmark(itemId, null);
+
+  let bookmarks = [];
+  yield PlacesUtils.bookmarks.fetch({ url: URI2 }, bookmark => bookmarks.push(bookmark));
+  do_print(bookmarks.length);
+  observer.check([ { name: "onItemChanged",
+                     arguments: [ (yield PlacesUtils.promiseItemId(bookmarks[0].guid)),
+                                  "keyword", false, "",
+                                  bookmarks[0].lastModified, bookmarks[0].type,
+                                  (yield PlacesUtils.promiseItemId(bookmarks[0].parentGuid)),
+                                  bookmarks[0].guid, bookmarks[0].parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                    { name: "onItemChanged",
+                     arguments: [ (yield PlacesUtils.promiseItemId(bookmarks[1].guid)),
+                                  "keyword", false, "",
+                                  bookmarks[1].lastModified, bookmarks[1].type,
+                                  (yield PlacesUtils.promiseItemId(bookmarks[1].parentGuid)),
+                                  bookmarks[1].guid, bookmarks[1].parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                    { name: "onItemChanged",
+                     arguments: [ (yield PlacesUtils.promiseItemId(bookmarks[2].guid)),
+                                  "keyword", false, "",
+                                  bookmarks[2].lastModified, bookmarks[2].type,
+                                  (yield PlacesUtils.promiseItemId(bookmarks[2].parentGuid)),
+                                  bookmarks[2].guid, bookmarks[2].parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+
+  check_keyword(URI1, null);
+  check_keyword(URI2, null);
+  Assert.equal((yield foreign_count(URI2)), fc - 1); // + 1 bookmark - 2 keyword
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  check_orphans();
+});
+
+add_task(function* test_addRemoveBookmark() {
+  let observer = expectNotifications();
+
+  let itemId =
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         URI3,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "test3");
+
+  PlacesUtils.bookmarks.setKeywordForBookmark(itemId, "keyword");
+  let bookmark = yield PlacesUtils.bookmarks.fetch({ url: URI3 });
+  let parentId = yield PlacesUtils.promiseItemId(bookmark.parentGuid);
+  PlacesUtils.bookmarks.removeItem(itemId);
+
+  observer.check([ { name: "onItemChanged",
+                     arguments: [ itemId,
+                                  "keyword", false, "keyword",
+                                  bookmark.lastModified, bookmark.type,
+                                  parentId,
+                                  bookmark.guid, bookmark.parentGuid, "",
+                                  Ci.nsINavBookmarksService.SOURCE_DEFAULT ] }
+                 ]);
+
+  check_keyword(URI3, null);
+  // Don't check the foreign count since the process is async.
+  // The new test_keywords.js in unit is checking this though.
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  check_orphans();
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_nsINavBookmarkObserver.js b/toolkit/components/places/tests/bookmarks/test_nsINavBookmarkObserver.js
new file mode 100644
index 000000000..06f45b18e
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_nsINavBookmarkObserver.js
@@ -0,0 +1,640 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Tests that each nsINavBookmarksObserver method gets the correct input.
+Cu.import("resource://gre/modules/PromiseUtils.jsm");
+
+const GUID_RE = /^[a-zA-Z0-9\-_]{12}$/;
+
+var gBookmarksObserver = {
+  expected: [],
+  setup(expected) {
+    this.expected = expected;
+    this.deferred = PromiseUtils.defer();
+    return this.deferred.promise;
+  },
+  validate: function (aMethodName, aArguments) {
+    do_check_eq(this.expected[0].name, aMethodName);
+
+    let args = this.expected.shift().args;
+    do_check_eq(aArguments.length, args.length);
+    for (let i = 0; i < aArguments.length; i++) {
+      do_check_true(args[i].check(aArguments[i]), aMethodName + "(args[" + i + "]: " + args[i].name + ")");
+    }
+
+    if (this.expected.length === 0) {
+      this.deferred.resolve();
+    }
+  },
+
+  // nsINavBookmarkObserver
+  onBeginUpdateBatch() {
+    return this.validate("onBeginUpdateBatch", arguments);
+  },
+  onEndUpdateBatch() {
+    return this.validate("onEndUpdateBatch", arguments);
+  },
+  onItemAdded() {
+    return this.validate("onItemAdded", arguments);
+  },
+  onItemRemoved() {
+    return this.validate("onItemRemoved", arguments);
+  },
+  onItemChanged() {
+    return this.validate("onItemChanged", arguments);
+  },
+  onItemVisited() {
+    return this.validate("onItemVisited", arguments);
+  },
+  onItemMoved() {
+    return this.validate("onItemMoved", arguments);
+  },
+
+  // nsISupports
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsINavBookmarkObserver]),
+};
+
+var gBookmarkSkipObserver = {
+  skipTags: true,
+  skipDescendantsOnItemRemoval: true,
+
+  expected: null,
+  setup(expected) {
+    this.expected = expected;
+    this.deferred = PromiseUtils.defer();
+    return this.deferred.promise;
+  },
+  validate: function (aMethodName) {
+    do_check_eq(this.expected.shift(), aMethodName);
+    if (this.expected.length === 0) {
+      this.deferred.resolve();
+    }
+  },
+
+  // nsINavBookmarkObserver
+  onBeginUpdateBatch() {
+    return this.validate("onBeginUpdateBatch", arguments);
+  },
+  onEndUpdateBatch() {
+    return this.validate("onEndUpdateBatch", arguments);
+  },
+  onItemAdded() {
+    return this.validate("onItemAdded", arguments);
+  },
+  onItemRemoved() {
+    return this.validate("onItemRemoved", arguments);
+  },
+  onItemChanged() {
+    return this.validate("onItemChanged", arguments);
+  },
+  onItemVisited() {
+    return this.validate("onItemVisited", arguments);
+  },
+  onItemMoved() {
+    return this.validate("onItemMoved", arguments);
+  },
+
+  // nsISupports
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsINavBookmarkObserver]),
+};
+
+
+add_task(function setup() {
+  PlacesUtils.bookmarks.addObserver(gBookmarksObserver, false);
+  PlacesUtils.bookmarks.addObserver(gBookmarkSkipObserver, false);
+});
+
+add_task(function* batch() {
+  let promise = Promise.all([
+    gBookmarksObserver.setup([
+      { name: "onBeginUpdateBatch",
+       args: [] },
+      { name: "onEndUpdateBatch",
+       args: [] },
+    ]),
+    gBookmarkSkipObserver.setup([
+      "onBeginUpdateBatch", "onEndUpdateBatch"
+  ])]);
+  PlacesUtils.bookmarks.runInBatchMode({
+    runBatched: function () {
+      // Nothing.
+    }
+  }, null);
+  yield promise;
+});
+
+add_task(function* onItemAdded_bookmark() {
+  const TITLE = "Bookmark 1";
+  let uri = NetUtil.newURI("http://1.mozilla.org/");
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemAdded"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemAdded",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "title", check: v => v === TITLE },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       uri, PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       TITLE);
+  yield promise;
+});
+
+add_task(function* onItemAdded_separator() {
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemAdded"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemAdded",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "index", check: v => v === 1 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_SEPARATOR },
+          { name: "uri", check: v => v === null },
+          { name: "title", check: v => v === null },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.bookmarks.insertSeparator(PlacesUtils.unfiledBookmarksFolderId,
+                                        PlacesUtils.bookmarks.DEFAULT_INDEX);
+  yield promise;
+});
+
+add_task(function* onItemAdded_folder() {
+  const TITLE = "Folder 1";
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemAdded"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemAdded",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "index", check: v => v === 2 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "uri", check: v => v === null },
+          { name: "title", check: v => v === TITLE },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.bookmarks.createFolder(PlacesUtils.unfiledBookmarksFolderId,
+                                     TITLE,
+                                     PlacesUtils.bookmarks.DEFAULT_INDEX);
+  yield promise;
+});
+
+add_task(function* onItemChanged_title_bookmark() {
+  let id = PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0);
+  const TITLE = "New title";
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemChanged"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemChanged", // This is an unfortunate effect of bug 653910.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "property", check: v => v === "title" },
+          { name: "isAnno", check: v => v === false },
+          { name: "newValue", check: v => v === TITLE },
+          { name: "lastModified", check: v => typeof(v) == "number" && v > 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldValue", check: v => typeof(v) == "string" },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.bookmarks.setItemTitle(id, TITLE);
+  yield promise;
+});
+
+add_task(function* onItemChanged_tags_bookmark() {
+  let id = PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0);
+  let uri = PlacesUtils.bookmarks.getBookmarkURI(id);
+  const TAG = "tag";
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemChanged", "onItemChanged"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemAdded", // This is the tag folder.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.tagsFolderId },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "uri", check: v => v === null },
+          { name: "title", check: v => v === TAG },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemAdded", // This is the tag.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "title", check: v => v === null },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemChanged",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "property", check: v => v === "tags" },
+          { name: "isAnno", check: v => v === false },
+          { name: "newValue", check: v => v === "" },
+          { name: "lastModified", check: v => typeof(v) == "number" && v > 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldValue", check: v => typeof(v) == "string" },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved", // This is the tag.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved", // This is the tag folder.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.tagsFolderId },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "uri", check: v => v === null },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemChanged",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "property", check: v => v === "tags" },
+          { name: "isAnno", check: v => v === false },
+          { name: "newValue", check: v => v === "" },
+          { name: "lastModified", check: v => typeof(v) == "number" && v > 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldValue", check: v => typeof(v) == "string" },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.tagging.tagURI(uri, [TAG]);
+  PlacesUtils.tagging.untagURI(uri, [TAG]);
+  yield promise;
+});
+
+add_task(function* onItemMoved_bookmark() {
+  let id = PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0);
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemMoved", "onItemMoved"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemMoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "oldParentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "oldIndex", check: v => v === 0 },
+          { name: "newParentId", check: v => v === PlacesUtils.toolbarFolderId },
+          { name: "newIndex", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldParentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "newParentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemMoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "oldParentId", check: v => v === PlacesUtils.toolbarFolderId },
+          { name: "oldIndex", check: v => v === 0 },
+          { name: "newParentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "newIndex", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldParentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "newParentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.bookmarks.moveItem(id, PlacesUtils.toolbarFolderId, 0);
+  PlacesUtils.bookmarks.moveItem(id, PlacesUtils.unfiledBookmarksFolderId, 0);
+  yield promise;
+});
+
+add_task(function* onItemMoved_bookmark() {
+  let id = PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0);
+  let uri = PlacesUtils.bookmarks.getBookmarkURI(id);
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemVisited"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemVisited",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "visitId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "time", check: v => typeof(v) == "number" && v > 0 },
+          { name: "transitionType", check: v => v === PlacesUtils.history.TRANSITION_TYPED },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+        ] },
+  ])]);
+  PlacesTestUtils.addVisits({ uri: uri, transition: TRANSITION_TYPED });
+  yield promise;
+});
+
+add_task(function* onItemRemoved_bookmark() {
+  let id = PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0);
+  let uri = PlacesUtils.bookmarks.getBookmarkURI(id);
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemChanged", "onItemRemoved"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemChanged", // This is an unfortunate effect of bug 653910.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "property", check: v => v === "" },
+          { name: "isAnno", check: v => v === true },
+          { name: "newValue", check: v => v === "" },
+          { name: "lastModified", check: v => typeof(v) == "number" && v > 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldValue", check: v => typeof(v) == "string" },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.bookmarks.removeItem(id);
+  yield promise;
+});
+
+add_task(function* onItemRemoved_separator() {
+  let id = PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0);
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemChanged", "onItemRemoved"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemChanged", // This is an unfortunate effect of bug 653910.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "property", check: v => v === "" },
+          { name: "isAnno", check: v => v === true },
+          { name: "newValue", check: v => v === "" },
+          { name: "lastModified", check: v => typeof(v) == "number" && v > 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_SEPARATOR },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldValue", check: v => typeof(v) == "string" },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_SEPARATOR },
+          { name: "uri", check: v => v === null },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.bookmarks.removeItem(id);
+  yield promise;
+});
+
+add_task(function* onItemRemoved_folder() {
+  let id = PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0);
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemChanged", "onItemRemoved"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemChanged", // This is an unfortunate effect of bug 653910.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "property", check: v => v === "" },
+          { name: "isAnno", check: v => v === true },
+          { name: "newValue", check: v => v === "" },
+          { name: "lastModified", check: v => typeof(v) == "number" && v > 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldValue", check: v => typeof(v) == "string" },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "uri", check: v => v === null },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  PlacesUtils.bookmarks.removeItem(id);
+  yield promise;
+});
+
+add_task(function* onItemRemoved_folder_recursive() {
+  const TITLE = "Folder 3";
+  const BMTITLE = "Bookmark 1";
+  let uri = NetUtil.newURI("http://1.mozilla.org/");
+  let promise = Promise.all([
+    gBookmarkSkipObserver.setup([
+      "onItemAdded", "onItemAdded", "onItemAdded", "onItemAdded",
+      "onItemChanged", "onItemRemoved"
+    ]),
+    gBookmarksObserver.setup([
+      { name: "onItemAdded",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.unfiledBookmarksFolderId },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "uri", check: v => v === null },
+          { name: "title", check: v => v === TITLE },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemAdded",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0) },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "title", check: v => v === BMTITLE },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemAdded",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0) },
+          { name: "index", check: v => v === 1 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "uri", check: v => v === null },
+          { name: "title", check: v => v === TITLE },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemAdded",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => v === PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0), 1) },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "title", check: v => v === BMTITLE },
+          { name: "dateAdded", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemChanged", // This is an unfortunate effect of bug 653910.
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "property", check: v => v === "" },
+          { name: "isAnno", check: v => v === true },
+          { name: "newValue", check: v => v === "" },
+          { name: "lastModified", check: v => typeof(v) == "number" && v > 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "oldValue", check: v => typeof(v) == "string" },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "index", check: v => v === 1 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "uri", check: v => v === null },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_BOOKMARK },
+          { name: "uri", check: v => v instanceof Ci.nsIURI && v.equals(uri) },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+      { name: "onItemRemoved",
+        args: [
+          { name: "itemId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "parentId", check: v => typeof(v) == "number" && v > 0 },
+          { name: "index", check: v => v === 0 },
+          { name: "itemType", check: v => v === PlacesUtils.bookmarks.TYPE_FOLDER },
+          { name: "uri", check: v => v === null },
+          { name: "guid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "parentGuid", check: v => typeof(v) == "string" && GUID_RE.test(v) },
+          { name: "source", check: v => Object.values(PlacesUtils.bookmarks.SOURCES).includes(v) },
+        ] },
+  ])]);
+  let folder = PlacesUtils.bookmarks.createFolder(PlacesUtils.unfiledBookmarksFolderId,
+                                                  TITLE,
+                                                  PlacesUtils.bookmarks.DEFAULT_INDEX);
+  PlacesUtils.bookmarks.insertBookmark(folder,
+                                       uri, PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       BMTITLE);
+  let folder2 = PlacesUtils.bookmarks.createFolder(folder, TITLE,
+                                                   PlacesUtils.bookmarks.DEFAULT_INDEX);
+  PlacesUtils.bookmarks.insertBookmark(folder2,
+                                       uri, PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       BMTITLE);
+
+  PlacesUtils.bookmarks.removeItem(folder);
+  yield promise;
+});
+
+add_task(function cleanup()
+{
+  PlacesUtils.bookmarks.removeObserver(gBookmarksObserver);
+  PlacesUtils.bookmarks.removeObserver(gBookmarkSkipObserver);
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_protectRoots.js b/toolkit/components/places/tests/bookmarks/test_protectRoots.js
new file mode 100644
index 000000000..0a59f1653
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_protectRoots.js
@@ -0,0 +1,37 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test()
+{
+  const ROOTS = [
+    PlacesUtils.bookmarksMenuFolderId,
+    PlacesUtils.toolbarFolderId,
+    PlacesUtils.unfiledBookmarksFolderId,
+    PlacesUtils.tagsFolderId,
+    PlacesUtils.placesRootId,
+    PlacesUtils.mobileFolderId,
+  ];
+
+  for (let root of ROOTS) {
+    do_check_true(PlacesUtils.isRootItem(root));
+
+    try {
+      PlacesUtils.bookmarks.removeItem(root);
+      do_throw("Trying to remove a root should throw");
+    } catch (ex) {}
+
+    try {
+      PlacesUtils.bookmarks.moveItem(root, PlacesUtils.placesRootId, 0);
+      do_throw("Trying to move a root should throw");
+    } catch (ex) {}
+
+    try {
+      PlacesUtils.bookmarks.removeFolderChildren(root);
+      if (root == PlacesUtils.placesRootId)
+        do_throw("Trying to remove children of the main root should throw");
+    } catch (ex) {
+      if (root != PlacesUtils.placesRootId)
+        do_throw("Trying to remove children of other roots should not throw");
+    }
+  }
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_removeFolderTransaction_reinsert.js b/toolkit/components/places/tests/bookmarks/test_removeFolderTransaction_reinsert.js
new file mode 100644
index 000000000..537974b38
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_removeFolderTransaction_reinsert.js
@@ -0,0 +1,70 @@
+/**
+ * This test ensures that reinserting a folder within a transaction gives it
+ * a different GUID, and passes the GUID to the observers.
+ */
+
+add_task(function* test_removeFolderTransaction_reinsert() {
+  let folder = yield PlacesUtils.bookmarks.insert({
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    parentGuid: PlacesUtils.bookmarks.menuGuid,
+    title: "Test folder",
+  });
+  let folderId = yield PlacesUtils.promiseItemId(folder.guid);
+  let fx = yield PlacesUtils.bookmarks.insert({
+    parentGuid: folder.guid,
+    title: "Get Firefox!",
+    url: "http://getfirefox.com",
+  });
+  let fxId = yield PlacesUtils.promiseItemId(fx.guid);
+  let tb = yield PlacesUtils.bookmarks.insert({
+    parentGuid: folder.guid,
+    title: "Get Thunderbird!",
+    url: "http://getthunderbird.com",
+  });
+  let tbId = yield PlacesUtils.promiseItemId(tb.guid);
+
+  let notifications = [];
+  function checkNotifications(expected, message) {
+    deepEqual(notifications, expected, message);
+    notifications.length = 0;
+  }
+
+  let observer = {
+    onItemAdded(itemId, parentId, index, type, uri, title, dateAdded, guid,
+                parentGuid) {
+      notifications.push(["onItemAdded", itemId, parentId, guid, parentGuid]);
+    },
+    onItemRemoved(itemId, parentId, index, type, uri, guid, parentGuid) {
+      notifications.push(["onItemRemoved", itemId, parentId, guid, parentGuid]);
+    },
+  };
+  PlacesUtils.bookmarks.addObserver(observer, false);
+  PlacesUtils.registerShutdownFunction(function() {
+    PlacesUtils.bookmarks.removeObserver(observer);
+  });
+
+  let transaction = PlacesUtils.bookmarks.getRemoveFolderTransaction(folderId);
+  deepEqual(notifications, [], "We haven't executed the transaction yet");
+
+  transaction.doTransaction();
+  checkNotifications([
+    ["onItemRemoved", tbId, folderId, tb.guid, folder.guid],
+    ["onItemRemoved", fxId, folderId, fx.guid, folder.guid],
+    ["onItemRemoved", folderId, PlacesUtils.bookmarksMenuFolderId, folder.guid,
+      PlacesUtils.bookmarks.menuGuid],
+  ], "Executing transaction should remove folder and its descendants");
+
+  transaction.undoTransaction();
+  // At this point, the restored folder has the same ID, but a different GUID.
+  let newFolderGuid = yield PlacesUtils.promiseItemGuid(folderId);
+  checkNotifications([
+    ["onItemAdded", folderId, PlacesUtils.bookmarksMenuFolderId, newFolderGuid,
+      PlacesUtils.bookmarks.menuGuid],
+  ], "Undo should reinsert folder with same ID and different GUID");
+
+  transaction.redoTransaction();
+  checkNotifications([
+    ["onItemRemoved", folderId, PlacesUtils.bookmarksMenuFolderId,
+      newFolderGuid, PlacesUtils.bookmarks.menuGuid],
+  ], "Redo should forward new GUID to observer");
+});
diff --git a/toolkit/components/places/tests/bookmarks/test_removeItem.js b/toolkit/components/places/tests/bookmarks/test_removeItem.js
new file mode 100644
index 000000000..ec846b28e
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_removeItem.js
@@ -0,0 +1,30 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var tests = [];
+
+
+const DEFAULT_INDEX = PlacesUtils.bookmarks.DEFAULT_INDEX;
+
+function run_test() {
+  // folder to hold this test
+  var folderId =
+    PlacesUtils.bookmarks.createFolder(PlacesUtils.toolbarFolderId,
+                                       "", DEFAULT_INDEX);
+
+  // add a bookmark to the new folder
+  var bookmarkURI = uri("http://iasdjkf");
+  do_check_false(PlacesUtils.bookmarks.isBookmarked(bookmarkURI));
+  var bookmarkId = PlacesUtils.bookmarks.insertBookmark(folderId, bookmarkURI,
+                                                        DEFAULT_INDEX, "");
+  do_check_eq(PlacesUtils.bookmarks.getItemTitle(bookmarkId), "");
+
+  // remove the folder using removeItem
+  PlacesUtils.bookmarks.removeItem(folderId);
+  do_check_eq(PlacesUtils.bookmarks.getBookmarkIdsForURI(bookmarkURI).length, 0);
+  do_check_false(PlacesUtils.bookmarks.isBookmarked(bookmarkURI));
+  do_check_eq(PlacesUtils.bookmarks.getItemIndex(bookmarkId), -1);
+}
diff --git a/toolkit/components/places/tests/bookmarks/test_savedsearches.js b/toolkit/components/places/tests/bookmarks/test_savedsearches.js
new file mode 100644
index 000000000..eee2c4489
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/test_savedsearches.js
@@ -0,0 +1,209 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// get bookmarks root id
+var root = PlacesUtils.bookmarksMenuFolderId;
+
+// a search term that matches a default bookmark
+const searchTerm = "about";
+
+var testRoot;
+
+// main
+function run_test() {
+  // create a folder to hold all the tests
+  // this makes the tests more tolerant of changes to the default bookmarks set
+  // also, name it using the search term, for testing that containers that match don't show up in query results
+  testRoot = PlacesUtils.bookmarks.createFolder(
+    root, searchTerm, PlacesUtils.bookmarks.DEFAULT_INDEX);
+
+  run_next_test();
+}
+
+add_test(function test_savedsearches_bookmarks() {
+  // add a bookmark that matches the search term
+  var bookmarkId = PlacesUtils.bookmarks.insertBookmark(
+    root, uri("http://foo.com"), PlacesUtils.bookmarks.DEFAULT_INDEX,
+    searchTerm);
+
+  // create a saved-search that matches a default bookmark
+  var searchId = PlacesUtils.bookmarks.insertBookmark(
+    testRoot, uri("place:terms=" + searchTerm + "&excludeQueries=1&expandQueries=1&queryType=1"),
+    PlacesUtils.bookmarks.DEFAULT_INDEX, searchTerm);
+
+  // query for the test root, expandQueries=0
+  // the query should show up as a regular bookmark
+  try {
+    let options = PlacesUtils.history.getNewQueryOptions();
+    options.expandQueries = 0;
+    let query = PlacesUtils.history.getNewQuery();
+    query.setFolders([testRoot], 1);
+    let result = PlacesUtils.history.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    let cc = rootNode.childCount;
+    do_check_eq(cc, 1);
+    for (let i = 0; i < cc; i++) {
+      let node = rootNode.getChild(i);
+      // test that queries have valid itemId
+      do_check_true(node.itemId > 0);
+      // test that the container is closed
+      node.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+      do_check_eq(node.containerOpen, false);
+    }
+    rootNode.containerOpen = false;
+  }
+  catch (ex) {
+    do_throw("expandQueries=0 query error: " + ex);
+  }
+
+  // bookmark saved search
+  // query for the test root, expandQueries=1
+  // the query should show up as a query container, with 1 child
+  try {
+    let options = PlacesUtils.history.getNewQueryOptions();
+    options.expandQueries = 1;
+    let query = PlacesUtils.history.getNewQuery();
+    query.setFolders([testRoot], 1);
+    let result = PlacesUtils.history.executeQuery(query, options);
+    let rootNode = result.root;
+    rootNode.containerOpen = true;
+    let cc = rootNode.childCount;
+    do_check_eq(cc, 1);
+    for (let i = 0; i < cc; i++) {
+      let node = rootNode.getChild(i);
+      // test that query node type is container when expandQueries=1
+      do_check_eq(node.type, node.RESULT_TYPE_QUERY);
+      // test that queries (as containers) have valid itemId
+      do_check_true(node.itemId > 0);
+      node.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+      node.containerOpen = true;
+
+      // test that queries have children when excludeItems=1
+      // test that query nodes don't show containers (shouldn't have our folder that matches)
+      // test that queries don't show themselves in query results (shouldn't have our saved search)
+      do_check_eq(node.childCount, 1);
+
+      // test that bookmark shows in query results
+      var item = node.getChild(0);
+      do_check_eq(item.itemId, bookmarkId);
+
+      // XXX - FAILING - test live-update of query results - add a bookmark that matches the query
+      // var tmpBmId = PlacesUtils.bookmarks.insertBookmark(
+      //  root, uri("http://" + searchTerm + ".com"),
+      //  PlacesUtils.bookmarks.DEFAULT_INDEX, searchTerm + "blah");
+      // do_check_eq(query.childCount, 2);
+
+      // XXX - test live-update of query results - delete a bookmark that matches the query
+      // PlacesUtils.bookmarks.removeItem(tmpBMId);
+      // do_check_eq(query.childCount, 1);
+
+      // test live-update of query results - add a folder that matches the query
+      PlacesUtils.bookmarks.createFolder(
+        root, searchTerm + "zaa", PlacesUtils.bookmarks.DEFAULT_INDEX);
+      do_check_eq(node.childCount, 1);
+      // test live-update of query results - add a query that matches the query
+      PlacesUtils.bookmarks.insertBookmark(
+        root, uri("place:terms=foo&excludeQueries=1&expandQueries=1&queryType=1"),
+        PlacesUtils.bookmarks.DEFAULT_INDEX, searchTerm + "blah");
+      do_check_eq(node.childCount, 1);
+    }
+    rootNode.containerOpen = false;
+  }
+  catch (ex) {
+    do_throw("expandQueries=1 bookmarks query: " + ex);
+  }
+
+  // delete the bookmark search
+  PlacesUtils.bookmarks.removeItem(searchId);
+
+  run_next_test();
+});
+
+add_task(function* test_savedsearches_history() {
+  // add a visit that matches the search term
+  var testURI = uri("http://" + searchTerm + ".com");
+  yield PlacesTestUtils.addVisits({ uri: testURI, title: searchTerm });
+
+  // create a saved-search that matches the visit we added
+  var searchId = PlacesUtils.bookmarks.insertBookmark(testRoot,
+    uri("place:terms=" + searchTerm + "&excludeQueries=1&expandQueries=1&queryType=0"),
+    PlacesUtils.bookmarks.DEFAULT_INDEX, searchTerm);
+
+  // query for the test root, expandQueries=1
+  // the query should show up as a query container, with 1 child
+  try {
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.expandQueries = 1;
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([testRoot], 1);
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var rootNode = result.root;
+    rootNode.containerOpen = true;
+    var cc = rootNode.childCount;
+    do_check_eq(cc, 1);
+    for (var i = 0; i < cc; i++) {
+      var node = rootNode.getChild(i);
+      // test that query node type is container when expandQueries=1
+      do_check_eq(node.type, node.RESULT_TYPE_QUERY);
+      // test that queries (as containers) have valid itemId
+      do_check_eq(node.itemId, searchId);
+      node.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+      node.containerOpen = true;
+
+      // test that queries have children when excludeItems=1
+      // test that query nodes don't show containers (shouldn't have our folder that matches)
+      // test that queries don't show themselves in query results (shouldn't have our saved search)
+      do_check_eq(node.childCount, 1);
+
+      // test that history visit shows in query results
+      var item = node.getChild(0);
+      do_check_eq(item.type, item.RESULT_TYPE_URI);
+      do_check_eq(item.itemId, -1); // history visit
+      do_check_eq(item.uri, testURI.spec); // history visit
+
+      // test live-update of query results - add a history visit that matches the query
+      yield PlacesTestUtils.addVisits({
+        uri: uri("http://foo.com"),
+        title: searchTerm + "blah"
+      });
+      do_check_eq(node.childCount, 2);
+
+      // test live-update of query results - delete a history visit that matches the query
+      PlacesUtils.history.removePage(uri("http://foo.com"));
+      do_check_eq(node.childCount, 1);
+      node.containerOpen = false;
+    }
+
+    // test live-update of moved queries
+    var tmpFolderId = PlacesUtils.bookmarks.createFolder(
+      testRoot, "foo", PlacesUtils.bookmarks.DEFAULT_INDEX);
+    PlacesUtils.bookmarks.moveItem(
+      searchId, tmpFolderId, PlacesUtils.bookmarks.DEFAULT_INDEX);
+    var tmpFolderNode = rootNode.getChild(0);
+    do_check_eq(tmpFolderNode.itemId, tmpFolderId);
+    tmpFolderNode.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+    tmpFolderNode.containerOpen = true;
+    do_check_eq(tmpFolderNode.childCount, 1);
+
+    // test live-update of renamed queries
+    PlacesUtils.bookmarks.setItemTitle(searchId, "foo");
+    do_check_eq(tmpFolderNode.title, "foo");
+
+    // test live-update of deleted queries
+    PlacesUtils.bookmarks.removeItem(searchId);
+    try {
+      tmpFolderNode = root.getChild(1);
+      do_throw("query was not removed");
+    } catch (ex) {}
+
+    tmpFolderNode.containerOpen = false;
+    rootNode.containerOpen = false;
+  }
+  catch (ex) {
+    do_throw("expandQueries=1 bookmarks query: " + ex);
+  }
+});
diff --git a/toolkit/components/places/tests/bookmarks/xpcshell.ini b/toolkit/components/places/tests/bookmarks/xpcshell.ini
new file mode 100644
index 000000000..c290fd693
--- /dev/null
+++ b/toolkit/components/places/tests/bookmarks/xpcshell.ini
@@ -0,0 +1,50 @@
+[DEFAULT]
+head = head_bookmarks.js
+tail =
+skip-if = toolkit == 'android'
+
+[test_1016953-renaming-uncompressed.js]
+[test_1017502-bookmarks_foreign_count.js]
+[test_384228.js]
+[test_385829.js]
+[test_388695.js]
+[test_393498.js]
+[test_395101.js]
+[test_395593.js]
+[test_405938_restore_queries.js]
+[test_417228-exclude-from-backup.js]
+[test_417228-other-roots.js]
+[test_424958-json-quoted-folders.js]
+[test_448584.js]
+[test_458683.js]
+[test_466303-json-remove-backups.js]
+[test_477583_json-backup-in-future.js]
+[test_675416.js]
+[test_711914.js]
+[test_818584-discard-duplicate-backups.js]
+[test_818587_compress-bookmarks-backups.js]
+[test_818593-store-backup-metadata.js]
+[test_992901-backup-unsorted-hierarchy.js]
+[test_997030-bookmarks-html-encode.js]
+[test_1129529.js]
+[test_async_observers.js]
+[test_bmindex.js]
+[test_bookmarkstree_cache.js]
+[test_bookmarks.js]
+[test_bookmarks_eraseEverything.js]
+[test_bookmarks_fetch.js]
+[test_bookmarks_getRecent.js]
+[test_bookmarks_insert.js]
+[test_bookmarks_notifications.js]
+[test_bookmarks_remove.js]
+[test_bookmarks_reorder.js]
+[test_bookmarks_search.js]
+[test_bookmarks_update.js]
+[test_changeBookmarkURI.js]
+[test_getBookmarkedURIFor.js]
+[test_keywords.js]
+[test_nsINavBookmarkObserver.js]
+[test_protectRoots.js]
+[test_removeFolderTransaction_reinsert.js]
+[test_removeItem.js]
+[test_savedsearches.js]
diff --git a/toolkit/components/places/tests/browser/.eslintrc.js b/toolkit/components/places/tests/browser/.eslintrc.js
new file mode 100644
index 000000000..7a41a9cde
--- /dev/null
+++ b/toolkit/components/places/tests/browser/.eslintrc.js
@@ -0,0 +1,8 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/mochitest/browser.eslintrc.js",
+    "../../../../../testing/mochitest/mochitest.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/browser/399606-history.go-0.html b/toolkit/components/places/tests/browser/399606-history.go-0.html
new file mode 100644
index 000000000..039708ed7
--- /dev/null
+++ b/toolkit/components/places/tests/browser/399606-history.go-0.html
@@ -0,0 +1,11 @@
+<html>
+<head>
+<title>history.go(0)</title>
+<script>
+setTimeout('history.go(0)', 1000);
+</script>
+</head>
+<body>
+Testing history.go(0)
+</body>
+</html>
diff --git a/toolkit/components/places/tests/browser/399606-httprefresh.html b/toolkit/components/places/tests/browser/399606-httprefresh.html
new file mode 100644
index 000000000..e43455ee0
--- /dev/null
+++ b/toolkit/components/places/tests/browser/399606-httprefresh.html
@@ -0,0 +1,8 @@
+<html><head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+
+<meta http-equiv="refresh" content="1">
+<title>httprefresh</title>
+</head><body>
+Testing httprefresh
+</body></html>
diff --git a/toolkit/components/places/tests/browser/399606-location.reload.html b/toolkit/components/places/tests/browser/399606-location.reload.html
new file mode 100644
index 000000000..0f46538cd
--- /dev/null
+++ b/toolkit/components/places/tests/browser/399606-location.reload.html
@@ -0,0 +1,11 @@
+<html>
+<head>
+<title>location.reload()</title>
+<script>
+setTimeout('location.reload();', 100);
+</script>
+</head>
+<body>
+Testing location.reload();
+</body>
+</html>
diff --git a/toolkit/components/places/tests/browser/399606-location.replace.html b/toolkit/components/places/tests/browser/399606-location.replace.html
new file mode 100644
index 000000000..36705402c
--- /dev/null
+++ b/toolkit/components/places/tests/browser/399606-location.replace.html
@@ -0,0 +1,11 @@
+<html>
+<head>
+<title>location.replace</title>
+<script>
+setTimeout('location.replace(window.location.href)', 1000);
+</script>
+</head>
+<body>
+Testing location.replace
+</body>
+</html>
diff --git a/toolkit/components/places/tests/browser/399606-window.location.href.html b/toolkit/components/places/tests/browser/399606-window.location.href.html
new file mode 100644
index 000000000..61a2c8ba0
--- /dev/null
+++ b/toolkit/components/places/tests/browser/399606-window.location.href.html
@@ -0,0 +1,11 @@
+<html>
+<head>
+<title>window.location.href</title>
+<script>
+setTimeout('window.location.href = window.location.href', 1000);
+</script>
+</head>
+<body>
+Testing window.location.href
+</body>
+</html>
diff --git a/toolkit/components/places/tests/browser/399606-window.location.html b/toolkit/components/places/tests/browser/399606-window.location.html
new file mode 100644
index 000000000..e77f73071
--- /dev/null
+++ b/toolkit/components/places/tests/browser/399606-window.location.html
@@ -0,0 +1,11 @@
+<html>
+<head>
+<title>window.location</title>
+<script>
+setTimeout('window.location = window.location', 1000);
+</script>
+</head>
+<body>
+Testing window.location
+</body>
+</html>
diff --git a/toolkit/components/places/tests/browser/461710_iframe.html b/toolkit/components/places/tests/browser/461710_iframe.html
new file mode 100644
index 000000000..7480fe58f
--- /dev/null
+++ b/toolkit/components/places/tests/browser/461710_iframe.html
@@ -0,0 +1,8 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+  </head>
+  <body>
+    <iframe id="iframe"></iframe>
+  </body>
+</html>
diff --git a/toolkit/components/places/tests/browser/461710_link_page-2.html b/toolkit/components/places/tests/browser/461710_link_page-2.html
new file mode 100644
index 000000000..1fc3e0959
--- /dev/null
+++ b/toolkit/components/places/tests/browser/461710_link_page-2.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>

+<html>

+  <head>

+    <title>Link page 2</title>

+    <style type="text/css">

+      a:link { color: #0000ff; }

+      a:visited { color: #ff0000; }

+    </style>

+  </head>

+  <body>

+    <p><a href="461710_visited_page.html" id="link">Link to the second visited page</a></p>

+  </body>

+</html>
\ No newline at end of file
diff --git a/toolkit/components/places/tests/browser/461710_link_page-3.html b/toolkit/components/places/tests/browser/461710_link_page-3.html
new file mode 100644
index 000000000..596661803
--- /dev/null
+++ b/toolkit/components/places/tests/browser/461710_link_page-3.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>

+<html>

+  <head>

+    <title>Link page 3</title>

+    <style type="text/css">

+      a:link { color: #0000ff; }

+      a:visited { color: #ff0000; }

+    </style>

+  </head>

+  <body>

+    <p><a href="461710_visited_page.html" id="link">Link to the third visited page</a></p>

+  </body>

+</html>
\ No newline at end of file
diff --git a/toolkit/components/places/tests/browser/461710_link_page.html b/toolkit/components/places/tests/browser/461710_link_page.html
new file mode 100644
index 000000000..6bea50628
--- /dev/null
+++ b/toolkit/components/places/tests/browser/461710_link_page.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>

+<html>

+  <head>

+    <title>Link page</title>

+    <style type="text/css">

+      a:link { color: #0000ff; }

+      a:visited { color: #ff0000; }

+    </style>

+  </head>

+  <body>

+    <p><a href="461710_visited_page.html" id="link">Link to the visited page</a></p>

+  </body>

+</html>
\ No newline at end of file
diff --git a/toolkit/components/places/tests/browser/461710_visited_page.html b/toolkit/components/places/tests/browser/461710_visited_page.html
new file mode 100644
index 000000000..90e65116b
--- /dev/null
+++ b/toolkit/components/places/tests/browser/461710_visited_page.html
@@ -0,0 +1,9 @@
+<!DOCTYPE HTML>

+<html>

+  <head>

+    <title>Visited page</title>

+  </head>

+  <body>

+    <p>This page is marked as visited</p>

+  </body>

+</html>
\ No newline at end of file
diff --git a/toolkit/components/places/tests/browser/begin.html b/toolkit/components/places/tests/browser/begin.html
new file mode 100644
index 000000000..da4c16dd2
--- /dev/null
+++ b/toolkit/components/places/tests/browser/begin.html
@@ -0,0 +1,10 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+
+<html>
+  <body>
+    <a id="clickme" href="redirect_twice.sjs">Redirect twice</a>
+  </body>
+</html>
diff --git a/toolkit/components/places/tests/browser/browser.ini b/toolkit/components/places/tests/browser/browser.ini
new file mode 100644
index 000000000..e6abe987f
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser.ini
@@ -0,0 +1,26 @@
+[DEFAULT]
+support-files =
+  colorAnalyzer/category-discover.png
+  colorAnalyzer/dictionaryGeneric-16.png
+  colorAnalyzer/extensionGeneric-16.png
+  colorAnalyzer/localeGeneric.png
+  head.js
+
+[browser_bug248970.js]
+[browser_bug399606.js]
+[browser_bug461710.js]
+[browser_bug646422.js]
+[browser_bug680727.js]
+[browser_colorAnalyzer.js]
+[browser_double_redirect.js]
+[browser_favicon_privatebrowsing_perwindowpb.js]
+[browser_favicon_setAndFetchFaviconForPage.js]
+[browser_favicon_setAndFetchFaviconForPage_failures.js]
+[browser_history_post.js]
+[browser_notfound.js]
+[browser_redirect.js]
+[browser_settitle.js]
+[browser_visited_notfound.js]
+[browser_visituri.js]
+[browser_visituri_nohistory.js]
+[browser_visituri_privatebrowsing_perwindowpb.js]
\ No newline at end of file
diff --git a/toolkit/components/places/tests/browser/browser_bug248970.js b/toolkit/components/places/tests/browser/browser_bug248970.js
new file mode 100644
index 000000000..5850a3038
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_bug248970.js
@@ -0,0 +1,152 @@
+/* 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 test performs checks on the history testing area as outlined
+// https://wiki.mozilla.org/Firefox3.1/PrivateBrowsing/TestPlan#History
+// http://developer.mozilla.org/en/Using_the_Places_history_service
+
+var visitedURIs = [
+  "http://www.test-link.com/",
+  "http://www.test-typed.com/",
+  "http://www.test-bookmark.com/",
+  "http://www.test-redirect-permanent.com/",
+  "http://www.test-redirect-temporary.com/",
+  "http://www.test-embed.com/",
+  "http://www.test-framed.com/",
+  "http://www.test-download.com/"
+].map(NetUtil.newURI.bind(NetUtil));
+
+add_task(function* () {
+  let windowsToClose = [];
+  let placeItemsCount = 0;
+
+  registerCleanupFunction(function() {
+    windowsToClose.forEach(function(win) {
+      win.close();
+    });
+  });
+
+  yield PlacesTestUtils.clearHistory();
+
+   // Ensure we wait for the default bookmarks import.
+  yield new Promise(resolve => {
+    waitForCondition(() => {
+      placeItemsCount = getPlacesItemsCount();
+      return placeItemsCount > 0
+    }, resolve, "Should have default bookmarks")
+  });
+
+  // Create a handful of history items with various visit types
+  yield PlacesTestUtils.addVisits([
+    { uri: visitedURIs[0], transition: TRANSITION_LINK },
+    { uri: visitedURIs[1], transition: TRANSITION_TYPED },
+    { uri: visitedURIs[2], transition: TRANSITION_BOOKMARK },
+    { uri: visitedURIs[3], transition: TRANSITION_REDIRECT_PERMANENT },
+    { uri: visitedURIs[4], transition: TRANSITION_REDIRECT_TEMPORARY },
+    { uri: visitedURIs[5], transition: TRANSITION_EMBED },
+    { uri: visitedURIs[6], transition: TRANSITION_FRAMED_LINK },
+    { uri: visitedURIs[7], transition: TRANSITION_DOWNLOAD }
+  ]);
+
+  placeItemsCount += 7;
+  // We added 7 new items to history.
+  is(getPlacesItemsCount(), placeItemsCount,
+     "Check the total items count");
+
+  function* testOnWindow(aIsPrivate, aCount) {
+    let win = yield new Promise(resolve => {
+      whenNewWindowLoaded({ private: aIsPrivate }, resolve);
+    });
+    windowsToClose.push(win);
+
+    // History items should be retrievable by query
+    yield checkHistoryItems();
+
+    // Updates the place items count
+    let count = getPlacesItemsCount();
+
+    // Create Bookmark
+    let title = "title " + windowsToClose.length;
+    let keyword = "keyword " + windowsToClose.length;
+    let url = "http://test-a-" + windowsToClose.length + ".com/";
+
+    yield PlacesUtils.bookmarks.insert({ url, title,
+                                         parentGuid: PlacesUtils.bookmarks.menuGuid });
+    yield PlacesUtils.keywords.insert({ url, keyword });
+    count++;
+
+    ok((yield PlacesUtils.bookmarks.fetch({ url })),
+       "Bookmark should be bookmarked, data should be retrievable");
+    is(getPlacesItemsCount(), count,
+       "Check the new bookmark items count");
+    is(isBookmarkAltered(), false, "Check if bookmark has been visited");
+  }
+
+  // Test on windows.
+  yield testOnWindow(false);
+  yield testOnWindow(true);
+  yield testOnWindow(false);
+});
+
+/**
+ * Function performs a really simple query on our places entries,
+ * and makes sure that the number of entries equal num_places_entries.
+ */
+function getPlacesItemsCount() {
+  // Get bookmarks count
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.includeHidden = true;
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  let root = PlacesUtils.history.executeQuery(
+    PlacesUtils.history.getNewQuery(), options).root;
+  root.containerOpen = true;
+  let cc = root.childCount;
+  root.containerOpen = false;
+
+  // Get history item count
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_HISTORY;
+  root = PlacesUtils.history.executeQuery(
+    PlacesUtils.history.getNewQuery(), options).root;
+  root.containerOpen = true;
+  cc += root.childCount;
+  root.containerOpen = false;
+
+  return cc;
+}
+
+function* checkHistoryItems() {
+  for (let i = 0; i < visitedURIs.length; i++) {
+    let visitedUri = visitedURIs[i];
+    ok((yield promiseIsURIVisited(visitedUri)), "");
+    if (/embed/.test(visitedUri.spec)) {
+      is((yield PlacesTestUtils.isPageInDB(visitedUri)), false, "Check if URI is in database");
+    } else {
+      ok((yield PlacesTestUtils.isPageInDB(visitedUri)), "Check if URI is in database");
+    }
+  }
+}
+
+/**
+ * Function attempts to check if Bookmark-A has been visited
+ * during private browsing mode, function should return false
+ *
+ * @returns false if the accessCount has not changed
+ *          true if the accessCount has changed
+ */
+function isBookmarkAltered() {
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  options.maxResults = 1; // should only expect a new bookmark
+
+  let query = PlacesUtils.history.getNewQuery();
+  query.setFolders([PlacesUtils.bookmarks.bookmarksMenuFolder], 1);
+
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  is(root.childCount, options.maxResults, "Check new bookmarks results");
+  let node = root.getChild(0);
+  root.containerOpen = false;
+
+  return (node.accessCount != 0);
+}
diff --git a/toolkit/components/places/tests/browser/browser_bug399606.js b/toolkit/components/places/tests/browser/browser_bug399606.js
new file mode 100644
index 000000000..b5eee0f92
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_bug399606.js
@@ -0,0 +1,77 @@
+/* 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/. */
+
+gBrowser.selectedTab = gBrowser.addTab();
+
+function test() {
+  waitForExplicitFinish();
+
+  var URIs = [
+    "http://example.com/tests/toolkit/components/places/tests/browser/399606-window.location.href.html",
+    "http://example.com/tests/toolkit/components/places/tests/browser/399606-history.go-0.html",
+    "http://example.com/tests/toolkit/components/places/tests/browser/399606-location.replace.html",
+    "http://example.com/tests/toolkit/components/places/tests/browser/399606-location.reload.html",
+    "http://example.com/tests/toolkit/components/places/tests/browser/399606-httprefresh.html",
+    "http://example.com/tests/toolkit/components/places/tests/browser/399606-window.location.html",
+  ];
+  var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+           getService(Ci.nsINavHistoryService);
+
+  // Create and add history observer.
+  var historyObserver = {
+    visitCount: Array(),
+    onBeginUpdateBatch: function () {},
+    onEndUpdateBatch: function () {},
+    onVisit: function (aURI, aVisitID, aTime, aSessionID, aReferringID,
+                      aTransitionType) {
+      info("Received onVisit: " + aURI.spec);
+      if (aURI.spec in this.visitCount)
+        this.visitCount[aURI.spec]++;
+      else
+        this.visitCount[aURI.spec] = 1;
+    },
+    onTitleChanged: function () {},
+    onDeleteURI: function () {},
+    onClearHistory: function () {},
+    onPageChanged: function () {},
+    onDeleteVisits: function () {},
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver])
+  };
+  hs.addObserver(historyObserver, false);
+
+  function confirm_results() {
+    gBrowser.removeCurrentTab();
+    hs.removeObserver(historyObserver, false);
+    for (let aURI in historyObserver.visitCount) {
+      is(historyObserver.visitCount[aURI], 1,
+         "onVisit has been received right number of times for " + aURI);
+    }
+    PlacesTestUtils.clearHistory().then(finish);
+  }
+
+  var loadCount = 0;
+  function handleLoad(aEvent) {
+    loadCount++;
+    info("new load count is " + loadCount);
+
+    if (loadCount == 3) {
+      gBrowser.removeEventListener("DOMContentLoaded", handleLoad, true);
+      gBrowser.loadURI("about:blank");
+      executeSoon(check_next_uri);
+    }
+  }
+
+  function check_next_uri() {
+    if (URIs.length) {
+      let uri = URIs.shift();
+      loadCount = 0;
+      gBrowser.addEventListener("DOMContentLoaded", handleLoad, true);
+      gBrowser.loadURI(uri);
+    }
+    else {
+      confirm_results();
+    }
+  }
+  executeSoon(check_next_uri);
+}
diff --git a/toolkit/components/places/tests/browser/browser_bug461710.js b/toolkit/components/places/tests/browser/browser_bug461710.js
new file mode 100644
index 000000000..12af87a06
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_bug461710.js
@@ -0,0 +1,82 @@
+const kRed = "rgb(255, 0, 0)";
+const kBlue = "rgb(0, 0, 255)";
+
+const prefix = "http://example.com/tests/toolkit/components/places/tests/browser/461710_";
+
+add_task(function* () {
+  let contentPage = prefix + "iframe.html";
+  let normalWindow = yield BrowserTestUtils.openNewBrowserWindow();
+
+  let browser = normalWindow.gBrowser.selectedBrowser;
+  BrowserTestUtils.loadURI(browser, contentPage);
+  yield BrowserTestUtils.browserLoaded(browser, contentPage);
+
+  let privateWindow = yield BrowserTestUtils.openNewBrowserWindow({private: true});
+
+  browser = privateWindow.gBrowser.selectedBrowser;
+  BrowserTestUtils.loadURI(browser, contentPage);
+  yield BrowserTestUtils.browserLoaded(browser, contentPage);
+
+  let tests = [{
+    win: normalWindow,
+    topic: "uri-visit-saved",
+    subtest: "visited_page.html"
+  }, {
+    win: normalWindow,
+    topic: "visited-status-resolution",
+    subtest: "link_page.html",
+    color: kRed,
+    message: "Visited link coloring should work outside of private mode"
+  }, {
+    win: privateWindow,
+    topic: "visited-status-resolution",
+    subtest: "link_page-2.html",
+    color: kBlue,
+    message: "Visited link coloring should not work inside of private mode"
+  }, {
+    win: normalWindow,
+    topic: "visited-status-resolution",
+    subtest: "link_page-3.html",
+    color: kRed,
+    message: "Visited link coloring should work outside of private mode"
+  }];
+
+  let visited_page_url = prefix + tests[0].subtest;
+  for (let test of tests) {
+    let promise = new Promise(resolve => {
+      let uri = NetUtil.newURI(visited_page_url);
+      Services.obs.addObserver(function observe(aSubject) {
+        if (uri.equals(aSubject.QueryInterface(Ci.nsIURI))) {
+          Services.obs.removeObserver(observe, test.topic);
+          resolve();
+        }
+      }, test.topic, false);
+    });
+    ContentTask.spawn(test.win.gBrowser.selectedBrowser, prefix + test.subtest, function* (aSrc) {
+      content.document.getElementById("iframe").src = aSrc;
+    });
+    yield promise;
+
+    if (test.color) {
+      // In e10s waiting for visited-status-resolution is not enough to ensure links
+      // have been updated, because it only tells us that messages to update links
+      // have been dispatched. We must still wait for the actual links to update.
+      yield BrowserTestUtils.waitForCondition(function* () {
+        let color = yield ContentTask.spawn(test.win.gBrowser.selectedBrowser, null, function* () {
+          let iframe = content.document.getElementById("iframe");
+          let elem = iframe.contentDocument.getElementById("link");
+          return content.QueryInterface(Ci.nsIInterfaceRequestor)
+                        .getInterface(Ci.nsIDOMWindowUtils)
+                        .getVisitedDependentComputedStyle(elem, "", "color");
+        });
+        return (color == test.color);
+      }, test.message);
+      // The harness will consider the test as failed overall if there were no
+      // passes or failures, so record it as a pass.
+      ok(true, test.message);
+    }
+  }
+
+  yield BrowserTestUtils.closeWindow(normalWindow);
+  yield BrowserTestUtils.closeWindow(privateWindow);
+});
diff --git a/toolkit/components/places/tests/browser/browser_bug646422.js b/toolkit/components/places/tests/browser/browser_bug646422.js
new file mode 100644
index 000000000..1a81de4e1
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_bug646422.js
@@ -0,0 +1,51 @@
+/* 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/. */
+
+/**
+ * Test for Bug 646224.  Make sure that after changing the URI via
+ * history.pushState, the history service has a title stored for the new URI.
+ **/
+
+add_task(function* () {
+  let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, 'http://example.com');
+
+  let newTitlePromise = new Promise(resolve => {
+    let observer = {
+      onTitleChanged: function(uri, title) {
+        // If the uri of the page whose title is changing ends with 'new_page',
+        // then it's the result of our pushState.
+        if (/new_page$/.test(uri.spec)) {
+          resolve(title);
+          PlacesUtils.history.removeObserver(observer);
+        }
+      },
+
+      onBeginUpdateBatch: function() { },
+      onEndUpdateBatch: function() { },
+      onVisit: function() { },
+      onDeleteURI: function() { },
+      onClearHistory: function() { },
+      onPageChanged: function() { },
+      onDeleteVisits: function() { },
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver])
+    };
+
+    PlacesUtils.history.addObserver(observer, false);
+  });
+
+  yield ContentTask.spawn(tab.linkedBrowser, null, function* () {
+    let title =  content.document.title;
+    content.history.pushState('', '', 'new_page');
+    Assert.ok(title, "Content window should initially have a title.");
+  });
+
+  let newtitle = yield newTitlePromise;
+
+  yield ContentTask.spawn(tab.linkedBrowser, { newtitle }, function* (args) {
+    Assert.equal(args.newtitle, content.document.title, "Title after pushstate.");
+  });
+
+  yield PlacesTestUtils.clearHistory();
+  gBrowser.removeTab(tab);
+});
diff --git a/toolkit/components/places/tests/browser/browser_bug680727.js b/toolkit/components/places/tests/browser/browser_bug680727.js
new file mode 100644
index 000000000..560cbfe6c
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_bug680727.js
@@ -0,0 +1,109 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/* Ensure that clicking the button in the Offline mode neterror page updates
+   global history. See bug 680727. */
+/* TEST_PATH=toolkit/components/places/tests/browser/browser_bug680727.js make -C $(OBJDIR) mochitest-browser-chrome */
+
+
+const kUniqueURI = Services.io.newURI("http://mochi.test:8888/#bug_680727",
+                                      null, null);
+var gAsyncHistory =
+  Cc["@mozilla.org/browser/history;1"].getService(Ci.mozIAsyncHistory);
+
+var proxyPrefValue;
+var ourTab;
+
+function test() {
+  waitForExplicitFinish();
+
+  // Tests always connect to localhost, and per bug 87717, localhost is now
+  // reachable in offline mode.  To avoid this, disable any proxy.
+  proxyPrefValue = Services.prefs.getIntPref("network.proxy.type");
+  Services.prefs.setIntPref("network.proxy.type", 0);
+
+  // Clear network cache.
+  Components.classes["@mozilla.org/netwerk/cache-storage-service;1"]
+            .getService(Components.interfaces.nsICacheStorageService)
+            .clear();
+
+  // Go offline, expecting the error page.
+  Services.io.offline = true;
+
+  BrowserTestUtils.openNewForegroundTab(gBrowser).then(tab => {
+    ourTab = tab;
+    BrowserTestUtils.waitForContentEvent(ourTab.linkedBrowser, "DOMContentLoaded")
+                    .then(errorListener);
+    BrowserTestUtils.loadURI(ourTab.linkedBrowser, kUniqueURI.spec);
+  });
+}
+
+// ------------------------------------------------------------------------------
+// listen to loading the neterror page. (offline mode)
+function errorListener() {
+  ok(Services.io.offline, "Services.io.offline is true.");
+
+  // This is an error page.
+  ContentTask.spawn(ourTab.linkedBrowser, kUniqueURI.spec, function(uri) {
+    Assert.equal(content.document.documentURI.substring(0, 27),
+      "about:neterror?e=netOffline", "Document URI is the error page.");
+
+    // But location bar should show the original request.
+    Assert.equal(content.location.href, uri, "Docshell URI is the original URI.");
+  }).then(() => {
+    // Global history does not record URI of a failed request.
+    return PlacesTestUtils.promiseAsyncUpdates().then(() => {
+      gAsyncHistory.isURIVisited(kUniqueURI, errorAsyncListener);
+    });
+  });
+}
+
+function errorAsyncListener(aURI, aIsVisited) {
+  ok(kUniqueURI.equals(aURI) && !aIsVisited,
+     "The neterror page is not listed in global history.");
+
+  Services.prefs.setIntPref("network.proxy.type", proxyPrefValue);
+
+  // Now press the "Try Again" button, with offline mode off.
+  Services.io.offline = false;
+
+  BrowserTestUtils.waitForContentEvent(ourTab.linkedBrowser, "DOMContentLoaded")
+                  .then(reloadListener);
+
+  ContentTask.spawn(ourTab.linkedBrowser, null, function() {
+    Assert.ok(content.document.getElementById("errorTryAgain"),
+      "The error page has got a #errorTryAgain element");
+    content.document.getElementById("errorTryAgain").click();
+  });
+}
+
+// ------------------------------------------------------------------------------
+// listen to reload of neterror.
+function reloadListener() {
+  // This listener catches "DOMContentLoaded" on being called
+  // nsIWPL::onLocationChange(...). That is right *AFTER*
+  // IHistory::VisitURI(...) is called.
+  ok(!Services.io.offline, "Services.io.offline is false.");
+
+  ContentTask.spawn(ourTab.linkedBrowser, kUniqueURI.spec, function(uri) {
+    // This is not an error page.
+    Assert.equal(content.document.documentURI, uri,
+      "Document URI is not the offline-error page, but the original URI.");
+  }).then(() => {
+    // Check if global history remembers the successfully-requested URI.
+    PlacesTestUtils.promiseAsyncUpdates().then(() => {
+      gAsyncHistory.isURIVisited(kUniqueURI, reloadAsyncListener);
+    });
+  });
+}
+
+function reloadAsyncListener(aURI, aIsVisited) {
+  ok(kUniqueURI.equals(aURI) && aIsVisited, "We have visited the URI.");
+  PlacesTestUtils.clearHistory().then(finish);
+}
+
+registerCleanupFunction(function* () {
+  Services.prefs.setIntPref("network.proxy.type", proxyPrefValue);
+  Services.io.offline = false;
+  yield BrowserTestUtils.removeTab(ourTab);
+});
diff --git a/toolkit/components/places/tests/browser/browser_colorAnalyzer.js b/toolkit/components/places/tests/browser/browser_colorAnalyzer.js
new file mode 100644
index 000000000..7b7fe6ec5
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_colorAnalyzer.js
@@ -0,0 +1,259 @@
+/* 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/. */
+
+"use strict";
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+const CA = Cc["@mozilla.org/places/colorAnalyzer;1"].
+           getService(Ci.mozIColorAnalyzer);
+
+const hiddenWindowDoc = Cc["@mozilla.org/appshell/appShellService;1"].
+                        getService(Ci.nsIAppShellService).
+                        hiddenDOMWindow.document;
+
+const XHTML_NS = "http://www.w3.org/1999/xhtml";
+
+/**
+ * Passes the given uri to findRepresentativeColor.
+ * If expected is null, you expect it to fail.
+ * If expected is a function, it will call that function.
+ * If expected is a color, you expect that color to be returned.
+ * Message is used in the calls to is().
+ */
+function frcTest(uri, expected, message) {
+  return new Promise(resolve => {
+    CA.findRepresentativeColor(Services.io.newURI(uri, "", null),
+      function(success, color) {
+        if (expected == null) {
+          ok(!success, message);
+        } else if (typeof expected == "function") {
+          expected(color, message);
+        } else {
+          ok(success, "success: " + message);
+          is(color, expected, message);
+        }
+        resolve();
+    });
+  });
+}
+
+/**
+ * Handy function for getting an image into findRepresentativeColor and testing it.
+ * Makes a canvas with the given dimensions, calls paintCanvasFunc with the 2d
+ * context of the canvas, sticks the generated canvas into findRepresentativeColor.
+ * See frcTest.
+ */
+function canvasTest(width, height, paintCanvasFunc, expected, message) {
+  let canvas = hiddenWindowDoc.createElementNS(XHTML_NS, "canvas");
+  canvas.width = width;
+  canvas.height = height;
+  paintCanvasFunc(canvas.getContext("2d"));
+  let uri = canvas.toDataURL();
+  return frcTest(uri, expected, message);
+}
+
+// simple test - draw a red box in the center, make sure we get red back
+add_task(function* test_redSquare() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "red";
+    ctx.fillRect(2, 2, 12, 12);
+  }, 0xFF0000, "redSquare analysis returns red");
+});
+
+
+// draw a blue square in one corner, red in the other, such that blue overlaps
+// red by one pixel, making it the dominant color
+add_task(function* test_blueOverlappingRed() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "red";
+    ctx.fillRect(0, 0, 8, 8);
+    ctx.fillStyle = "blue";
+    ctx.fillRect(7, 7, 8, 8);
+  }, 0x0000FF, "blueOverlappingRed analysis returns blue");
+});
+
+// draw a red gradient next to a solid blue rectangle to ensure that a large
+// block of similar colors beats out a smaller block of one color
+add_task(function* test_redGradientBlueSolid() {
+  yield canvasTest(16, 16, function(ctx) {
+    let gradient = ctx.createLinearGradient(0, 0, 1, 15);
+    gradient.addColorStop(0, "#FF0000");
+    gradient.addColorStop(1, "#FF0808");
+
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, 16, 16);
+    ctx.fillStyle = "blue";
+    ctx.fillRect(9, 0, 7, 16);
+  }, function(actual, message) {
+    ok(actual >= 0xFF0000 && actual <= 0xFF0808, message);
+  }, "redGradientBlueSolid analysis returns redish");
+});
+
+// try a transparent image, should fail
+add_task(function* test_transparent() {
+  yield canvasTest(16, 16, function(ctx) {
+    // do nothing!
+  }, null, "transparent analysis fails");
+});
+
+add_task(function* test_invalidURI() {
+  yield frcTest("data:blah,Imnotavaliddatauri", null, "invalid URI analysis fails");
+});
+
+add_task(function* test_malformedPNGURI() {
+  yield frcTest("data:image/png;base64,iVBORblahblahblah", null,
+                "malformed PNG URI analysis fails");
+});
+
+add_task(function* test_unresolvableURI() {
+  yield frcTest("http://www.example.com/blah/idontexist.png", null,
+                "unresolvable URI analysis fails");
+});
+
+// draw a small blue box on a red background to make sure the algorithm avoids
+// using the background color
+add_task(function* test_blueOnRedBackground() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "red";
+    ctx.fillRect(0, 0, 16, 16);
+    ctx.fillStyle = "blue";
+    ctx.fillRect(4, 4, 8, 8);
+  }, 0x0000FF, "blueOnRedBackground analysis returns blue");
+});
+
+// draw a slightly different color in the corners to make sure the corner colors
+// don't have to be exactly equal to be considered the background color
+add_task(function* test_variableBackground() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "white";
+    ctx.fillRect(0, 0, 16, 16);
+    ctx.fillStyle = "#FEFEFE";
+    ctx.fillRect(15, 0, 1, 1);
+    ctx.fillStyle = "#FDFDFD";
+    ctx.fillRect(15, 15, 1, 1);
+    ctx.fillStyle = "#FCFCFC";
+    ctx.fillRect(0, 15, 1, 1);
+    ctx.fillStyle = "black";
+    ctx.fillRect(4, 4, 8, 8);
+  }, 0x000000, "variableBackground analysis returns black");
+});
+
+// like the above test, but make the colors different enough that they aren't
+// considered the background color
+add_task(function* test_tooVariableBackground() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "white";
+    ctx.fillRect(0, 0, 16, 16);
+    ctx.fillStyle = "#EEDDCC";
+    ctx.fillRect(15, 0, 1, 1);
+    ctx.fillStyle = "#DDDDDD";
+    ctx.fillRect(15, 15, 1, 1);
+    ctx.fillStyle = "#CCCCCC";
+    ctx.fillRect(0, 15, 1, 1);
+    ctx.fillStyle = "black";
+    ctx.fillRect(4, 4, 8, 8);
+  }, function(actual, message) {
+    isnot(actual, 0x000000, message);
+  }, "tooVariableBackground analysis doesn't return black");
+});
+
+// draw a small black/white box over transparent background to make sure the
+// algorithm doesn't think rgb(0,0,0) == rgba(0,0,0,0)
+add_task(function* test_transparentBackgroundConflation() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "black";
+    ctx.fillRect(2, 2, 12, 12);
+    ctx.fillStyle = "white";
+    ctx.fillRect(5, 5, 6, 6);
+  }, 0x000000, "transparentBackgroundConflation analysis returns black");
+});
+
+
+// make sure we fall back to the background color if we have no other choice
+// (instead of failing as if there were no colors)
+add_task(function* test_backgroundFallback() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "black";
+    ctx.fillRect(0, 0, 16, 16);
+  }, 0x000000, "backgroundFallback analysis returns black");
+});
+
+// draw red rectangle next to a pink one to make sure the algorithm picks the
+// more interesting color
+add_task(function* test_interestingColorPreference() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "#FFDDDD";
+    ctx.fillRect(0, 0, 16, 16);
+    ctx.fillStyle = "red";
+    ctx.fillRect(0, 0, 3, 16);
+  }, 0xFF0000, "interestingColorPreference analysis returns red");
+});
+
+// draw high saturation but dark red next to slightly less saturated color but
+// much lighter, to make sure the algorithm doesn't pick colors that are
+// nearly black just because of high saturation (in HSL terms)
+add_task(function* test_saturationDependence() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "hsl(0, 100%, 5%)";
+    ctx.fillRect(0, 0, 16, 16);
+    ctx.fillStyle = "hsl(0, 90%, 35%)";
+    ctx.fillRect(0, 0, 8, 16);
+  }, 0xA90808, "saturationDependence analysis returns lighter red");
+});
+
+// make sure the preference for interesting colors won't stupidly pick 1 pixel
+// of red over 169 black pixels
+add_task(function* test_interestingColorPreferenceLenient() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "black";
+    ctx.fillRect(1, 1, 13, 13);
+    ctx.fillStyle = "red";
+    ctx.fillRect(3, 3, 1, 1);
+  }, 0x000000, "interestingColorPreferenceLenient analysis returns black");
+});
+
+// ...but 6 pixels of red is more reasonable
+add_task(function* test_interestingColorPreferenceNotTooLenient() {
+  yield canvasTest(16, 16, function(ctx) {
+    ctx.fillStyle = "black";
+    ctx.fillRect(1, 1, 13, 13);
+    ctx.fillStyle = "red";
+    ctx.fillRect(3, 3, 3, 2);
+  }, 0xFF0000, "interestingColorPreferenceNotTooLenient analysis returns red");
+});
+
+var maxPixels = 144; // see ColorAnalyzer MAXIMUM_PIXELS const
+
+// make sure that images larger than maxPixels*maxPixels fail
+add_task(function* test_imageTooLarge() {
+  yield canvasTest(1+maxPixels, 1+maxPixels, function(ctx) {
+    ctx.fillStyle = "red";
+    ctx.fillRect(0, 0, 1+maxPixels, 1+maxPixels);
+  }, null, "imageTooLarge analysis fails");
+});
+
+// the rest of the tests are for coverage of "real" favicons
+// exact color isn't terribly important, just make sure it's reasonable
+const filePrefix = getRootDirectory(gTestPath) + "colorAnalyzer/";
+
+add_task(function* test_categoryDiscover() {
+  yield frcTest(filePrefix + "category-discover.png", 0xB28D3A,
+                "category-discover analysis returns red");
+});
+
+add_task(function* test_localeGeneric() {
+  yield frcTest(filePrefix + "localeGeneric.png", 0x3EC23E,
+                "localeGeneric analysis returns green");
+});
+
+add_task(function* test_dictionaryGeneric() {
+  yield frcTest(filePrefix + "dictionaryGeneric-16.png", 0x854C30,
+                "dictionaryGeneric-16 analysis returns brown");
+});
+
+add_task(function* test_extensionGeneric() {
+  yield frcTest(filePrefix + "extensionGeneric-16.png", 0x53BA3F,
+                "extensionGeneric-16 analysis returns green");
+});
diff --git a/toolkit/components/places/tests/browser/browser_double_redirect.js b/toolkit/components/places/tests/browser/browser_double_redirect.js
new file mode 100644
index 000000000..1e5dc9c16
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_double_redirect.js
@@ -0,0 +1,63 @@
+// Test for bug 411966.
+// When a page redirects multiple times, from_visit should point to the
+// previous visit in the chain, not to the first visit in the chain.
+
+add_task(function* () {
+  yield PlacesTestUtils.clearHistory();
+
+  const BASE_URL = "http://example.com/tests/toolkit/components/places/tests/browser/";
+  const TEST_URI = NetUtil.newURI(BASE_URL + "begin.html");
+  const FIRST_REDIRECTING_URI = NetUtil.newURI(BASE_URL + "redirect_twice.sjs");
+  const FINAL_URI = NetUtil.newURI(BASE_URL + "final.html");
+
+  let promiseVisits = new Promise(resolve => {
+    PlacesUtils.history.addObserver({
+      __proto__: NavHistoryObserver.prototype,
+      _notified: [],
+      onVisit: function (uri, id, time, sessionId, referrerId, transition) {
+        info("Received onVisit: " + uri.spec);
+        this._notified.push(uri);
+
+        if (!uri.equals(FINAL_URI)) {
+          return;
+        }
+
+        is(this._notified.length, 4);
+        PlacesUtils.history.removeObserver(this);
+
+        Task.spawn(function* () {
+          // Get all pages visited from the original typed one
+          let db = yield PlacesUtils.promiseDBConnection();
+          let rows = yield db.execute(
+            `SELECT url FROM moz_historyvisits
+             JOIN moz_places h ON h.id = place_id
+             WHERE from_visit IN
+                (SELECT v.id FROM moz_historyvisits v
+                 JOIN moz_places p ON p.id = v.place_id
+                 WHERE p.url_hash = hash(:url) AND p.url = :url)
+            `, { url: TEST_URI.spec });
+
+          is(rows.length, 1, "Found right number of visits");
+          let visitedUrl = rows[0].getResultByName("url");
+          // Check that redirect from_visit is not from the original typed one
+          is(visitedUrl, FIRST_REDIRECTING_URI.spec, "Check referrer for " + visitedUrl);
+
+          resolve();
+        });
+      }
+    }, false);
+  });
+
+  PlacesUtils.history.markPageAsTyped(TEST_URI);
+  yield BrowserTestUtils.withNewTab({
+    gBrowser,
+    url: TEST_URI.spec,
+  }, function* (browser) {
+    // Load begin page, click link on page to record visits.
+    yield BrowserTestUtils.synthesizeMouseAtCenter("#clickme", {}, browser);
+
+    yield promiseVisits;
+  });
+
+  yield PlacesTestUtils.clearHistory();
+});
diff --git a/toolkit/components/places/tests/browser/browser_favicon_privatebrowsing_perwindowpb.js b/toolkit/components/places/tests/browser/browser_favicon_privatebrowsing_perwindowpb.js
new file mode 100644
index 000000000..51d82adc6
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_favicon_privatebrowsing_perwindowpb.js
@@ -0,0 +1,43 @@
+/* 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/. */
+
+function test() {
+  waitForExplicitFinish();
+
+  const pageURI =
+   "http://example.org/tests/toolkit/components/places/tests/browser/favicon.html";
+  let windowsToClose = [];
+
+  registerCleanupFunction(function() {
+    windowsToClose.forEach(function(aWin) {
+      aWin.close();
+    });
+  });
+
+  function testOnWindow(aIsPrivate, aCallback) {
+    whenNewWindowLoaded({private: aIsPrivate}, function(aWin) {
+      windowsToClose.push(aWin);
+      executeSoon(() => aCallback(aWin));
+    });
+  }
+
+  function waitForTabLoad(aWin, aCallback) {
+    aWin.gBrowser.selectedBrowser.addEventListener("load", function onLoad() {
+      aWin.gBrowser.selectedBrowser.removeEventListener("load", onLoad, true);
+      aCallback();
+    }, true);
+    aWin.gBrowser.selectedBrowser.loadURI(pageURI);
+  }
+
+  testOnWindow(true, function(win) {
+    waitForTabLoad(win, function() {
+      PlacesUtils.favicons.getFaviconURLForPage(NetUtil.newURI(pageURI),
+        function(uri, dataLen, data, mimeType) {
+          is(uri, null, "No result should be found");
+          finish();
+        }
+      );
+    });
+  });
+}
diff --git a/toolkit/components/places/tests/browser/browser_favicon_setAndFetchFaviconForPage.js b/toolkit/components/places/tests/browser/browser_favicon_setAndFetchFaviconForPage.js
new file mode 100644
index 000000000..60df8ebd7
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_favicon_setAndFetchFaviconForPage.js
@@ -0,0 +1,152 @@
+/* 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 file tests the normal operation of setAndFetchFaviconForPage.
+function test() {
+  // Initialization
+  waitForExplicitFinish();
+  let windowsToClose = [];
+  let favIconLocation =
+    "http://example.org/tests/toolkit/components/places/tests/browser/favicon-normal32.png";
+  let favIconURI = NetUtil.newURI(favIconLocation);
+  let favIconMimeType= "image/png";
+  let pageURI;
+  let favIconData;
+
+  function testOnWindow(aOptions, aCallback) {
+    whenNewWindowLoaded(aOptions, function(aWin) {
+      windowsToClose.push(aWin);
+      executeSoon(() => aCallback(aWin));
+    });
+  }
+
+  // This function is called after calling finish() on the test.
+  registerCleanupFunction(function() {
+    windowsToClose.forEach(function(aWin) {
+      aWin.close();
+    });
+  });
+
+  function getIconFile(aCallback) {
+    NetUtil.asyncFetch({
+      uri: favIconLocation,
+      loadUsingSystemPrincipal: true,
+      contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE_FAVICON
+    }, function(inputStream, status) {
+        if (!Components.isSuccessCode(status)) {
+          ok(false, "Could not get the icon file");
+          // Handle error.
+          return;
+        }
+
+        // Check the returned size versus the expected size.
+        let size = inputStream.available();
+        favIconData = NetUtil.readInputStreamToString(inputStream, size);
+        is(size, favIconData.length, "Check correct icon size");
+        // Check that the favicon loaded correctly before starting the actual tests.
+        is(favIconData.length, 344, "Check correct icon length (344)");
+
+        if (aCallback) {
+          aCallback();
+        } else {
+          finish();
+        }
+      });
+  }
+
+  function testNormal(aWindow, aCallback) {
+    pageURI = NetUtil.newURI("http://example.com/normal");
+    waitForFaviconChanged(pageURI, favIconURI, aWindow,
+      function testNormalCallback() {
+        checkFaviconDataForPage(pageURI, favIconMimeType, favIconData, aWindow,
+          aCallback);
+      }
+    );
+
+    addVisits({uri: pageURI, transition: TRANSITION_TYPED}, aWindow,
+      function () {
+        aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI, favIconURI,
+          true, aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, null,
+          Services.scriptSecurityManager.getSystemPrincipal());
+      }
+    );
+  }
+
+  function testAboutURIBookmarked(aWindow, aCallback) {
+    pageURI = NetUtil.newURI("about:testAboutURI_bookmarked");
+    waitForFaviconChanged(pageURI, favIconURI, aWindow,
+      function testAboutURIBookmarkedCallback() {
+        checkFaviconDataForPage(pageURI, favIconMimeType, favIconData, aWindow,
+          aCallback);
+      }
+    );
+
+    aWindow.PlacesUtils.bookmarks.insertBookmark(
+      aWindow.PlacesUtils.unfiledBookmarksFolderId, pageURI,
+      aWindow.PlacesUtils.bookmarks.DEFAULT_INDEX, pageURI.spec);
+    aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI, favIconURI,
+      true, aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, null,
+      Services.scriptSecurityManager.getSystemPrincipal());
+  }
+
+  function testPrivateBrowsingBookmarked(aWindow, aCallback) {
+    pageURI = NetUtil.newURI("http://example.com/privateBrowsing_bookmarked");
+    waitForFaviconChanged(pageURI, favIconURI, aWindow,
+      function testPrivateBrowsingBookmarkedCallback() {
+        checkFaviconDataForPage(pageURI, favIconMimeType, favIconData, aWindow,
+          aCallback);
+      }
+    );
+
+    aWindow.PlacesUtils.bookmarks.insertBookmark(
+      aWindow.PlacesUtils.unfiledBookmarksFolderId, pageURI,
+      aWindow.PlacesUtils.bookmarks.DEFAULT_INDEX, pageURI.spec);
+    aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI, favIconURI,
+      true, aWindow.PlacesUtils.favicons.FAVICON_LOAD_PRIVATE, null,
+      Services.scriptSecurityManager.getSystemPrincipal());
+  }
+
+  function testDisabledHistoryBookmarked(aWindow, aCallback) {
+    pageURI = NetUtil.newURI("http://example.com/disabledHistory_bookmarked");
+    waitForFaviconChanged(pageURI, favIconURI, aWindow,
+      function testDisabledHistoryBookmarkedCallback() {
+        checkFaviconDataForPage(pageURI, favIconMimeType, favIconData, aWindow,
+          aCallback);
+      }
+    );
+
+    // Disable history while changing the favicon.
+    aWindow.Services.prefs.setBoolPref("places.history.enabled", false);
+
+    aWindow.PlacesUtils.bookmarks.insertBookmark(
+      aWindow.PlacesUtils.unfiledBookmarksFolderId, pageURI,
+      aWindow.PlacesUtils.bookmarks.DEFAULT_INDEX, pageURI.spec);
+    aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI, favIconURI,
+      true, aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, null,
+      Services.scriptSecurityManager.getSystemPrincipal());
+
+    // The setAndFetchFaviconForPage function calls CanAddURI synchronously, thus
+    // we can set the preference back to true immediately.  We don't clear the
+    // preference because not all products enable Places by default.
+    aWindow.Services.prefs.setBoolPref("places.history.enabled", true);
+  }
+
+  getIconFile(function () {
+    testOnWindow({}, function(aWin) {
+      testNormal(aWin, function () {
+        testOnWindow({}, function(aWin2) {
+          testAboutURIBookmarked(aWin2, function () {
+            testOnWindow({private: true}, function(aWin3) {
+              testPrivateBrowsingBookmarked(aWin3, function () {
+                testOnWindow({}, function(aWin4) {
+                  testDisabledHistoryBookmarked(aWin4, finish);
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+}
diff --git a/toolkit/components/places/tests/browser/browser_favicon_setAndFetchFaviconForPage_failures.js b/toolkit/components/places/tests/browser/browser_favicon_setAndFetchFaviconForPage_failures.js
new file mode 100644
index 000000000..bd73af441
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_favicon_setAndFetchFaviconForPage_failures.js
@@ -0,0 +1,261 @@
+/* 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 file tests setAndFetchFaviconForPage when it is called with invalid
+ * arguments, and when no favicon is stored for the given arguments.
+ */
+function test() {
+  // Initialization
+  waitForExplicitFinish();
+  let windowsToClose = [];
+  let favIcon16Location =
+    "http://example.org/tests/toolkit/components/places/tests/browser/favicon-normal16.png";
+  let favIcon32Location =
+    "http://example.org/tests/toolkit/components/places/tests/browser/favicon-normal32.png";
+  let favIcon16URI = NetUtil.newURI(favIcon16Location);
+  let favIcon32URI = NetUtil.newURI(favIcon32Location);
+  let lastPageURI = NetUtil.newURI("http://example.com/verification");
+  // This error icon must stay in sync with FAVICON_ERRORPAGE_URL in
+  // nsIFaviconService.idl, aboutCertError.xhtml and netError.xhtml.
+  let favIconErrorPageURI =
+    NetUtil.newURI("chrome://global/skin/icons/warning-16.png");
+  let favIconsResultCount = 0;
+
+  function testOnWindow(aOptions, aCallback) {
+    whenNewWindowLoaded(aOptions, function(aWin) {
+      windowsToClose.push(aWin);
+      executeSoon(() => aCallback(aWin));
+    });
+  }
+
+  // This function is called after calling finish() on the test.
+  registerCleanupFunction(function() {
+    windowsToClose.forEach(function(aWin) {
+      aWin.close();
+    });
+  });
+
+  function checkFavIconsDBCount(aCallback) {
+    let stmt = DBConn().createAsyncStatement("SELECT url FROM moz_favicons");
+    stmt.executeAsync({
+      handleResult: function final_handleResult(aResultSet) {
+        while (aResultSet.getNextRow()) {
+          favIconsResultCount++;
+        }
+      },
+      handleError: function final_handleError(aError) {
+        throw ("Unexpected error (" + aError.result + "): " + aError.message);
+      },
+      handleCompletion: function final_handleCompletion(aReason) {
+        // begin testing
+        info("Previous records in moz_favicons: " + favIconsResultCount);
+        if (aCallback) {
+          aCallback();
+        }
+      }
+    });
+    stmt.finalize();
+  }
+
+  function testNullPageURI(aWindow, aCallback) {
+    try {
+      aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(null, favIcon16URI,
+        true, aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, null,
+        Services.scriptSecurityManager.getSystemPrincipal());
+      throw ("Exception expected because aPageURI is null.");
+    } catch (ex) {
+      // We expected an exception.
+      ok(true, "Exception expected because aPageURI is null");
+    }
+
+    if (aCallback) {
+      aCallback();
+    }
+  }
+
+  function testNullFavIconURI(aWindow, aCallback) {
+    try {
+      aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(
+        NetUtil.newURI("http://example.com/null_faviconURI"), null,
+        true, aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+        null, Services.scriptSecurityManager.getSystemPrincipal());
+      throw ("Exception expected because aFaviconURI is null.");
+    } catch (ex) {
+      // We expected an exception.
+      ok(true, "Exception expected because aFaviconURI is null.");
+    }
+
+    if (aCallback) {
+      aCallback();
+    }
+  }
+
+  function testAboutURI(aWindow, aCallback) {
+    aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(
+      NetUtil.newURI("about:testAboutURI"), favIcon16URI,
+      true, aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+      null, Services.scriptSecurityManager.getSystemPrincipal());
+
+    if (aCallback) {
+      aCallback();
+    }
+  }
+
+  function testPrivateBrowsingNonBookmarkedURI(aWindow, aCallback) {
+    let pageURI = NetUtil.newURI("http://example.com/privateBrowsing");
+    addVisits({ uri: pageURI, transitionType: TRANSITION_TYPED }, aWindow,
+      function () {
+        aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI,
+          favIcon16URI, true,
+          aWindow.PlacesUtils.favicons.FAVICON_LOAD_PRIVATE, null,
+          Services.scriptSecurityManager.getSystemPrincipal());
+
+        if (aCallback) {
+          aCallback();
+        }
+    });
+  }
+
+  function testDisabledHistory(aWindow, aCallback) {
+    let pageURI = NetUtil.newURI("http://example.com/disabledHistory");
+    addVisits({ uri: pageURI, transition: TRANSITION_TYPED }, aWindow,
+      function () {
+        aWindow.Services.prefs.setBoolPref("places.history.enabled", false);
+
+        aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI,
+          favIcon16URI, true,
+          aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, null,
+          Services.scriptSecurityManager.getSystemPrincipal());
+
+        // The setAndFetchFaviconForPage function calls CanAddURI synchronously, thus
+        // we can set the preference back to true immediately . We don't clear the
+        // preference because not all products enable Places by default.
+        aWindow.Services.prefs.setBoolPref("places.history.enabled", true);
+
+        if (aCallback) {
+          aCallback();
+        }
+    });
+  }
+
+  function testErrorIcon(aWindow, aCallback) {
+    let pageURI = NetUtil.newURI("http://example.com/errorIcon");
+    addVisits({ uri: pageURI, transition: TRANSITION_TYPED }, aWindow,
+      function () {
+        aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI,
+          favIconErrorPageURI, true,
+          aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, null,
+          Services.scriptSecurityManager.getSystemPrincipal());
+
+      if (aCallback) {
+        aCallback();
+      }
+    });
+  }
+
+  function testNonExistingPage(aWindow, aCallback) {
+    aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(
+      NetUtil.newURI("http://example.com/nonexistingPage"), favIcon16URI,
+      true, aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, null,
+      Services.scriptSecurityManager.getSystemPrincipal());
+
+    if (aCallback) {
+      aCallback();
+    }
+  }
+
+  function testFinalVerification(aWindow, aCallback) {
+    // Only the last test should raise the onPageChanged notification,
+    // executing the waitForFaviconChanged callback.
+    waitForFaviconChanged(lastPageURI, favIcon32URI, aWindow,
+      function final_callback() {
+        // Check that only one record corresponding to the last favicon is present.
+        let resultCount = 0;
+        let stmt = DBConn().createAsyncStatement("SELECT url FROM moz_favicons");
+        stmt.executeAsync({
+          handleResult: function final_handleResult(aResultSet) {
+
+            // If the moz_favicons DB had been previously loaded (before our
+            // test began), we should focus only in the URI we are testing and
+            // skip the URIs not related to our test.
+            if (favIconsResultCount > 0) {
+              for (let row; (row = aResultSet.getNextRow()); ) {
+                if (favIcon32URI.spec === row.getResultByIndex(0)) {
+                  is(favIcon32URI.spec, row.getResultByIndex(0),
+                    "Check equal favicons");
+                  resultCount++;
+                }
+              }
+            } else {
+              for (let row; (row = aResultSet.getNextRow()); ) {
+                is(favIcon32URI.spec, row.getResultByIndex(0),
+                  "Check equal favicons");
+                resultCount++;
+              }
+            }
+          },
+          handleError: function final_handleError(aError) {
+            throw ("Unexpected error (" + aError.result + "): " + aError.message);
+          },
+          handleCompletion: function final_handleCompletion(aReason) {
+            is(Ci.mozIStorageStatementCallback.REASON_FINISHED, aReason,
+              "Check reasons are equal");
+            is(1, resultCount, "Check result count");
+            if (aCallback) {
+              aCallback();
+            }
+          }
+        });
+        stmt.finalize();
+    });
+
+    // This is the only test that should cause the waitForFaviconChanged
+    // callback to be invoked.  In turn, the callback will invoke
+    // finish() causing the tests to finish.
+    addVisits({ uri: lastPageURI, transition: TRANSITION_TYPED }, aWindow,
+      function () {
+        aWindow.PlacesUtils.favicons.setAndFetchFaviconForPage(lastPageURI,
+          favIcon32URI, true,
+          aWindow.PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, null,
+          Services.scriptSecurityManager.getSystemPrincipal());
+    });
+  }
+
+  checkFavIconsDBCount(function () {
+    testOnWindow({}, function(aWin) {
+      testNullPageURI(aWin, function () {
+        testOnWindow({}, function(aWin2) {
+          testNullFavIconURI(aWin2, function() {
+            testOnWindow({}, function(aWin3) {
+              testAboutURI(aWin3, function() {
+                testOnWindow({private: true}, function(aWin4) {
+                  testPrivateBrowsingNonBookmarkedURI(aWin4, function () {
+                    testOnWindow({}, function(aWin5) {
+                      testDisabledHistory(aWin5, function () {
+                        testOnWindow({}, function(aWin6) {
+                          testErrorIcon(aWin6, function() {
+                            testOnWindow({}, function(aWin7) {
+                              testNonExistingPage(aWin7, function() {
+                                testOnWindow({}, function(aWin8) {
+                                  testFinalVerification(aWin8, function() {
+                                    finish();
+                                  });
+                                });
+                              });
+                            });
+                          });
+                        });
+                      });
+                    });
+                  });
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+}
diff --git a/toolkit/components/places/tests/browser/browser_history_post.js b/toolkit/components/places/tests/browser/browser_history_post.js
new file mode 100644
index 000000000..c85e720f8
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_history_post.js
@@ -0,0 +1,23 @@
+const PAGE_URI = "http://example.com/tests/toolkit/components/places/tests/browser/history_post.html";
+const SJS_URI = NetUtil.newURI("http://example.com/tests/toolkit/components/places/tests/browser/history_post.sjs");
+
+add_task(function* () {
+  yield BrowserTestUtils.withNewTab({gBrowser, url: PAGE_URI}, Task.async(function* (aBrowser) {
+    yield ContentTask.spawn(aBrowser, null, function* () {
+      let doc = content.document;
+      let submit = doc.getElementById("submit");
+      let iframe = doc.getElementById("post_iframe");
+      let p = new Promise((resolve, reject) => {
+        iframe.addEventListener("load", function onLoad() {
+          iframe.removeEventListener("load", onLoad);
+          resolve();
+        });
+      });
+      submit.click();
+      yield p;
+    });
+    let visited = yield promiseIsURIVisited(SJS_URI);
+    ok(!visited, "The POST page should not be added to history");
+    ok(!(yield PlacesTestUtils.isPageInDB(SJS_URI.spec)), "The page should not be in the database");
+  }));
+});
diff --git a/toolkit/components/places/tests/browser/browser_notfound.js b/toolkit/components/places/tests/browser/browser_notfound.js
new file mode 100644
index 000000000..20467eef4
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_notfound.js
@@ -0,0 +1,46 @@
+/* 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/. */
+
+add_task(function* () {
+  const TEST_URL = "http://mochi.test:8888/notFoundPage.html";
+
+  // Used to verify errors are not marked as typed.
+  PlacesUtils.history.markPageAsTyped(NetUtil.newURI(TEST_URL));
+
+  // Create and add history observer.
+  let visitedPromise = new Promise(resolve => {
+    let historyObserver = {
+      onVisit: function (aURI, aVisitID, aTime, aSessionID, aReferringID,
+                        aTransitionType) {
+        PlacesUtils.history.removeObserver(historyObserver);
+        info("Received onVisit: " + aURI.spec);
+        fieldForUrl(aURI, "frecency", function (aFrecency) {
+          is(aFrecency, 0, "Frecency should be 0");
+          fieldForUrl(aURI, "hidden", function (aHidden) {
+            is(aHidden, 0, "Page should not be hidden");
+            fieldForUrl(aURI, "typed", function (aTyped) {
+              is(aTyped, 0, "page should not be marked as typed");
+              resolve();
+            });
+          });
+        });
+      },
+      onBeginUpdateBatch: function () {},
+      onEndUpdateBatch: function () {},
+      onTitleChanged: function () {},
+      onDeleteURI: function () {},
+      onClearHistory: function () {},
+      onPageChanged: function () {},
+      onDeleteVisits: function () {},
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver])
+    };
+    PlacesUtils.history.addObserver(historyObserver, false);
+  });
+
+  let newTabPromise = BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_URL);
+  yield Promise.all([visitedPromise, newTabPromise]);
+
+  yield PlacesTestUtils.clearHistory();
+  gBrowser.removeCurrentTab();
+});
diff --git a/toolkit/components/places/tests/browser/browser_redirect.js b/toolkit/components/places/tests/browser/browser_redirect.js
new file mode 100644
index 000000000..d8a19731a
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_redirect.js
@@ -0,0 +1,61 @@
+/* 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/. */
+
+add_task(function* () {
+  const REDIRECT_URI = NetUtil.newURI("http://mochi.test:8888/tests/toolkit/components/places/tests/browser/redirect.sjs");
+  const TARGET_URI = NetUtil.newURI("http://mochi.test:8888/tests/toolkit/components/places/tests/browser/redirect-target.html");
+
+  // Create and add history observer.
+  let visitedPromise = new Promise(resolve => {
+    let historyObserver = {
+      _redirectNotified: false,
+      onVisit: function (aURI, aVisitID, aTime, aSessionID, aReferringID,
+                        aTransitionType) {
+        info("Received onVisit: " + aURI.spec);
+
+        if (aURI.equals(REDIRECT_URI)) {
+          this._redirectNotified = true;
+          // Wait for the target page notification.
+          return;
+        }
+
+        PlacesUtils.history.removeObserver(historyObserver);
+
+        ok(this._redirectNotified, "The redirect should have been notified");
+
+        fieldForUrl(REDIRECT_URI, "frecency", function (aFrecency) {
+          ok(aFrecency != 0, "Frecency or the redirecting page should not be 0");
+
+          fieldForUrl(REDIRECT_URI, "hidden", function (aHidden) {
+            is(aHidden, 1, "The redirecting page should be hidden");
+
+            fieldForUrl(TARGET_URI, "frecency", function (aFrecency2) {
+              ok(aFrecency2 != 0, "Frecency of the target page should not be 0");
+
+              fieldForUrl(TARGET_URI, "hidden", function (aHidden2) {
+                is(aHidden2, 0, "The target page should not be hidden");
+                resolve();
+              });
+            });
+          });
+        });
+      },
+      onBeginUpdateBatch: function () {},
+      onEndUpdateBatch: function () {},
+      onTitleChanged: function () {},
+      onDeleteURI: function () {},
+      onClearHistory: function () {},
+      onPageChanged: function () {},
+      onDeleteVisits: function () {},
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver])
+    };
+    PlacesUtils.history.addObserver(historyObserver, false);
+  });
+
+  let newTabPromise = BrowserTestUtils.openNewForegroundTab(gBrowser, REDIRECT_URI.spec);
+  yield Promise.all([visitedPromise, newTabPromise]);
+
+  yield PlacesTestUtils.clearHistory();
+  gBrowser.removeCurrentTab();
+});
diff --git a/toolkit/components/places/tests/browser/browser_settitle.js b/toolkit/components/places/tests/browser/browser_settitle.js
new file mode 100644
index 000000000..68c8deda7
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_settitle.js
@@ -0,0 +1,76 @@
+var conn = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase).DBConnection;
+
+/**
+ * Gets a single column value from either the places or historyvisits table.
+ */
+function getColumn(table, column, url)
+{
+  var stmt = conn.createStatement(
+    `SELECT ${column} FROM ${table} WHERE url_hash = hash(:val) AND url = :val`);
+  try {
+    stmt.params.val = url;
+    stmt.executeStep();
+    return stmt.row[column];
+  }
+  finally {
+    stmt.finalize();
+  }
+}
+
+add_task(function* ()
+{
+  // Make sure titles are correctly saved for a URI with the proper
+  // notifications.
+
+  // Create and add history observer.
+  let titleChangedPromise = new Promise(resolve => {
+    var historyObserver = {
+      data: [],
+      onBeginUpdateBatch: function() {},
+      onEndUpdateBatch: function() {},
+      onVisit: function(aURI, aVisitID, aTime, aSessionID, aReferringID,
+                        aTransitionType) {
+      },
+      onTitleChanged: function(aURI, aPageTitle, aGUID) {
+        this.data.push({ uri: aURI, title: aPageTitle, guid: aGUID });
+
+        // We only expect one title change.
+        //
+        // Although we are loading two different pages, the first page does not
+        // have a title.  Since the title starts out as empty and then is set
+        // to empty, there is no title change notification.
+
+        PlacesUtils.history.removeObserver(this);
+        resolve(this.data);
+      },
+      onDeleteURI: function() {},
+      onClearHistory: function() {},
+      onPageChanged: function() {},
+      onDeleteVisits: function() {},
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver])
+    };
+    PlacesUtils.history.addObserver(historyObserver, false);
+  });
+
+  const url1 = "http://example.com/tests/toolkit/components/places/tests/browser/title1.html";
+  yield BrowserTestUtils.openNewForegroundTab(gBrowser, url1);
+
+  const url2 = "http://example.com/tests/toolkit/components/places/tests/browser/title2.html";
+  let loadPromise = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
+  BrowserTestUtils.loadURI(gBrowser.selectedBrowser, url2);
+  yield loadPromise;
+
+  let data = yield titleChangedPromise;
+  is(data[0].uri.spec, "http://example.com/tests/toolkit/components/places/tests/browser/title2.html");
+  is(data[0].title, "Some title");
+  is(data[0].guid, getColumn("moz_places", "guid", data[0].uri.spec));
+
+  data.forEach(function(item) {
+    var title = getColumn("moz_places", "title", data[0].uri.spec);
+    is(title, item.title);
+  });
+
+  gBrowser.removeCurrentTab();
+  yield PlacesTestUtils.clearHistory();
+});
+
diff --git a/toolkit/components/places/tests/browser/browser_visited_notfound.js b/toolkit/components/places/tests/browser/browser_visited_notfound.js
new file mode 100644
index 000000000..b2b4f25b8
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_visited_notfound.js
@@ -0,0 +1,51 @@
+/* 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/. */
+
+const TEST_URI = NetUtil.newURI("http://mochi.test:8888/notFoundPage.html");
+
+function test() {
+  waitForExplicitFinish();
+
+  gBrowser.selectedTab = gBrowser.addTab();
+  registerCleanupFunction(function() {
+    gBrowser.removeCurrentTab();
+  });
+
+  // First add a visit to the page, this will ensure that later we skip
+  // updating the frecency for a newly not-found page.
+  addVisits({ uri: TEST_URI }, window, () => {
+    info("Added visit");
+    fieldForUrl(TEST_URI, "frecency", aFrecency => {
+      ok(aFrecency > 0, "Frecency should be > 0");
+      continueTest(aFrecency);
+    });
+  });
+}
+
+function continueTest(aOldFrecency) {
+  // Used to verify errors are not marked as typed.
+  PlacesUtils.history.markPageAsTyped(TEST_URI);
+  gBrowser.selectedBrowser.loadURI(TEST_URI.spec);
+
+  // Create and add history observer.
+  let historyObserver = {
+    __proto__: NavHistoryObserver.prototype,
+    onVisit: function (aURI, aVisitID, aTime, aSessionID, aReferringID,
+                      aTransitionType) {
+      PlacesUtils.history.removeObserver(historyObserver);
+      info("Received onVisit: " + aURI.spec);
+      fieldForUrl(aURI, "frecency", function (aFrecency) {
+        is(aFrecency, aOldFrecency, "Frecency should be unchanged");
+        fieldForUrl(aURI, "hidden", function (aHidden) {
+          is(aHidden, 0, "Page should not be hidden");
+          fieldForUrl(aURI, "typed", function (aTyped) {
+            is(aTyped, 0, "page should not be marked as typed");
+            PlacesTestUtils.clearHistory().then(finish);
+          });
+        });
+      });
+    }
+  };
+  PlacesUtils.history.addObserver(historyObserver, false);
+}
diff --git a/toolkit/components/places/tests/browser/browser_visituri.js b/toolkit/components/places/tests/browser/browser_visituri.js
new file mode 100644
index 000000000..8ba2b7272
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_visituri.js
@@ -0,0 +1,84 @@
+/**
+ * One-time observer callback.
+ */
+function promiseObserve(name, checkFn) {
+  return new Promise(resolve => {
+    Services.obs.addObserver(function observer(subject) {
+      if (checkFn(subject)) {
+        Services.obs.removeObserver(observer, name);
+        resolve();
+      }
+    }, name, false);
+  });
+}
+
+var conn = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase).DBConnection;
+
+/**
+ * Gets a single column value from either the places or historyvisits table.
+ */
+function getColumn(table, column, fromColumnName, fromColumnValue) {
+  let sql = `SELECT ${column}
+             FROM ${table}
+             WHERE ${fromColumnName} = :val
+             ${fromColumnName == "url" ? "AND url_hash = hash(:val)" : ""}
+             LIMIT 1`;
+  let stmt = conn.createStatement(sql);
+  try {
+    stmt.params.val = fromColumnValue;
+    ok(stmt.executeStep(), "Expect to get a row");
+    return stmt.row[column];
+  }
+  finally {
+    stmt.reset();
+  }
+}
+
+add_task(function* () {
+  // Make sure places visit chains are saved correctly with a redirect
+  // transitions.
+
+  // Part 1: observe history events that fire when a visit occurs.
+  // Make sure visits appear in order, and that the visit chain is correct.
+  var expectedUrls = [
+    "http://example.com/tests/toolkit/components/places/tests/browser/begin.html",
+    "http://example.com/tests/toolkit/components/places/tests/browser/redirect_twice.sjs",
+    "http://example.com/tests/toolkit/components/places/tests/browser/redirect_once.sjs",
+    "http://example.com/tests/toolkit/components/places/tests/browser/final.html"
+  ];
+  var currentIndex = 0;
+
+  function checkObserver(subject) {
+    var uri = subject.QueryInterface(Ci.nsIURI);
+    var expected = expectedUrls[currentIndex];
+    is(uri.spec, expected, "Saved URL visit " + uri.spec);
+
+    var placeId = getColumn("moz_places", "id", "url", uri.spec);
+    var fromVisitId = getColumn("moz_historyvisits", "from_visit", "place_id", placeId);
+
+    if (currentIndex == 0) {
+      is(fromVisitId, 0, "First visit has no from visit");
+    }
+    else {
+      var lastVisitId = getColumn("moz_historyvisits", "place_id", "id", fromVisitId);
+      var fromVisitUrl = getColumn("moz_places", "url", "id", lastVisitId);
+      is(fromVisitUrl, expectedUrls[currentIndex - 1],
+         "From visit was " + expectedUrls[currentIndex - 1]);
+    }
+
+    currentIndex++;
+    return (currentIndex >= expectedUrls.length);
+  }
+  let visitUriPromise = promiseObserve("uri-visit-saved", checkObserver);
+
+  const testUrl = "http://example.com/tests/toolkit/components/places/tests/browser/begin.html";
+  yield BrowserTestUtils.openNewForegroundTab(gBrowser, testUrl);
+
+  // Load begin page, click link on page to record visits.
+  yield BrowserTestUtils.synthesizeMouseAtCenter("#clickme", { }, gBrowser.selectedBrowser);
+  yield visitUriPromise;
+
+  yield PlacesTestUtils.clearHistory();
+
+  gBrowser.removeCurrentTab();
+});
diff --git a/toolkit/components/places/tests/browser/browser_visituri_nohistory.js b/toolkit/components/places/tests/browser/browser_visituri_nohistory.js
new file mode 100644
index 000000000..a3a8e7626
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_visituri_nohistory.js
@@ -0,0 +1,42 @@
+/**
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+const INITIAL_URL = "http://example.com/tests/toolkit/components/places/tests/browser/begin.html";
+const FINAL_URL = "http://example.com/tests/toolkit/components/places/tests/browser/final.html";
+
+/**
+ * One-time observer callback.
+ */
+function promiseObserve(name)
+{
+  return new Promise(resolve => {
+    Services.obs.addObserver(function observer(subject) {
+      Services.obs.removeObserver(observer, name);
+      resolve(subject);
+    }, name, false);
+  });
+}
+
+add_task(function* ()
+{
+  yield new Promise(resolve => SpecialPowers.pushPrefEnv({"set": [["places.history.enabled", false]]}, resolve));
+
+  let visitUriPromise = promiseObserve("uri-visit-saved");
+
+  yield BrowserTestUtils.openNewForegroundTab(gBrowser, INITIAL_URL);
+
+  yield new Promise(resolve => SpecialPowers.popPrefEnv(resolve));
+
+  let browserLoadedPromise = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
+  gBrowser.loadURI(FINAL_URL);
+  yield browserLoadedPromise;
+
+  let subject = yield visitUriPromise;
+  let uri = subject.QueryInterface(Ci.nsIURI);
+  is(uri.spec, FINAL_URL, "received expected visit");
+
+  yield PlacesTestUtils.clearHistory();
+  gBrowser.removeCurrentTab();
+});
diff --git a/toolkit/components/places/tests/browser/browser_visituri_privatebrowsing_perwindowpb.js b/toolkit/components/places/tests/browser/browser_visituri_privatebrowsing_perwindowpb.js
new file mode 100644
index 000000000..abde69a7d
--- /dev/null
+++ b/toolkit/components/places/tests/browser/browser_visituri_privatebrowsing_perwindowpb.js
@@ -0,0 +1,73 @@
+/* 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/. */
+
+function test() {
+  // initialization
+  waitForExplicitFinish();
+  let windowsToClose = [];
+  let initialURL =
+    "http://example.com/tests/toolkit/components/places/tests/browser/begin.html";
+  let finalURL =
+    "http://example.com/tests/toolkit/components/places/tests/browser/final.html";
+  let observer = null;
+  let enumerator = null;
+  let currentObserver = null;
+  let uri = null;
+
+  function doTest(aIsPrivateMode, aWindow, aTestURI, aCallback) {
+    observer = {
+      observe: function(aSubject, aTopic, aData) {
+        // The uri-visit-saved topic should only work when on normal mode.
+        if (aTopic == "uri-visit-saved") {
+          // Remove the observers set on per window private mode and normal
+          // mode.
+          enumerator = aWindow.Services.obs.enumerateObservers("uri-visit-saved");
+          while (enumerator.hasMoreElements()) {
+            currentObserver = enumerator.getNext();
+            aWindow.Services.obs.removeObserver(currentObserver, "uri-visit-saved");
+          }
+
+          // The expected visit should be the finalURL because private mode
+          // should not register a visit with the initialURL.
+          uri = aSubject.QueryInterface(Ci.nsIURI);
+          is(uri.spec, finalURL, "Check received expected visit");
+        }
+      }
+    };
+
+    aWindow.Services.obs.addObserver(observer, "uri-visit-saved", false);
+
+    BrowserTestUtils.browserLoaded(aWindow.gBrowser.selectedBrowser).then(aCallback);
+    aWindow.gBrowser.selectedBrowser.loadURI(aTestURI);
+  }
+
+  function testOnWindow(aOptions, aCallback) {
+    whenNewWindowLoaded(aOptions, function(aWin) {
+      windowsToClose.push(aWin);
+      // execute should only be called when need, like when you are opening
+      // web pages on the test. If calling executeSoon() is not necesary, then
+      // call whenNewWindowLoaded() instead of testOnWindow() on your test.
+      executeSoon(() => aCallback(aWin));
+    });
+  }
+
+   // This function is called after calling finish() on the test.
+  registerCleanupFunction(function() {
+    windowsToClose.forEach(function(aWin) {
+      aWin.close();
+    });
+  });
+
+  // test first when on private mode
+  testOnWindow({private: true}, function(aWin) {
+    doTest(true, aWin, initialURL, function() {
+      // then test when not on private mode
+      testOnWindow({}, function(aWin2) {
+        doTest(false, aWin2, finalURL, function () {
+          PlacesTestUtils.clearHistory().then(finish);
+        });
+      });
+    });
+  });
+}
diff --git a/toolkit/components/places/tests/browser/colorAnalyzer/category-discover.png b/toolkit/components/places/tests/browser/colorAnalyzer/category-discover.png
new file mode 100644
index 000000000..a6f5b49b3
--- /dev/null
+++ b/toolkit/components/places/tests/browser/colorAnalyzer/category-discover.png
diff --git a/toolkit/components/places/tests/browser/colorAnalyzer/dictionaryGeneric-16.png b/toolkit/components/places/tests/browser/colorAnalyzer/dictionaryGeneric-16.png
new file mode 100644
index 000000000..4ad1a1a82
--- /dev/null
+++ b/toolkit/components/places/tests/browser/colorAnalyzer/dictionaryGeneric-16.png
diff --git a/toolkit/components/places/tests/browser/colorAnalyzer/extensionGeneric-16.png b/toolkit/components/places/tests/browser/colorAnalyzer/extensionGeneric-16.png
new file mode 100644
index 000000000..fc6c8a258
--- /dev/null
+++ b/toolkit/components/places/tests/browser/colorAnalyzer/extensionGeneric-16.png
diff --git a/toolkit/components/places/tests/browser/colorAnalyzer/localeGeneric.png b/toolkit/components/places/tests/browser/colorAnalyzer/localeGeneric.png
new file mode 100644
index 000000000..4d9ac5ad8
--- /dev/null
+++ b/toolkit/components/places/tests/browser/colorAnalyzer/localeGeneric.png
diff --git a/toolkit/components/places/tests/browser/favicon-normal16.png b/toolkit/components/places/tests/browser/favicon-normal16.png
new file mode 100644
index 000000000..62b69a3d0
--- /dev/null
+++ b/toolkit/components/places/tests/browser/favicon-normal16.png
diff --git a/toolkit/components/places/tests/browser/favicon-normal32.png b/toolkit/components/places/tests/browser/favicon-normal32.png
new file mode 100644
index 000000000..5535363c9
--- /dev/null
+++ b/toolkit/components/places/tests/browser/favicon-normal32.png
diff --git a/toolkit/components/places/tests/browser/favicon.html b/toolkit/components/places/tests/browser/favicon.html
new file mode 100644
index 000000000..a0f5ea959
--- /dev/null
+++ b/toolkit/components/places/tests/browser/favicon.html
@@ -0,0 +1,13 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+
+<html>
+  <head>
+    <link rel="shortcut icon" href="http://example.org/tests/toolkit/components/places/tests/browser/favicon-normal32.png">
+  </head>
+  <body>
+    OK we're done!
+  </body>
+</html>
diff --git a/toolkit/components/places/tests/browser/final.html b/toolkit/components/places/tests/browser/final.html
new file mode 100644
index 000000000..ccd581918
--- /dev/null
+++ b/toolkit/components/places/tests/browser/final.html
@@ -0,0 +1,10 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+
+<html>
+  <body>
+    OK we're done!
+  </body>
+</html>
diff --git a/toolkit/components/places/tests/browser/head.js b/toolkit/components/places/tests/browser/head.js
new file mode 100644
index 000000000..897585a81
--- /dev/null
+++ b/toolkit/components/places/tests/browser/head.js
@@ -0,0 +1,319 @@
+Components.utils.import("resource://gre/modules/PlacesUtils.jsm");
+Components.utils.import("resource://gre/modules/NetUtil.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "PlacesTestUtils",
+                                  "resource://testing-common/PlacesTestUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "BrowserTestUtils",
+                                  "resource://testing-common/BrowserTestUtils.jsm");
+
+const TRANSITION_LINK = PlacesUtils.history.TRANSITION_LINK;
+const TRANSITION_TYPED = PlacesUtils.history.TRANSITION_TYPED;
+const TRANSITION_BOOKMARK = PlacesUtils.history.TRANSITION_BOOKMARK;
+const TRANSITION_REDIRECT_PERMANENT = PlacesUtils.history.TRANSITION_REDIRECT_PERMANENT;
+const TRANSITION_REDIRECT_TEMPORARY = PlacesUtils.history.TRANSITION_REDIRECT_TEMPORARY;
+const TRANSITION_EMBED = PlacesUtils.history.TRANSITION_EMBED;
+const TRANSITION_FRAMED_LINK = PlacesUtils.history.TRANSITION_FRAMED_LINK;
+const TRANSITION_DOWNLOAD = PlacesUtils.history.TRANSITION_DOWNLOAD;
+
+/**
+ * Returns a moz_places field value for a url.
+ *
+ * @param aURI
+ *        The URI or spec to get field for.
+ * param aCallback
+ *        Callback function that will get the property value.
+ */
+function fieldForUrl(aURI, aFieldName, aCallback)
+{
+  let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
+  let stmt = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
+                                .DBConnection.createAsyncStatement(
+    `SELECT ${aFieldName} FROM moz_places WHERE url_hash = hash(:page_url) AND url = :page_url`
+  );
+  stmt.params.page_url = url;
+  stmt.executeAsync({
+    _value: -1,
+    handleResult: function(aResultSet) {
+      let row = aResultSet.getNextRow();
+      if (!row)
+        ok(false, "The page should exist in the database");
+      this._value = row.getResultByName(aFieldName);
+    },
+    handleError: function() {},
+    handleCompletion: function(aReason) {
+      if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED)
+         ok(false, "The statement should properly succeed");
+      aCallback(this._value);
+    }
+  });
+  stmt.finalize();
+}
+
+/**
+ * Generic nsINavHistoryObserver that doesn't implement anything, but provides
+ * dummy methods to prevent errors about an object not having a certain method.
+ */
+function NavHistoryObserver() {}
+
+NavHistoryObserver.prototype = {
+  onBeginUpdateBatch: function () {},
+  onEndUpdateBatch: function () {},
+  onVisit: function () {},
+  onTitleChanged: function () {},
+  onDeleteURI: function () {},
+  onClearHistory: function () {},
+  onPageChanged: function () {},
+  onDeleteVisits: function () {},
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsINavHistoryObserver,
+  ])
+};
+
+/**
+ * Waits for the first OnPageChanged notification for ATTRIBUTE_FAVICON, and
+ * verifies that it matches the expected page URI and associated favicon URI.
+ *
+ * This function also double-checks the GUID parameter of the notification.
+ *
+ * @param aExpectedPageURI
+ *        nsIURI object of the page whose favicon should change.
+ * @param aExpectedFaviconURI
+ *        nsIURI object of the newly associated favicon.
+ * @param aCallback
+ *        This function is called after the check finished.
+ */
+function waitForFaviconChanged(aExpectedPageURI, aExpectedFaviconURI, aWindow,
+                               aCallback) {
+  let historyObserver = {
+    __proto__: NavHistoryObserver.prototype,
+    onPageChanged: function WFFC_onPageChanged(aURI, aWhat, aValue, aGUID) {
+      if (aWhat != Ci.nsINavHistoryObserver.ATTRIBUTE_FAVICON) {
+        return;
+      }
+      aWindow.PlacesUtils.history.removeObserver(this);
+
+      ok(aURI.equals(aExpectedPageURI),
+        "Check URIs are equal for the page which favicon changed");
+      is(aValue, aExpectedFaviconURI.spec,
+        "Check changed favicon URI is the expected");
+      checkGuidForURI(aURI, aGUID);
+
+      if (aCallback) {
+        aCallback();
+      }
+    }
+  };
+  aWindow.PlacesUtils.history.addObserver(historyObserver, false);
+}
+
+/**
+ * Asynchronously adds visits to a page, invoking a callback function when done.
+ *
+ * @param aPlaceInfo
+ *        Either an nsIURI, in such a case a single LINK visit will be added.
+ *        Or can be an object describing the visit to add, or an array
+ *        of these objects:
+ *          { uri: nsIURI of the page,
+ *            transition: one of the TRANSITION_* from nsINavHistoryService,
+ *            [optional] title: title of the page,
+ *            [optional] visitDate: visit date in microseconds from the epoch
+ *            [optional] referrer: nsIURI of the referrer for this visit
+ *          }
+ * @param [optional] aCallback
+ *        Function to be invoked on completion.
+ * @param [optional] aStack
+ *        The stack frame used to report errors.
+ */
+function addVisits(aPlaceInfo, aWindow, aCallback, aStack) {
+  let places = [];
+  if (aPlaceInfo instanceof Ci.nsIURI) {
+    places.push({ uri: aPlaceInfo });
+  }
+  else if (Array.isArray(aPlaceInfo)) {
+    places = places.concat(aPlaceInfo);
+  } else {
+    places.push(aPlaceInfo)
+  }
+
+  // Create mozIVisitInfo for each entry.
+  let now = Date.now();
+  for (let place of places) {
+    if (!place.title) {
+      place.title = "test visit for " + place.uri.spec;
+    }
+    place.visits = [{
+      transitionType: place.transition === undefined ? TRANSITION_LINK
+                                                     : place.transition,
+      visitDate: place.visitDate || (now++) * 1000,
+      referrerURI: place.referrer
+    }];
+  }
+
+  aWindow.PlacesUtils.asyncHistory.updatePlaces(
+    places,
+    {
+      handleError: function AAV_handleError() {
+        throw ("Unexpected error in adding visit.");
+      },
+      handleResult: function () {},
+      handleCompletion: function UP_handleCompletion() {
+        if (aCallback)
+          aCallback();
+      }
+    }
+  );
+}
+
+/**
+ * Checks that the favicon for the given page matches the provided data.
+ *
+ * @param aPageURI
+ *        nsIURI object for the page to check.
+ * @param aExpectedMimeType
+ *        Expected MIME type of the icon, for example "image/png".
+ * @param aExpectedData
+ *        Expected icon data, expressed as an array of byte values.
+ * @param aCallback
+ *        This function is called after the check finished.
+ */
+function checkFaviconDataForPage(aPageURI, aExpectedMimeType, aExpectedData,
+  aWindow, aCallback) {
+  aWindow.PlacesUtils.favicons.getFaviconDataForPage(aPageURI,
+    function (aURI, aDataLen, aData, aMimeType) {
+      is(aExpectedMimeType, aMimeType, "Check expected MimeType");
+      is(aExpectedData.length, aData.length,
+        "Check favicon data for the given page matches the provided data");
+      checkGuidForURI(aPageURI);
+      aCallback();
+    });
+}
+
+/**
+ * Tests that a guid was set in moz_places for a given uri.
+ *
+ * @param aURI
+ *        The uri to check.
+ * @param [optional] aGUID
+ *        The expected guid in the database.
+ */
+function checkGuidForURI(aURI, aGUID) {
+  let guid = doGetGuidForURI(aURI);
+  if (aGUID) {
+    doCheckValidPlacesGuid(aGUID);
+    is(guid, aGUID, "Check equal guid for URIs");
+  }
+}
+
+/**
+ * Retrieves the guid for a given uri.
+ *
+ * @param aURI
+ *        The uri to check.
+ * @return the associated the guid.
+ */
+function doGetGuidForURI(aURI) {
+  let stmt = DBConn().createStatement(
+    `SELECT guid
+       FROM moz_places
+       WHERE url_hash = hash(:url) AND url = :url`
+  );
+  stmt.params.url = aURI.spec;
+  ok(stmt.executeStep(), "Check get guid for uri from moz_places");
+  let guid = stmt.row.guid;
+  stmt.finalize();
+  doCheckValidPlacesGuid(guid);
+  return guid;
+}
+
+/**
+ * Tests if a given guid is valid for use in Places or not.
+ *
+ * @param aGuid
+ *        The guid to test.
+ */
+function doCheckValidPlacesGuid(aGuid) {
+  ok(/^[a-zA-Z0-9\-_]{12}$/.test(aGuid), "Check guid for valid places");
+}
+
+/**
+ * Gets the database connection.  If the Places connection is invalid it will
+ * try to create a new connection.
+ *
+ * @param [optional] aForceNewConnection
+ *        Forces creation of a new connection to the database.  When a
+ *        connection is asyncClosed it cannot anymore schedule async statements,
+ *        though connectionReady will keep returning true (Bug 726990).
+ *
+ * @return The database connection or null if unable to get one.
+ */
+function DBConn(aForceNewConnection) {
+  let gDBConn;
+  if (!aForceNewConnection) {
+    let db = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
+      .DBConnection;
+    if (db.connectionReady)
+      return db;
+  }
+
+  // If the Places database connection has been closed, create a new connection.
+  if (!gDBConn || aForceNewConnection) {
+    let file = Services.dirsvc.get('ProfD', Ci.nsIFile);
+    file.append("places.sqlite");
+    let dbConn = gDBConn = Services.storage.openDatabase(file);
+
+    // Be sure to cleanly close this connection.
+    Services.obs.addObserver(function DBCloseCallback(aSubject, aTopic, aData) {
+      Services.obs.removeObserver(DBCloseCallback, aTopic);
+      dbConn.asyncClose();
+    }, "profile-before-change", false);
+  }
+
+  return gDBConn.connectionReady ? gDBConn : null;
+}
+
+function whenNewWindowLoaded(aOptions, aCallback) {
+  BrowserTestUtils.waitForNewWindow().then(aCallback);
+  OpenBrowserWindow(aOptions);
+}
+
+/**
+ * Asynchronously check a url is visited.
+ *
+ * @param aURI The URI.
+ * @param aExpectedValue The expected value.
+ * @return {Promise}
+ * @resolves When the check has been added successfully.
+ * @rejects JavaScript exception.
+ */
+function promiseIsURIVisited(aURI, aExpectedValue) {
+  return new Promise(resolve => {
+    PlacesUtils.asyncHistory.isURIVisited(aURI, function(unused, aIsVisited) {
+      resolve(aIsVisited);
+    });
+  });
+}
+
+function waitForCondition(condition, nextTest, errorMsg) {
+  let tries = 0;
+  let interval = setInterval(function() {
+    if (tries >= 30) {
+      ok(false, errorMsg);
+      moveOn();
+    }
+    let conditionPassed;
+    try {
+      conditionPassed = condition();
+    } catch (e) {
+      ok(false, e + "\n" + e.stack);
+      conditionPassed = false;
+    }
+    if (conditionPassed) {
+      moveOn();
+    }
+    tries++;
+  }, 200);
+  function moveOn() {
+    clearInterval(interval);
+    nextTest();
+  }
+}
diff --git a/toolkit/components/places/tests/browser/history_post.html b/toolkit/components/places/tests/browser/history_post.html
new file mode 100644
index 000000000..a579a9b8a
--- /dev/null
+++ b/toolkit/components/places/tests/browser/history_post.html
@@ -0,0 +1,12 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    <title>Test post pages are not added to history</title>
+  </head>
+  <body>
+    <iframe name="post_iframe" id="post_iframe"></iframe>
+    <form method="post" action="http://example.com/tests/toolkit/components/places/tests/browser/history_post.sjs" target="post_iframe">
+      <input type="submit" id="submit"/>
+    </form>
+  </body>
+</html>
diff --git a/toolkit/components/places/tests/browser/history_post.sjs b/toolkit/components/places/tests/browser/history_post.sjs
new file mode 100644
index 000000000..3c86aad7b
--- /dev/null
+++ b/toolkit/components/places/tests/browser/history_post.sjs
@@ -0,0 +1,6 @@
+function handleRequest(request, response)
+{
+  response.setStatusLine("1.0", 200, "OK");
+  response.setHeader("Content-Type", "text/plain; charset=utf-8", false);
+  response.write("Ciao");
+}
diff --git a/toolkit/components/places/tests/browser/redirect-target.html b/toolkit/components/places/tests/browser/redirect-target.html
new file mode 100644
index 000000000..370026338
--- /dev/null
+++ b/toolkit/components/places/tests/browser/redirect-target.html
@@ -0,0 +1 @@
+<!DOCTYPE html><html><body><p>Ciao!</p></body></html>
diff --git a/toolkit/components/places/tests/browser/redirect.sjs b/toolkit/components/places/tests/browser/redirect.sjs
new file mode 100644
index 000000000..f55e78eb1
--- /dev/null
+++ b/toolkit/components/places/tests/browser/redirect.sjs
@@ -0,0 +1,14 @@
+/* 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/. */
+
+function handleRequest(request, response)
+{
+  let page = "<!DOCTYPE html><html><body><p>Redirecting...</p></body></html>";
+
+  response.setStatusLine(request.httpVersion, "301", "Moved Permanently");
+  response.setHeader("Content-Type", "text/html", false);
+  response.setHeader("Content-Length", page.length + "", false);
+  response.setHeader("Location", "redirect-target.html", false);
+  response.write(page);
+}
diff --git a/toolkit/components/places/tests/browser/redirect_once.sjs b/toolkit/components/places/tests/browser/redirect_once.sjs
new file mode 100644
index 000000000..8b2a8aa55
--- /dev/null
+++ b/toolkit/components/places/tests/browser/redirect_once.sjs
@@ -0,0 +1,9 @@
+/**
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function handleRequest(request, response) {
+  response.setStatusLine("1.1", 301, "Found");
+  response.setHeader("Location", "final.html", false);
+}
diff --git a/toolkit/components/places/tests/browser/redirect_twice.sjs b/toolkit/components/places/tests/browser/redirect_twice.sjs
new file mode 100644
index 000000000..099d20022
--- /dev/null
+++ b/toolkit/components/places/tests/browser/redirect_twice.sjs
@@ -0,0 +1,9 @@
+/**
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function handleRequest(request, response) {
+  response.setStatusLine("1.1", 302, "Found");
+  response.setHeader("Location", "redirect_once.sjs", false);
+}
diff --git a/toolkit/components/places/tests/browser/title1.html b/toolkit/components/places/tests/browser/title1.html
new file mode 100644
index 000000000..3c98d693e
--- /dev/null
+++ b/toolkit/components/places/tests/browser/title1.html
@@ -0,0 +1,12 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+
+<html>
+  <head>
+  </head>
+  <body>
+    title1.html
+  </body>
+</html>
diff --git a/toolkit/components/places/tests/browser/title2.html b/toolkit/components/places/tests/browser/title2.html
new file mode 100644
index 000000000..28a6b69b5
--- /dev/null
+++ b/toolkit/components/places/tests/browser/title2.html
@@ -0,0 +1,14 @@
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+
+<html>
+  <head>
+    <title>Some title</title>
+  </head>
+  <body>
+    title2.html
+  </body>
+</html>
+
diff --git a/toolkit/components/places/tests/chrome/.eslintrc.js b/toolkit/components/places/tests/chrome/.eslintrc.js
new file mode 100644
index 000000000..bf379df8d
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/.eslintrc.js
@@ -0,0 +1,8 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/mochitest/chrome.eslintrc.js",
+    "../../../../../testing/mochitest/mochitest.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/chrome/bad_links.atom b/toolkit/components/places/tests/chrome/bad_links.atom
new file mode 100644
index 000000000..446927252
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/bad_links.atom
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+
+  <title>Example Feed</title> 
+  <link href="http://example.org/"/>
+  <updated>2003-12-13T18:30:02Z</updated>
+
+  <author> 
+    <name>John Doe</name>
+  </author> 
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+
+  <entry>
+
+    <title>First good item</title>
+    <link href="http://example.org/first"/>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
+    <updated>2003-12-13T18:30:02Z</updated>
+
+    <summary>Some text.</summary>
+  </entry>
+
+  <entry>
+
+    <title>data: link</title>
+    <link href="data:text/plain,Hi"/>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6b</id>
+    <updated>2003-12-13T18:30:03Z</updated>
+
+    <summary>Some text.</summary>
+  </entry>
+  
+  <entry>
+
+    <title>javascript: link</title>
+    <link href="javascript:alert('Hi')"/>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6c</id>
+    <updated>2003-12-13T18:30:04Z</updated>
+
+    <summary>Some text.</summary>
+  </entry>
+  
+  <entry>
+
+    <title>file: link</title>
+    <link href="file:///var/"/>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6d</id>
+    <updated>2003-12-13T18:30:05Z</updated>
+
+    <summary>Some text.</summary>
+  </entry>
+
+  <entry>
+
+    <title>chrome: link</title>
+    <link href="chrome://browser/content/browser.js"/>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6e</id>
+    <updated>2003-12-13T18:30:06Z</updated>
+
+    <summary>Some text.</summary>
+  </entry>
+
+  <entry>
+
+    <title>Last good item</title>
+    <link href="http://example.org/last"/>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6b</id>
+    <updated>2003-12-13T18:30:07Z</updated>
+
+    <summary>Some text.</summary>
+  </entry>
+
+
+</feed>
diff --git a/toolkit/components/places/tests/chrome/browser_disableglobalhistory.xul b/toolkit/components/places/tests/chrome/browser_disableglobalhistory.xul
new file mode 100644
index 000000000..d7bbfda67
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/browser_disableglobalhistory.xul
@@ -0,0 +1,44 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+
+<window title="Test disableglobalhistory attribute on remote browsers"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  onload="run_test();">
+  <script type="application/javascript"
+          src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript"
+          src="chrome://mochikit/content/tests/SimpleTest/SpawnTask.js"></script>
+
+  <browser id="inprocess_disabled" src="about:blank" type="content" disableglobalhistory="true" />
+  <browser id="inprocess_enabled" src="about:blank" type="content" />
+
+  <browser id="remote_disabled" src="about:blank" type="content" disableglobalhistory="true" />
+  <browser id="remote_enabled" src="about:blank" type="content" />
+
+  <script type="text/javascript;version=1.7">
+  const {interfaces: Ci, classes: Cc, results: Cr, utils: Cu} = Components;
+
+  Cu.import("resource://testing-common/ContentTask.jsm");
+  ContentTask.setTestScope(window.opener.wrappedJSObject);
+
+  function expectUseGlobalHistory(id, expected) {
+    let browser = document.getElementById(id);
+    return ContentTask.spawn(browser, {id, expected}, function*({id, expected}) {
+      Assert.equal(docShell.useGlobalHistory, expected,
+                   "Got the right useGlobalHistory state in the docShell of " + id);
+    });
+  }
+
+  function run_test() {
+    spawn_task(function*() {
+      yield expectUseGlobalHistory("inprocess_disabled", false);
+      yield expectUseGlobalHistory("inprocess_enabled", true);
+
+      yield expectUseGlobalHistory("remote_disabled", false);
+      yield expectUseGlobalHistory("remote_enabled", true);
+      window.opener.done();
+    });
+  };
+
+  </script>
+</window>
\ No newline at end of file
diff --git a/toolkit/components/places/tests/chrome/chrome.ini b/toolkit/components/places/tests/chrome/chrome.ini
new file mode 100644
index 000000000..5ac753e73
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/chrome.ini
@@ -0,0 +1,12 @@
+[DEFAULT]
+
+[test_303567.xul]
+[test_341972a.xul]
+[test_341972b.xul]
+[test_342484.xul]
+[test_371798.xul]
+[test_381357.xul]
+[test_favicon_annotations.xul]
+[test_reloadLivemarks.xul]
+[test_browser_disableglobalhistory.xul]
+support-files = browser_disableglobalhistory.xul
\ No newline at end of file
diff --git a/toolkit/components/places/tests/chrome/link-less-items-no-site-uri.rss b/toolkit/components/places/tests/chrome/link-less-items-no-site-uri.rss
new file mode 100644
index 000000000..612b0a5c2
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/link-less-items-no-site-uri.rss
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<rss version="2.0">
+  <channel>
+    <title>feed title</title>
+    <ttl>180</ttl>
+    <item>
+      <title>linked feed item</title>
+	    <link>http://feed-item-link.com</link>
+    </item>
+    <item>
+      <title>link-less feed item</title>
+    </item>
+    <item>
+      <title>linked feed item</title>
+	    <link>http://feed-item-link.com</link>
+    </item>
+  </channel>
+</rss>
diff --git a/toolkit/components/places/tests/chrome/link-less-items.rss b/toolkit/components/places/tests/chrome/link-less-items.rss
new file mode 100644
index 000000000..a30d4a353
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/link-less-items.rss
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<rss version="2.0">
+  <channel>
+    <title>feed title</title>
+    <link>http://feed-link.com</link>
+    <ttl>180</ttl>
+    <item>
+      <title>linked feed item</title>
+	    <link>http://feed-item-link.com</link>
+    </item>
+    <item>
+      <title>link-less feed item</title>
+    </item>
+    <item>
+      <title>linked feed item</title>
+	    <link>http://feed-item-link.com</link>
+    </item>
+  </channel>
+</rss>
diff --git a/toolkit/components/places/tests/chrome/rss_as_html.rss b/toolkit/components/places/tests/chrome/rss_as_html.rss
new file mode 100644
index 000000000..e82305035
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/rss_as_html.rss
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
+<channel>
+<title>sadfasdfasdfasfasdf</title>
+<link>http://www.example.com</link>
+<description>asdfasdfasdf.example.com</description>
+<language>de</language>
+<copyright>asdfasdfasdfasdf</copyright>
+<lastBuildDate>Tue, 11 Mar 2008 18:52:52 +0100</lastBuildDate>
+<docs>http://blogs.law.harvard.edu/tech/rss</docs>
+<ttl>10</ttl>
+<item>
+<title>The First Title</title>
+<link>http://www.example.com/index.html</link>
+<pubDate>Tue, 11 Mar 2008 18:24:43 +0100</pubDate>
+<content:encoded>
+<![CDATA[
+<p>
+askdlfjas;dfkjas;fkdj
+</p>
+]]>
+</content:encoded>
+<description>aklsjdhfasdjfahasdfhj</description>
+<guid>http://foo.example.com/asdfasdf</guid>
+</item>
+</channel>
+</rss>
diff --git a/toolkit/components/places/tests/chrome/rss_as_html.rss^headers^ b/toolkit/components/places/tests/chrome/rss_as_html.rss^headers^
new file mode 100644
index 000000000..04fbaa08f
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/rss_as_html.rss^headers^
@@ -0,0 +1,2 @@
+HTTP 200 OK
+Content-Type: text/html
diff --git a/toolkit/components/places/tests/chrome/sample_feed.atom b/toolkit/components/places/tests/chrome/sample_feed.atom
new file mode 100644
index 000000000..add75efb4
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/sample_feed.atom
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+
+  <title>Example Feed</title> 
+  <link href="http://example.org/"/>
+  <updated>2003-12-13T18:30:02Z</updated>
+
+  <author> 
+    <name>John Doe</name>
+  </author> 
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+
+  <entry>
+
+    <title>Atom-Powered Robots Run Amok</title>
+    <link href="http://example.org/2003/12/13/atom03"/>
+    <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
+    <updated>2003-12-13T18:30:02Z</updated>
+
+    <summary>Some text.</summary>
+  </entry>
+
+</feed>
diff --git a/toolkit/components/places/tests/chrome/test_303567.xul b/toolkit/components/places/tests/chrome/test_303567.xul
new file mode 100644
index 000000000..37ae77cbb
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_303567.xul
@@ -0,0 +1,122 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet
+  href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
+<window title="Add Bad Livemarks"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  onload="runTest()">
+  <script type="application/javascript"
+   src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml" />
+
+<script type="application/javascript">
+<![CDATA[
+// Test that for feeds with items that have no link:
+//   * the link-less items are present in the database.
+//   * the feed's site URI is substituted for each item's link.
+SimpleTest.waitForExplicitFinish();
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/NetUtil.jsm");
+Components.utils.import("resource://gre/modules/PlacesUtils.jsm");
+
+const LIVEMARKS = [
+  { feedURI: NetUtil.newURI("http://mochi.test:8888/tests/toolkit/components/places/tests/chrome/link-less-items.rss"),
+    siteURI: NetUtil.newURI("http://mochi.test:8888/"),
+    urls: [
+      "http://feed-item-link.com/",
+      "http://feed-link.com/",
+      "http://feed-item-link.com/",
+    ],
+    message: "Ensure link-less livemark item picked up site uri.",
+  },
+  { feedURI: NetUtil.newURI("http://mochi.test:8888/tests/toolkit/components/places/tests/chrome/link-less-items-no-site-uri.rss"),
+    siteURI: null,
+    urls: [
+      "http://feed-item-link.com/",
+      "http://feed-item-link.com/",
+    ],
+    message: "Ensure livemark item links did not inherit site uri."
+  },  
+];
+
+function runTest()
+{
+  let loadCount = 0;
+
+  function testLivemark(aLivemarkData) {
+    PlacesUtils.livemarks.addLivemark(
+      { title: "foo"
+      , parentGuid: PlacesUtils.bookmarks.toolbarGuid
+      , feedURI: aLivemarkData.feedURI
+      , siteURI: aLivemarkData.siteURI
+      })
+      .then(function (aLivemark) {
+        is (aLivemark.feedURI.spec, aLivemarkData.feedURI.spec,
+            "Get correct feedURI");
+        if (aLivemarkData.siteURI) {
+          is (aLivemark.siteURI.spec, aLivemarkData.siteURI.spec,
+              "Get correct siteURI");
+        }
+        else {
+          is (aLivemark.siteURI, null, "Get correct siteURI");
+        }
+
+        waitForLivemarkLoad(aLivemark, function (aLivemark) {
+          let nodes = aLivemark.getNodesForContainer({});
+          is(nodes.length, aLivemarkData.urls.length,
+             "Ensure all the livemark items were created.");
+          aLivemarkData.urls.forEach(function (aUrl, aIndex) {
+            let node = nodes[aIndex];
+            is(node.uri, aUrl, aLivemarkData.message);
+          });
+
+          PlacesUtils.livemarks.removeLivemark(aLivemark).then(() => {
+            if (++loadCount == LIVEMARKS.length)
+              SimpleTest.finish();
+          });
+        });
+      }, function () {
+        is(true, false, "Should not fail adding a livemark");
+      }
+    );
+  }
+
+  LIVEMARKS.forEach(testLivemark);
+}
+
+function waitForLivemarkLoad(aLivemark, aCallback) {
+  // Don't need a real node here.
+  let node = {};
+  let resultObserver = {
+    nodeInserted: function() {},
+    nodeRemoved: function() {},
+    nodeAnnotationChanged: function() {},
+    nodeTitleChanged: function() {},
+    nodeHistoryDetailsChanged: function() {},
+    nodeMoved: function() {},
+    ontainerStateChanged: function () {},
+    sortingChanged: function() {},
+    batching: function() {},
+    invalidateContainer: function(node) {
+      isnot(aLivemark.status, Ci.mozILivemark.STATUS_FAILED,
+            "Loading livemark should success");
+      if (aLivemark.status == Ci.mozILivemark.STATUS_READY) {
+        aLivemark.unregisterForUpdates(node, resultObserver);
+        aCallback(aLivemark);
+      }
+    }
+  };
+  aLivemark.registerForUpdates(node, resultObserver);
+  aLivemark.reload();
+}
+
+]]>
+</script>
+</window>
diff --git a/toolkit/components/places/tests/chrome/test_341972a.xul b/toolkit/components/places/tests/chrome/test_341972a.xul
new file mode 100644
index 000000000..7c78136a9
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_341972a.xul
@@ -0,0 +1,87 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet
+  href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
+<window title="Update Livemark SiteURI"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  onload="runTest()">
+  <script type="application/javascript"
+   src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml" />
+
+<script type="application/javascript">
+<![CDATA[
+/*
+ Test updating livemark siteURI to the value from the feed
+ */
+SimpleTest.waitForExplicitFinish();
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/NetUtil.jsm");
+Components.utils.import("resource://gre/modules/PlacesUtils.jsm");
+
+function runTest() {
+  const FEEDSPEC = "http://mochi.test:8888/tests/toolkit/components/places/tests/chrome/sample_feed.atom";
+  const INITIALSITESPEC = "http://mochi.test:8888/";
+  const FEEDSITESPEC = "http://example.org/"; 
+
+  PlacesUtils.livemarks.addLivemark(
+    { title: "foo"
+    , parentGuid: PlacesUtils.bookmarks.toolbarGuid
+    , feedURI: NetUtil.newURI(FEEDSPEC)
+    , siteURI: NetUtil.newURI(INITIALSITESPEC)
+    })
+    .then(function (aLivemark) {
+      is(aLivemark.siteURI.spec, INITIALSITESPEC,
+         "Has correct initial livemark site URI");
+
+      waitForLivemarkLoad(aLivemark, function (aLivemark) {
+        is(aLivemark.siteURI.spec, FEEDSITESPEC,
+           "livemark site URI set to value in feed");
+
+        PlacesUtils.livemarks.removeLivemark(aLivemark).then(() => {
+          SimpleTest.finish();
+        });
+      });
+    }, function () {
+      is(true, false, "Should not fail adding a livemark");
+    }
+  );
+}
+
+function waitForLivemarkLoad(aLivemark, aCallback) {
+  // Don't need a real node here.
+  let node = {};
+  let resultObserver = {
+    nodeInserted: function() {},
+    nodeRemoved: function() {},
+    nodeAnnotationChanged: function() {},
+    nodeTitleChanged: function() {},
+    nodeHistoryDetailsChanged: function() {},
+    nodeMoved: function() {},
+    ontainerStateChanged: function () {},
+    sortingChanged: function() {},
+    batching: function() {},
+    invalidateContainer: function(node) {
+      isnot(aLivemark.status, Ci.mozILivemark.STATUS_FAILED,
+            "Loading livemark should success");
+      if (aLivemark.status == Ci.mozILivemark.STATUS_READY) {
+        aLivemark.unregisterForUpdates(node, resultObserver);
+        aCallback(aLivemark);
+      }
+    }
+  };
+  aLivemark.registerForUpdates(node, resultObserver);
+  aLivemark.reload();
+}
+
+]]>
+</script>
+
+</window>
diff --git a/toolkit/components/places/tests/chrome/test_341972b.xul b/toolkit/components/places/tests/chrome/test_341972b.xul
new file mode 100644
index 000000000..86cdc75f3
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_341972b.xul
@@ -0,0 +1,84 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet
+  href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
+<window title="Update Livemark SiteURI, null to start"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  onload="runTest()">
+  <script type="application/javascript"
+   src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml" />
+
+<script type="application/javascript">
+<![CDATA[
+/*
+ Test updating livemark siteURI to the value from the feed, when it's null
+ */
+SimpleTest.waitForExplicitFinish();
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/NetUtil.jsm");
+Components.utils.import("resource://gre/modules/PlacesUtils.jsm");
+
+function runTest() {
+  const FEEDSPEC = "http://mochi.test:8888/tests/toolkit/components/places/tests/chrome/sample_feed.atom";
+  const FEEDSITESPEC = "http://example.org/"; 
+
+  PlacesUtils.livemarks.addLivemark(
+    { title: "foo"
+    , parentGuid: PlacesUtils.bookmarks.toolbarGuid
+    , feedURI: NetUtil.newURI(FEEDSPEC)
+    })
+    .then(function (aLivemark) {
+      is(aLivemark.siteURI, null, "Has null livemark site URI");
+
+      waitForLivemarkLoad(aLivemark, function (aLivemark) {
+        is(aLivemark.siteURI.spec, FEEDSITESPEC,
+           "livemark site URI set to value in feed");
+
+        PlacesUtils.livemarks.removeLivemark(aLivemark).then(() => {
+          SimpleTest.finish();
+        });
+      });
+    }, function () {
+      is(true, false, "Should not fail adding a livemark");
+    }
+  );
+}
+
+function waitForLivemarkLoad(aLivemark, aCallback) {
+  // Don't need a real node here.
+  let node = {};
+  let resultObserver = {
+    nodeInserted: function() {},
+    nodeRemoved: function() {},
+    nodeAnnotationChanged: function() {},
+    nodeTitleChanged: function() {},
+    nodeHistoryDetailsChanged: function() {},
+    nodeMoved: function() {},
+    ontainerStateChanged: function () {},
+    sortingChanged: function() {},
+    batching: function() {},
+    invalidateContainer: function(node) {
+      isnot(aLivemark.status, Ci.mozILivemark.STATUS_FAILED,
+            "Loading livemark should success");
+      if (aLivemark.status == Ci.mozILivemark.STATUS_READY) {
+        aLivemark.unregisterForUpdates(node, resultObserver);
+        aCallback(aLivemark);
+      }
+    }
+  };
+  aLivemark.registerForUpdates(node, resultObserver);
+  aLivemark.reload();
+}
+
+]]>
+</script>
+
+</window>
diff --git a/toolkit/components/places/tests/chrome/test_342484.xul b/toolkit/components/places/tests/chrome/test_342484.xul
new file mode 100644
index 000000000..353313abb
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_342484.xul
@@ -0,0 +1,88 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet
+  href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
+<window title="Add Bad Livemarks"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  onload="runTest()">
+  <script type="application/javascript"
+   src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml" />
+
+<script type="application/javascript">
+<![CDATA[
+/*
+ Test loading feeds with items that aren't allowed
+ */
+SimpleTest.waitForExplicitFinish();
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/NetUtil.jsm");
+Components.utils.import("resource://gre/modules/PlacesUtils.jsm");
+
+function runTest() {
+  const FEEDSPEC = "http://mochi.test:8888/tests/toolkit/components/places/tests/chrome/bad_links.atom";
+  const GOOD_URLS = ["http://example.org/first", "http://example.org/last"];
+
+  PlacesUtils.livemarks.addLivemark(
+    { title: "foo"
+    , parentGuid: PlacesUtils.bookmarks.toolbarGuid
+    , feedURI: NetUtil.newURI(FEEDSPEC)
+    , siteURI: NetUtil.newURI("http:/mochi.test/")
+    })
+    .then(function (aLivemark) {
+      waitForLivemarkLoad(aLivemark, function (aLivemark) {
+        let nodes = aLivemark.getNodesForContainer({});
+
+        is(nodes.length, 2, "Created the two good livemark items");
+        for (let i = 0; i < nodes.length; ++i) {
+          let node = nodes[i];
+          ok(GOOD_URLS.includes(node.uri), "livemark item created with bad uri " + node.uri);
+        }
+
+        PlacesUtils.livemarks.removeLivemark(aLivemark).then(() => {
+          SimpleTest.finish();
+        });
+      });
+    }, function () {
+      is(true, false, "Should not fail adding a livemark");
+    }
+  );
+}
+
+function waitForLivemarkLoad(aLivemark, aCallback) {
+  // Don't need a real node here.
+  let node = {};
+  let resultObserver = {
+    nodeInserted: function() {},
+    nodeRemoved: function() {},
+    nodeAnnotationChanged: function() {},
+    nodeTitleChanged: function() {},
+    nodeHistoryDetailsChanged: function() {},
+    nodeMoved: function() {},
+    ontainerStateChanged: function () {},
+    sortingChanged: function() {},
+    batching: function() {},
+    invalidateContainer: function(node) {
+      isnot(aLivemark.status, Ci.mozILivemark.STATUS_FAILED,
+            "Loading livemark should success");
+      if (aLivemark.status == Ci.mozILivemark.STATUS_READY) {
+        aLivemark.unregisterForUpdates(node, resultObserver);
+        aCallback(aLivemark);
+      }
+    }
+  };
+  aLivemark.registerForUpdates(node, resultObserver);
+  aLivemark.reload();
+}
+
+]]>
+</script>
+
+</window>
diff --git a/toolkit/components/places/tests/chrome/test_371798.xul b/toolkit/components/places/tests/chrome/test_371798.xul
new file mode 100644
index 000000000..241db75c3
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_371798.xul
@@ -0,0 +1,101 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet
+  href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
+<window title="Bug 371798"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script type="application/javascript"
+   src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml" />
+
+<script type="application/javascript">
+<![CDATA[
+// Test the asynchronous live-updating of bookmarks query results
+SimpleTest.waitForExplicitFinish();
+
+var {utils: Cu, interfaces: Ci} = Components;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+
+Cu.import("resource://gre/modules/PlacesUtils.jsm");
+
+const TEST_URI = NetUtil.newURI("http://foo.com");
+
+function promiseOnItemChanged() {
+  return new Promise(resolve => {
+    PlacesUtils.bookmarks.addObserver({
+      onBeginUpdateBatch() {},
+      onEndUpdateBatch() {},
+      onItemAdded() {},
+      onItemRemoved() {},
+      onItemVisited() {},
+      onItemMoved() {},
+
+      onItemChanged() {
+        PlacesUtils.bookmarks.removeObserver(this);
+        resolve();
+      },
+
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsINavBookmarkObserver])
+    }, false);
+  });
+}
+
+Task.spawn(function* () {
+  // add 2 bookmarks to the toolbar, same URI, different titles (set later)
+  let bm1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    url: TEST_URI
+  });
+
+  let bm2 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    url: TEST_URI
+  });
+
+  // query for bookmarks
+  let rootNode = PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId).root;
+
+  // set up observer
+  let promiseObserved = promiseOnItemChanged();
+
+  // modify the bookmark's title
+  yield PlacesUtils.bookmarks.update({
+    guid: bm2.guid, title: "foo"
+  });
+
+  // wait for notification
+  yield promiseObserved;
+
+  // Continue after our observer gets notified of onItemChanged
+  // which is triggered by updating the item's title.
+  // After receiving the notification, our original query should also
+  // have been live-updated, so we can iterate through its children,
+  // to check that only the modified bookmark has changed.
+
+  // result node should be updated
+  let cc = rootNode.childCount;
+  for (let i = 0; i < cc; ++i) {
+    let node = rootNode.getChild(i);
+    // test that bm1 does not have new title
+    if (node.bookmarkGuid == bm1.guid)
+      ok(node.title != "foo",
+         "Changing a bookmark's title did not affect the title of other bookmarks with the same URI");
+  }
+  rootNode.containerOpen = false;
+
+  // clean up
+  yield PlacesUtils.bookmarks.remove(bm1);
+  yield PlacesUtils.bookmarks.remove(bm2);
+}).catch(err => {
+  ok(false, `uncaught error: ${err}`);
+}).then(() => {
+  SimpleTest.finish();
+});
+]]>
+</script>
+
+</window>
diff --git a/toolkit/components/places/tests/chrome/test_381357.xul b/toolkit/components/places/tests/chrome/test_381357.xul
new file mode 100644
index 000000000..6bd6cb024
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_381357.xul
@@ -0,0 +1,85 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet
+  href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
+<window title="Add Livemarks from RSS feed served as text/html"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  onload="runTest()">
+  <script type="application/javascript"
+   src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml" />
+
+<script type="application/javascript">
+<![CDATA[
+/*
+ Test loading feeds with text/html 
+ */
+SimpleTest.waitForExplicitFinish();
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/NetUtil.jsm");
+Components.utils.import("resource://gre/modules/PlacesUtils.jsm");
+
+function runTest() {
+  const FEEDSPEC = "http://mochi.test:8888/tests/toolkit/components/places/tests/chrome/rss_as_html.rss";
+
+  PlacesUtils.livemarks.addLivemark(
+    { title: "foo"
+    , parentGuid: PlacesUtils.bookmarks.toolbarGuid
+    , feedURI: NetUtil.newURI(FEEDSPEC)
+    , siteURI: NetUtil.newURI("http:/mochi.test/")
+    })
+    .then(function (aLivemark) {
+      waitForLivemarkLoad(aLivemark, function (aLivemark) {
+        let nodes = aLivemark.getNodesForContainer({});
+
+        is(nodes[0].title, "The First Title",
+           "livemark site URI set to value in feed");
+
+        PlacesUtils.livemarks.removeLivemark(aLivemark).then(() => {
+          SimpleTest.finish();
+        });
+      });
+    }, function () {
+      is(true, false, "Should not fail adding a livemark");
+      SimpleTest.finish();
+    }
+  );
+}
+
+function waitForLivemarkLoad(aLivemark, aCallback) {
+  // Don't need a real node here.
+  let node = {};
+  let resultObserver = {
+    nodeInserted: function() {},
+    nodeRemoved: function() {},
+    nodeAnnotationChanged: function() {},
+    nodeTitleChanged: function() {},
+    nodeHistoryDetailsChanged: function() {},
+    nodeMoved: function() {},
+    ontainerStateChanged: function () {},
+    sortingChanged: function() {},
+    batching: function() {},
+    invalidateContainer: function(node) {
+      isnot(aLivemark.status, Ci.mozILivemark.STATUS_FAILED,
+            "Loading livemark should success");
+      if (aLivemark.status == Ci.mozILivemark.STATUS_READY) {
+        aLivemark.unregisterForUpdates(node, resultObserver);
+        aCallback(aLivemark);
+      }
+    }
+  };
+  aLivemark.registerForUpdates(node, resultObserver);
+  aLivemark.reload();
+}
+
+]]>
+</script>
+
+</window>
diff --git a/toolkit/components/places/tests/chrome/test_browser_disableglobalhistory.xul b/toolkit/components/places/tests/chrome/test_browser_disableglobalhistory.xul
new file mode 100644
index 000000000..3a84f3030
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_browser_disableglobalhistory.xul
@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css"
+                 type="text/css"?>
+
+<window title="Test disableglobalhistory attribute on remote browsers"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script type="application/javascript"
+          src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <!-- test results are displayed in the html:body -->
+  <body xmlns="http://www.w3.org/1999/xhtml">
+  </body>
+
+  <script type="text/javascript;version=1.7">
+  SimpleTest.waitForExplicitFinish();
+
+  let w = window.open('browser_disableglobalhistory.xul', '_blank', 'chrome,resizable=yes,width=400,height=600');
+
+  function done() {
+    w.close();
+    SimpleTest.finish();
+  }
+  </script>
+
+</window>
\ No newline at end of file
diff --git a/toolkit/components/places/tests/chrome/test_favicon_annotations.xul b/toolkit/components/places/tests/chrome/test_favicon_annotations.xul
new file mode 100644
index 000000000..b7647cbc6
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_favicon_annotations.xul
@@ -0,0 +1,168 @@
+<?xml version="1.0"?>
+<!-- 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 file tests the moz-anno protocol, which was added in Bug 316077 and how
+ * it loads favicons.
+-->
+
+<window title="Favicon Annotation Protocol Test"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        onload="test();">
+
+  <script type="application/javascript"
+          src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
+  <script type="application/javascript"
+          src="chrome://mochikit/content/tests/SimpleTest/WindowSnapshot.js"/>
+  <script type="application/javascript"
+          src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/>
+
+  <script type="application/javascript">
+  <![CDATA[
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+let fs = Cc["@mozilla.org/browser/favicon-service;1"].
+         getService(Ci.nsIFaviconService);
+
+// Test descriptions that will be printed in the case of failure.
+let testDescriptions = [
+  "moz-anno URI with no data in the database loads default icon",
+  "URI added to the database is properly loaded",
+];
+
+// URIs to load (will be compared with expectedURIs of the same index).
+let testURIs = [
+  "http://mozilla.org/2009/made-up-favicon/places-rocks/",
+  "http://mozilla.org/should-be-barney/",
+];
+
+// URIs to load for expected results.
+let expectedURIs = [
+  fs.defaultFavicon.spec,
+  "data:image/png,%89PNG%0D%0A%1A%0A%00%00%00%0DIHDR%00%00%00%10%00%00%00%10%08%06%00%00%00%1F%F3%FFa%00%00%00%04gAMA%00%00%AF%C87%05%8A%E9%00%00%00%19tEXtSoftware%00Adobe%20ImageReadyq%C9e%3C%00%00%01%D6IDATx%DAb%FC%FF%FF%3F%03%25%00%20%80%98%909%EF%DF%BFg%EF%EC%EC%FC%AD%AC%AC%FC%DF%95%91%F1%BF%89%89%C9%7F%20%FF%D7%EA%D5%AB%B7%DF%BBwO%16%9B%01%00%01%C4%00r%01%08%9F9s%C6%CD%D8%D8%F8%BF%0B%03%C3%FF3%40%BC%0A%88%EF%02q%1A%10%BB%40%F1%AAU%ABv%C1%D4%C30%40%00%81%89%993g%3E%06%1A%F6%3F%14%AA%11D%97%03%F1%7Fc%08%0D%E2%2B))%FD%17%04%89%A1%19%00%10%40%0C%D00%F8%0F3%00%C8%F8%BF%1B%E4%0Ac%88a%E5%60%17%19%FF%0F%0D%0D%05%1B%02v%D9%DD%BB%0A0%03%00%02%08%AC%B9%A3%A3%E3%17%03%D4v%90%01%EF%18%106%C3%0Cz%07%C5%BB%A1%DE%82y%07%20%80%A0%A6%08B%FCn%0C1%60%26%D4%20d%C3VA%C3%06%26%BE%0A%EA-%80%00%82%B9%E0%F7L4%0D%EF%90%F8%C6%60%2F%0A%82%BD%01%13%07%0700%D0%01%02%88%11%E4%02P%B41%DC%BB%C7%D0%014%0D%E8l%06W%20%06%BA%88%A1%1C%1AS%15%40%7C%16%CA6.%2Fgx%BFg%0F%83%CB%D9%B3%0C%7B%80%7C%80%00%02%BB%00%E8%9F%ED%20%1B%3A%A0%A6%9F%81%DA%DC%01%C5%B0%80%ED%80%FA%BF%BC%BC%FC%3F%83%12%90%9D%96%F6%1F%20%80%18%DE%BD%7B%C7%0E%8E%05AD%20%FEGr%A6%A0%A0%E0%7F%25P%80%02%9D%0F%D28%13%18%23%C6%C0%B0%02E%3D%C8%F5%00%01%04%8F%05P%A8%BA%40my%87%E4%12c%A8%8D%20%8B%D0%D3%00%08%03%04%10%9C%01R%E4%82d%3B%C8%A0%99%C6%90%90%C6%A5%19%84%01%02%08%9E%17%80%C9x%F7%7B%A0%DBVC%F9%A0%C0%5C%7D%16%2C%CE%00%F4%C6O%5C%99%09%20%800L%04y%A5%03%1A%95%A0%80%05%05%14.%DBA%18%20%80%18)%CD%CE%00%01%06%00%0C'%94%C7%C0k%C9%2C%00%00%00%00IEND%AEB%60%82",
+];
+
+
+/**
+ * The event listener placed on our test windows used to determine when it is
+ * safe to compare the two windows.
+ */
+let _results = [];
+function loadEventHandler()
+{
+  _results.push(snapshotWindow(window));
+
+  loadNextTest();
+}
+
+/**
+ * This runs the comparison.
+ */
+function compareResults(aIndex, aImage1, aImage2)
+{
+  let [correct, data1, data2] = compareSnapshots(aImage1, aImage2, true);
+  SimpleTest.ok(correct,
+                "Test '" + testDescriptions[aIndex] + "' matches expectations. " +
+                "Data from window 1 is '" + data1 + "'. " +
+                "Data from window 2 is '" + data2 + "'");
+}
+
+/**
+ * Loads the next set of URIs to compare against.
+ */
+let _counter = -1;
+function loadNextTest()
+{
+  _counter++;
+  // If we have no more tests, finish.
+  if (_counter / 2 == testDescriptions.length) {
+    for (let i = 0; i < _results.length; i = i + 2)
+      compareResults(i / 2, _results[i], _results[i + 1]);
+
+    SimpleTest.finish();
+    return;
+  }
+
+  let nextURI = function() {
+    let index = Math.floor(_counter / 2);
+    if ((_counter % 2) == 0)
+      return "moz-anno:favicon:" + testURIs[index];
+    return expectedURIs[index];
+  }
+
+  let img = document.getElementById("favicon");
+  img.setAttribute("src", nextURI());
+}
+
+function test()
+{
+  SimpleTest.waitForExplicitFinish();
+  let db = Cc["@mozilla.org/browser/nav-history-service;1"].
+           getService(Ci.nsPIPlacesDatabase).
+           DBConnection;
+
+  // Empty any old favicons
+  db.executeSimpleSQL("DELETE FROM moz_favicons");
+
+  let ios = Cc["@mozilla.org/network/io-service;1"].
+            getService(Ci.nsIIOService);
+  let uri = function(aSpec) {
+    return ios.newURI(aSpec, null, null);
+  };
+
+  let pageURI = uri("http://example.com/favicon_annotations");
+  let history = Cc["@mozilla.org/browser/history;1"]
+                  .getService(Ci.mozIAsyncHistory);
+  history.updatePlaces(
+    {
+      uri: pageURI,
+      visits: [{ transitionType: Ci.nsINavHistoryService.TRANSITION_TYPED,
+                 visitDate: Date.now() * 1000
+              }],
+    },
+    {
+      handleError: function UP_handleError() {
+        ok(false, "Unexpected error in adding visit.");
+      },
+      handleResult: function () {},
+      handleCompletion: function UP_handleCompletion() {
+        // Set the favicon data.  Note that the "moz-anno:" protocol requires
+        // the favicon to be stored in the database, but the
+        // replaceFaviconDataFromDataURL function will not save the favicon
+        // unless it is associated with a page.  Thus, we must associate the
+        // icon with a page explicitly in order for it to be visible through
+        // the protocol.
+        var systemPrincipal = Cc["@mozilla.org/systemprincipal;1"]
+                                .createInstance(Ci.nsIPrincipal);
+
+        fs.replaceFaviconDataFromDataURL(uri(testURIs[1]), expectedURIs[1],
+                                         (Date.now() + 60 * 60 * 24 * 1000) * 1000,
+                                         systemPrincipal);
+
+        fs.setAndFetchFaviconForPage(pageURI, uri(testURIs[1]), true,
+                                     fs.FAVICON_LOAD_NON_PRIVATE,
+                                     null, systemPrincipal);
+
+        // And start our test process.
+        loadNextTest();
+      }
+    }
+  );
+
+
+}
+
+  ]]>
+  </script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml">
+    <img id="favicon" onload="loadEventHandler();"/>
+    <p id="display"></p>
+    <div id="content" style="display:none;"></div>
+    <pre id="test"></pre>
+  </body>
+</window>
diff --git a/toolkit/components/places/tests/chrome/test_reloadLivemarks.xul b/toolkit/components/places/tests/chrome/test_reloadLivemarks.xul
new file mode 100644
index 000000000..43772d09f
--- /dev/null
+++ b/toolkit/components/places/tests/chrome/test_reloadLivemarks.xul
@@ -0,0 +1,155 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet
+  href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
+<window title="Reload Livemarks"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  onload="runTest()" onunload="cleanup()">
+  <script type="application/javascript"
+   src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml" />
+
+<script type="application/javascript">
+<![CDATA[
+// Test that for concurrent reload of livemarks.
+
+SimpleTest.waitForExplicitFinish();
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/NetUtil.jsm");
+Components.utils.import("resource://gre/modules/PlacesUtils.jsm");
+
+let gLivemarks = [
+  { id: -1,
+    title: "foo",
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    feedURI: NetUtil.newURI("http://mochi.test:8888/tests/toolkit/components/places/tests/chrome/link-less-items.rss")
+  },
+  { id: -1,
+    title: "bar",
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    feedURI: NetUtil.newURI("http://mochi.test:8888/tests/toolkit/components/places/tests/chrome/link-less-items-no-site-uri.rss")
+  },
+];
+
+function runTest()
+{
+  addLivemarks(function () {
+    reloadLivemarks(false, function () {
+      reloadLivemarks(true, function () {
+        removeLivemarks(SimpleTest.finish);
+      });
+    });
+    // Ensure this normal reload doesn't overwrite the forced one.
+    PlacesUtils.livemarks.reloadLivemarks();
+  });
+}
+
+function addLivemarks(aCallback) {
+  info("Adding livemarks");
+  let count = gLivemarks.length;
+  gLivemarks.forEach(function(aLivemarkData) {
+    PlacesUtils.livemarks.addLivemark(aLivemarkData)
+      .then(function (aLivemark) {
+        ok(aLivemark.feedURI.equals(aLivemarkData.feedURI), "Livemark added");
+        aLivemarkData.id = aLivemark.id;
+        if (--count == 0) {
+          aCallback();
+        }
+      },
+      function () {
+        is(true, false, "Should not fail adding a livemark.");
+        aCallback();
+      });
+  });
+}
+
+function reloadLivemarks(aForceUpdate, aCallback) {
+  info("Reloading livemarks with forceUpdate: " + aForceUpdate);
+  let count = gLivemarks.length;
+  gLivemarks.forEach(function(aLivemarkData) {
+    PlacesUtils.livemarks.getLivemark(aLivemarkData)
+      .then(aLivemark => {
+        ok(aLivemark.feedURI.equals(aLivemarkData.feedURI), "Livemark found");
+        aLivemarkData._observer = new resultObserver(aLivemark, function() {
+          if (++count == gLivemarks.length) {
+            aCallback();
+          }
+        });
+        if (--count == 0) {
+          PlacesUtils.livemarks.reloadLivemarks(aForceUpdate);
+        }
+      },
+      function() {
+        is(true, false, "Should not fail getting a livemark.");
+        aCallback();
+      }
+    );
+  });
+}
+
+function removeLivemarks(aCallback) {
+  info("Removing livemarks");
+  let count = gLivemarks.length;
+  gLivemarks.forEach(function(aLivemarkData) {
+    PlacesUtils.livemarks.removeLivemark(aLivemarkData).then(
+      function (aLivemark) {
+        if (--count == 0) {
+          aCallback();
+        }
+      },
+      function() {
+        is(true, false, "Should not fail adding a livemark.");
+        aCallback();
+      }
+    );
+  });
+}
+
+function resultObserver(aLivemark, aCallback) {
+  this._node = {};
+  this._livemark = aLivemark;
+  this._callback = aCallback;
+  this._livemark.registerForUpdates(this._node, this);
+}
+resultObserver.prototype = {
+  nodeInserted: function() {},
+  nodeRemoved: function() {},
+  nodeAnnotationChanged: function() {},
+  nodeTitleChanged: function() {},
+  nodeHistoryDetailsChanged: function() {},
+  nodeMoved: function() {},
+  ontainerStateChanged: function () {},
+  sortingChanged: function() {},
+  batching: function() {},
+  invalidateContainer: function(aContainer) {
+    // Wait for load finish.
+    if (this._livemark.status == Ci.mozILivemark.STATUS_LOADING)
+      return;
+
+    this._terminate();
+    this._callback();
+  },
+  _terminate: function () {
+    if (!this._terminated) {
+      this._livemark.unregisterForUpdates(this._node);
+      this._terminated = true;
+    }
+  }
+};
+
+function cleanup() {
+  gLivemarks.forEach(function(aLivemarkData) {
+    if (aLivemarkData._observer)
+      aLivemarkData._observer._terminate();
+  });
+}
+]]>
+</script>
+</window>
diff --git a/toolkit/components/places/tests/cpp/mock_Link.h b/toolkit/components/places/tests/cpp/mock_Link.h
new file mode 100644
index 000000000..92ef25d6a
--- /dev/null
+++ b/toolkit/components/places/tests/cpp/mock_Link.h
@@ -0,0 +1,229 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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 is a mock Link object which can be used in tests.
+ */
+
+#ifndef mock_Link_h__
+#define mock_Link_h__
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/dom/Link.h"
+#include "mozilla/dom/URLSearchParams.h"
+
+class mock_Link : public mozilla::dom::Link
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  explicit mock_Link(void (*aHandlerFunction)(nsLinkState),
+                     bool aRunNextTest = true)
+  : mozilla::dom::Link(nullptr)
+  , mHandler(aHandlerFunction)
+  , mRunNextTest(aRunNextTest)
+  {
+    // Create a cyclic ownership, so that the link will be released only
+    // after its status has been updated.  This will ensure that, when it should
+    // run the next test, it will happen at the end of the test function, if
+    // the link status has already been set before.  Indeed the link status is
+    // updated on a separate connection, thus may happen at any time.
+    mDeathGrip = this;
+  }
+
+  virtual void SetLinkState(nsLinkState aState) override
+  {
+    // Notify our callback function.
+    mHandler(aState);
+
+    // Break the cycle so the object can be destroyed.
+    mDeathGrip = nullptr;
+  }
+
+  virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override
+  {
+    return 0;   // the value shouldn't matter
+  }
+
+protected:
+  ~mock_Link() {
+    // Run the next test if we are supposed to.
+    if (mRunNextTest) {
+      run_next_test();
+    }
+  }
+
+private:
+  void (*mHandler)(nsLinkState);
+  bool mRunNextTest;
+  RefPtr<Link> mDeathGrip;
+};
+
+NS_IMPL_ISUPPORTS(
+  mock_Link,
+  mozilla::dom::Link
+)
+
+////////////////////////////////////////////////////////////////////////////////
+//// Needed Link Methods
+
+namespace mozilla {
+namespace dom {
+
+Link::Link(Element* aElement)
+: mElement(aElement)
+, mLinkState(eLinkState_NotLink)
+, mRegistered(false)
+{
+}
+
+Link::~Link()
+{
+}
+
+bool
+Link::ElementHasHref() const
+{
+  NS_NOTREACHED("Unexpected call to Link::ElementHasHref");
+  return false; // suppress compiler warning
+}
+
+void
+Link::SetLinkState(nsLinkState aState)
+{
+  NS_NOTREACHED("Unexpected call to Link::SetLinkState");
+}
+
+void
+Link::ResetLinkState(bool aNotify, bool aHasHref)
+{
+  NS_NOTREACHED("Unexpected call to Link::ResetLinkState");
+}
+
+nsIURI*
+Link::GetURI() const
+{
+  NS_NOTREACHED("Unexpected call to Link::GetURI");
+  return nullptr; // suppress compiler warning
+}
+
+size_t
+Link::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+{
+  NS_NOTREACHED("Unexpected call to Link::SizeOfExcludingThis");
+  return 0;
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(URLSearchParams)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(URLSearchParams)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(URLSearchParams)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(URLSearchParams)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(URLSearchParams)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(URLSearchParams)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(URLSearchParams)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+
+URLSearchParams::URLSearchParams(nsISupports* aParent,
+                                 URLSearchParamsObserver* aObserver)
+{
+}
+
+URLSearchParams::~URLSearchParams()
+{
+}
+
+JSObject*
+URLSearchParams::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return nullptr;
+}
+
+void
+URLSearchParams::ParseInput(const nsACString& aInput)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::ParseInput");
+}
+
+void
+URLSearchParams::Serialize(nsAString& aValue) const
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::Serialize");
+}
+
+void
+URLSearchParams::Get(const nsAString& aName, nsString& aRetval)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::Get");
+}
+
+void
+URLSearchParams::GetAll(const nsAString& aName, nsTArray<nsString >& aRetval)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::GetAll");
+}
+
+void
+URLSearchParams::Set(const nsAString& aName, const nsAString& aValue)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::Set");
+}
+
+void
+URLSearchParams::Append(const nsAString& aName, const nsAString& aValue)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::Append");
+}
+
+void
+URLSearchParams::AppendInternal(const nsAString& aName, const nsAString& aValue)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::AppendInternal");
+}
+
+bool
+URLSearchParams::Has(const nsAString& aName)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::Has");
+  return false;
+}
+
+void
+URLSearchParams::Delete(const nsAString& aName)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::Delete");
+}
+
+void
+URLSearchParams::DeleteAll()
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::DeleteAll");
+}
+
+void
+URLSearchParams::NotifyObserver()
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::NotifyObserver");
+}
+
+NS_IMETHODIMP
+URLSearchParams::GetSendInfo(nsIInputStream** aBody, uint64_t* aContentLength,
+                             nsACString& aContentType, nsACString& aCharset)
+{
+  NS_NOTREACHED("Unexpected call to URLSearchParams::GetSendInfo");
+  return NS_OK;
+}
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mock_Link_h__
diff --git a/toolkit/components/places/tests/cpp/moz.build b/toolkit/components/places/tests/cpp/moz.build
new file mode 100644
index 000000000..f6bd91bd7
--- /dev/null
+++ b/toolkit/components/places/tests/cpp/moz.build
@@ -0,0 +1,14 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+GeckoCppUnitTests([
+    'test_IHistory',
+])
+
+if CONFIG['JS_SHARED_LIBRARY']:
+    USE_LIBS += [
+        'js',
+    ]
diff --git a/toolkit/components/places/tests/cpp/places_test_harness.h b/toolkit/components/places/tests/cpp/places_test_harness.h
new file mode 100644
index 000000000..557a25f90
--- /dev/null
+++ b/toolkit/components/places/tests/cpp/places_test_harness.h
@@ -0,0 +1,413 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+#include "TestHarness.h"
+#include "nsMemory.h"
+#include "nsThreadUtils.h"
+#include "nsDocShellCID.h"
+
+#include "nsToolkitCompsCID.h"
+#include "nsINavHistoryService.h"
+#include "nsIObserverService.h"
+#include "nsIURI.h"
+#include "mozilla/IHistory.h"
+#include "mozIStorageConnection.h"
+#include "mozIStorageStatement.h"
+#include "mozIStorageAsyncStatement.h"
+#include "mozIStorageStatementCallback.h"
+#include "mozIStoragePendingStatement.h"
+#include "nsPIPlacesDatabase.h"
+#include "nsIObserver.h"
+#include "prinrval.h"
+#include "prtime.h"
+#include "mozilla/Attributes.h"
+
+#define WAITFORTOPIC_TIMEOUT_SECONDS 5
+
+
+static size_t gTotalTests = 0;
+static size_t gPassedTests = 0;
+
+#define do_check_true(aCondition) \
+  PR_BEGIN_MACRO \
+    gTotalTests++; \
+    if (aCondition) { \
+      gPassedTests++; \
+    } else { \
+      fail("%s | Expected true, got false at line %d", __FILE__, __LINE__); \
+    } \
+  PR_END_MACRO
+
+#define do_check_false(aCondition) \
+  PR_BEGIN_MACRO \
+    gTotalTests++; \
+    if (!aCondition) { \
+      gPassedTests++; \
+    } else { \
+      fail("%s | Expected false, got true at line %d", __FILE__, __LINE__); \
+    } \
+  PR_END_MACRO
+
+#define do_check_success(aResult) \
+  do_check_true(NS_SUCCEEDED(aResult))
+
+#ifdef LINUX
+// XXX Linux opt builds on tinderbox are orange due to linking with stdlib.
+// This is sad and annoying, but it's a workaround that works.
+#define do_check_eq(aExpected, aActual) \
+  do_check_true(aExpected == aActual)
+#else
+#include <sstream>
+
+#define do_check_eq(aActual, aExpected) \
+  PR_BEGIN_MACRO \
+    gTotalTests++; \
+    if (aExpected == aActual) { \
+      gPassedTests++; \
+    } else { \
+      std::ostringstream temp; \
+      temp << __FILE__ << " | Expected '" << aExpected << "', got '"; \
+      temp << aActual <<"' at line " << __LINE__; \
+      fail(temp.str().c_str()); \
+    } \
+  PR_END_MACRO
+#endif
+
+struct Test
+{
+  void (*func)(void);
+  const char* const name;
+};
+#define TEST(aName) \
+  {aName, #aName}
+
+/**
+ * Runs the next text.
+ */
+void run_next_test();
+
+/**
+ * To be used around asynchronous work.
+ */
+void do_test_pending();
+void do_test_finished();
+
+/**
+ * Spins current thread until a topic is received.
+ */
+class WaitForTopicSpinner final : public nsIObserver
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  explicit WaitForTopicSpinner(const char* const aTopic)
+  : mTopicReceived(false)
+  , mStartTime(PR_IntervalNow())
+  {
+    nsCOMPtr<nsIObserverService> observerService =
+      do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    do_check_true(observerService);
+    (void)observerService->AddObserver(this, aTopic, false);
+  }
+
+  void Spin() {
+    while (!mTopicReceived) {
+      if ((PR_IntervalNow() - mStartTime) > (WAITFORTOPIC_TIMEOUT_SECONDS * PR_USEC_PER_SEC)) {
+        // Timed out waiting for the topic.
+        do_check_true(false);
+        break;
+      }
+      (void)NS_ProcessNextEvent();
+    }
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject,
+                     const char* aTopic,
+                     const char16_t* aData) override
+  {
+    mTopicReceived = true;
+    nsCOMPtr<nsIObserverService> observerService =
+      do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    do_check_true(observerService);
+    (void)observerService->RemoveObserver(this, aTopic);
+    return NS_OK;
+  }
+
+private:
+  ~WaitForTopicSpinner() {}
+
+  bool mTopicReceived;
+  PRIntervalTime mStartTime;
+};
+NS_IMPL_ISUPPORTS(
+  WaitForTopicSpinner,
+  nsIObserver
+)
+
+/**
+ * Spins current thread until an async statement is executed.
+ */
+class AsyncStatementSpinner final : public mozIStorageStatementCallback
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_MOZISTORAGESTATEMENTCALLBACK
+
+  AsyncStatementSpinner();
+  void SpinUntilCompleted();
+  uint16_t completionReason;
+
+protected:
+  ~AsyncStatementSpinner() {}
+
+  volatile bool mCompleted;
+};
+
+NS_IMPL_ISUPPORTS(AsyncStatementSpinner,
+                  mozIStorageStatementCallback)
+
+AsyncStatementSpinner::AsyncStatementSpinner()
+: completionReason(0)
+, mCompleted(false)
+{
+}
+
+NS_IMETHODIMP
+AsyncStatementSpinner::HandleResult(mozIStorageResultSet *aResultSet)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+AsyncStatementSpinner::HandleError(mozIStorageError *aError)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+AsyncStatementSpinner::HandleCompletion(uint16_t aReason)
+{
+  completionReason = aReason;
+  mCompleted = true;
+  return NS_OK;
+}
+
+void AsyncStatementSpinner::SpinUntilCompleted()
+{
+  nsCOMPtr<nsIThread> thread(::do_GetCurrentThread());
+  nsresult rv = NS_OK;
+  bool processed = true;
+  while (!mCompleted && NS_SUCCEEDED(rv)) {
+    rv = thread->ProcessNextEvent(true, &processed);
+  }
+}
+
+struct PlaceRecord
+{
+  int64_t id;
+  int32_t hidden;
+  int32_t typed;
+  int32_t visitCount;
+  nsCString guid;
+};
+
+struct VisitRecord
+{
+  int64_t id;
+  int64_t lastVisitId;
+  int32_t transitionType;
+};
+
+already_AddRefed<mozilla::IHistory>
+do_get_IHistory()
+{
+  nsCOMPtr<mozilla::IHistory> history = do_GetService(NS_IHISTORY_CONTRACTID);
+  do_check_true(history);
+  return history.forget();
+}
+
+already_AddRefed<nsINavHistoryService>
+do_get_NavHistory()
+{
+  nsCOMPtr<nsINavHistoryService> serv =
+    do_GetService(NS_NAVHISTORYSERVICE_CONTRACTID);
+  do_check_true(serv);
+  return serv.forget();
+}
+
+already_AddRefed<mozIStorageConnection>
+do_get_db()
+{
+  nsCOMPtr<nsINavHistoryService> history = do_get_NavHistory();
+  nsCOMPtr<nsPIPlacesDatabase> database = do_QueryInterface(history);
+  do_check_true(database);
+
+  nsCOMPtr<mozIStorageConnection> dbConn;
+  nsresult rv = database->GetDBConnection(getter_AddRefs(dbConn));
+  do_check_success(rv);
+  return dbConn.forget();
+}
+
+/**
+ * Get the place record from the database.
+ *
+ * @param aURI The unique URI of the place we are looking up
+ * @param result Out parameter where the result is stored
+ */
+void
+do_get_place(nsIURI* aURI, PlaceRecord& result)
+{
+  nsCOMPtr<mozIStorageConnection> dbConn = do_get_db();
+  nsCOMPtr<mozIStorageStatement> stmt;
+
+  nsCString spec;
+  nsresult rv = aURI->GetSpec(spec);
+  do_check_success(rv);
+
+  rv = dbConn->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT id, hidden, typed, visit_count, guid FROM moz_places "
+    "WHERE url_hash = hash(?1) AND url = ?1"
+  ), getter_AddRefs(stmt));
+  do_check_success(rv);
+
+  rv = stmt->BindUTF8StringByIndex(0, spec);
+  do_check_success(rv);
+
+  bool hasResults;
+  rv = stmt->ExecuteStep(&hasResults);
+  do_check_success(rv);
+  if (!hasResults) {
+    result.id = 0;
+    return;
+  }
+
+  rv = stmt->GetInt64(0, &result.id);
+  do_check_success(rv);
+  rv = stmt->GetInt32(1, &result.hidden);
+  do_check_success(rv);
+  rv = stmt->GetInt32(2, &result.typed);
+  do_check_success(rv);
+  rv = stmt->GetInt32(3, &result.visitCount);
+  do_check_success(rv);
+  rv = stmt->GetUTF8String(4, result.guid);
+  do_check_success(rv);
+}
+
+/**
+ * Gets the most recent visit to a place.
+ *
+ * @param placeID ID from the moz_places table
+ * @param result Out parameter where visit is stored
+ */
+void
+do_get_lastVisit(int64_t placeId, VisitRecord& result)
+{
+  nsCOMPtr<mozIStorageConnection> dbConn = do_get_db();
+  nsCOMPtr<mozIStorageStatement> stmt;
+
+  nsresult rv = dbConn->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT id, from_visit, visit_type FROM moz_historyvisits "
+    "WHERE place_id=?1 "
+    "LIMIT 1"
+  ), getter_AddRefs(stmt));
+  do_check_success(rv);
+
+  rv = stmt->BindInt64ByIndex(0, placeId);
+  do_check_success(rv);
+
+  bool hasResults;
+  rv = stmt->ExecuteStep(&hasResults);
+  do_check_success(rv);
+
+  if (!hasResults) {
+    result.id = 0;
+    return;
+  }
+
+  rv = stmt->GetInt64(0, &result.id);
+  do_check_success(rv);
+  rv = stmt->GetInt64(1, &result.lastVisitId);
+  do_check_success(rv);
+  rv = stmt->GetInt32(2, &result.transitionType);
+  do_check_success(rv);
+}
+
+void
+do_wait_async_updates() {
+  nsCOMPtr<mozIStorageConnection> db = do_get_db();
+  nsCOMPtr<mozIStorageAsyncStatement> stmt;
+
+  db->CreateAsyncStatement(NS_LITERAL_CSTRING("BEGIN EXCLUSIVE"),
+                           getter_AddRefs(stmt));
+  nsCOMPtr<mozIStoragePendingStatement> pending;
+  (void)stmt->ExecuteAsync(nullptr, getter_AddRefs(pending));
+
+  db->CreateAsyncStatement(NS_LITERAL_CSTRING("COMMIT"),
+                           getter_AddRefs(stmt));
+  RefPtr<AsyncStatementSpinner> spinner = new AsyncStatementSpinner();
+  (void)stmt->ExecuteAsync(spinner, getter_AddRefs(pending));
+
+  spinner->SpinUntilCompleted();
+}
+
+/**
+ * Adds a URI to the database.
+ *
+ * @param aURI
+ *        The URI to add to the database.
+ */
+void
+addURI(nsIURI* aURI)
+{
+  nsCOMPtr<mozilla::IHistory> history = do_GetService(NS_IHISTORY_CONTRACTID);
+  do_check_true(history);
+  nsresult rv = history->VisitURI(aURI, nullptr, mozilla::IHistory::TOP_LEVEL);
+  do_check_success(rv);
+
+  do_wait_async_updates();
+}
+
+static const char TOPIC_PROFILE_CHANGE[] = "profile-before-change";
+static const char TOPIC_PLACES_CONNECTION_CLOSED[] = "places-connection-closed";
+
+class WaitForConnectionClosed final : public nsIObserver
+{
+  RefPtr<WaitForTopicSpinner> mSpinner;
+
+  ~WaitForConnectionClosed() {}
+
+public:
+  NS_DECL_ISUPPORTS
+
+  WaitForConnectionClosed()
+  {
+    nsCOMPtr<nsIObserverService> os =
+      do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    MOZ_ASSERT(os);
+    if (os) {
+      MOZ_ALWAYS_SUCCEEDS(os->AddObserver(this, TOPIC_PROFILE_CHANGE, false));
+    }
+    mSpinner = new WaitForTopicSpinner(TOPIC_PLACES_CONNECTION_CLOSED);
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject,
+                     const char* aTopic,
+                     const char16_t* aData) override
+  {
+    nsCOMPtr<nsIObserverService> os =
+      do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    MOZ_ASSERT(os);
+    if (os) {
+      MOZ_ALWAYS_SUCCEEDS(os->RemoveObserver(this, aTopic));
+    }
+
+    mSpinner->Spin();
+
+    return NS_OK;
+  }
+};
+
+NS_IMPL_ISUPPORTS(WaitForConnectionClosed, nsIObserver)
diff --git a/toolkit/components/places/tests/cpp/places_test_harness_tail.h b/toolkit/components/places/tests/cpp/places_test_harness_tail.h
new file mode 100644
index 000000000..4bbd45ccb
--- /dev/null
+++ b/toolkit/components/places/tests/cpp/places_test_harness_tail.h
@@ -0,0 +1,149 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+#include "nsWidgetsCID.h"
+#include "nsIComponentRegistrar.h"
+#ifdef MOZ_CRASHREPORTER
+#include "nsICrashReporter.h"
+#endif
+
+#ifndef TEST_NAME
+#error "Must #define TEST_NAME before including places_test_harness_tail.h"
+#endif
+
+#ifndef TEST_FILE
+#error "Must #define TEST_FILE before include places_test_harness_tail.h"
+#endif
+
+int gTestsIndex = 0;
+
+#define TEST_INFO_STR "TEST-INFO | (%s) | "
+
+class RunNextTest : public mozilla::Runnable
+{
+public:
+  NS_IMETHOD Run() override
+  {
+    NS_ASSERTION(NS_IsMainThread(), "Not running on the main thread?");
+    if (gTestsIndex < int(mozilla::ArrayLength(gTests))) {
+      do_test_pending();
+      Test &test = gTests[gTestsIndex++];
+      (void)fprintf(stderr, TEST_INFO_STR "Running %s.\n", TEST_FILE,
+                    test.name);
+      test.func();
+    }
+
+    do_test_finished();
+    return NS_OK;
+  }
+};
+
+void
+run_next_test()
+{
+  nsCOMPtr<nsIRunnable> event = new RunNextTest();
+  do_check_success(NS_DispatchToCurrentThread(event));
+}
+
+int gPendingTests = 0;
+
+void
+do_test_pending()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Not running on the main thread?");
+  gPendingTests++;
+}
+
+void
+do_test_finished()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Not running on the main thread?");
+  NS_ASSERTION(gPendingTests > 0, "Invalid pending test count!");
+  gPendingTests--;
+}
+
+void
+disable_idle_service()
+{
+  (void)fprintf(stderr, TEST_INFO_STR  "Disabling Idle Service.\n", TEST_FILE);
+  static NS_DEFINE_IID(kIdleCID, NS_IDLE_SERVICE_CID);
+  nsresult rv;
+  nsCOMPtr<nsIFactory> idleFactory = do_GetClassObject(kIdleCID, &rv);
+  do_check_success(rv);
+  nsCOMPtr<nsIComponentRegistrar> registrar;
+  rv = NS_GetComponentRegistrar(getter_AddRefs(registrar));
+  do_check_success(rv);
+  rv = registrar->UnregisterFactory(kIdleCID, idleFactory);
+  do_check_success(rv);
+}
+
+int
+main(int aArgc,
+     char** aArgv)
+{
+  ScopedXPCOM xpcom(TEST_NAME);
+  if (xpcom.failed())
+    return -1;
+  // Initialize a profile folder to ensure a clean shutdown.
+  nsCOMPtr<nsIFile> profile = xpcom.GetProfileDirectory();
+  if (!profile) {
+    fail("Couldn't get the profile directory.");
+    return -1;
+  }
+
+#ifdef MOZ_CRASHREPORTER
+    char* enabled = PR_GetEnv("MOZ_CRASHREPORTER");
+    if (enabled && !strcmp(enabled, "1")) {
+      // bug 787458: move this to an even-more-common location to use in all
+      // C++ unittests
+      nsCOMPtr<nsICrashReporter> crashreporter =
+        do_GetService("@mozilla.org/toolkit/crash-reporter;1");
+      if (crashreporter) {
+        fprintf(stderr, "Setting up crash reporting\n");
+
+        nsCOMPtr<nsIProperties> dirsvc =
+          do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
+        if (!dirsvc)
+          NS_RUNTIMEABORT("Couldn't get directory service");
+        nsCOMPtr<nsIFile> cwd;
+        nsresult rv = dirsvc->Get(NS_OS_CURRENT_WORKING_DIR,
+                                  NS_GET_IID(nsIFile),
+                                  getter_AddRefs(cwd));
+        if (NS_FAILED(rv))
+          NS_RUNTIMEABORT("Couldn't get CWD");
+        crashreporter->SetEnabled(true);
+        crashreporter->SetMinidumpPath(cwd);
+      }
+    }
+#endif
+
+  RefPtr<WaitForConnectionClosed> spinClose = new WaitForConnectionClosed();
+
+  // Tinderboxes are constantly on idle.  Since idle tasks can interact with
+  // tests, causing random failures, disable the idle service.
+  disable_idle_service();
+
+  do_test_pending();
+  run_next_test();
+
+  // Spin the event loop until we've run out of tests to run.
+  while (gPendingTests) {
+    (void)NS_ProcessNextEvent();
+  }
+
+  // And let any other events finish before we quit.
+  (void)NS_ProcessPendingEvents(nullptr);
+
+  // Check that we have passed all of our tests, and output accordingly.
+  if (gPassedTests == gTotalTests) {
+    passed(TEST_FILE);
+  }
+
+  (void)fprintf(stderr, TEST_INFO_STR  "%u of %u tests passed\n",
+                TEST_FILE, unsigned(gPassedTests), unsigned(gTotalTests));
+
+  return gPassedTests == gTotalTests ? 0 : -1;
+}
diff --git a/toolkit/components/places/tests/cpp/test_IHistory.cpp b/toolkit/components/places/tests/cpp/test_IHistory.cpp
new file mode 100644
index 000000000..90998ce8c
--- /dev/null
+++ b/toolkit/components/places/tests/cpp/test_IHistory.cpp
@@ -0,0 +1,639 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+#include "places_test_harness.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "mozilla/Attributes.h"
+#include "nsNetUtil.h"
+
+#include "mock_Link.h"
+using namespace mozilla;
+using namespace mozilla::dom;
+
+/**
+ * This file tests the IHistory interface.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+//// Helper Methods
+
+void
+expect_visit(nsLinkState aState)
+{
+  do_check_true(aState == eLinkState_Visited);
+}
+
+void
+expect_no_visit(nsLinkState aState)
+{
+  do_check_true(aState == eLinkState_Unvisited);
+}
+
+already_AddRefed<nsIURI>
+new_test_uri()
+{
+  // Create a unique spec.
+  static int32_t specNumber = 0;
+  nsAutoCString spec = NS_LITERAL_CSTRING("http://mozilla.org/");
+  spec.AppendInt(specNumber++);
+
+  // Create the URI for the spec.
+  nsCOMPtr<nsIURI> testURI;
+  nsresult rv = NS_NewURI(getter_AddRefs(testURI), spec);
+  do_check_success(rv);
+  return testURI.forget();
+}
+
+class VisitURIObserver final : public nsIObserver
+{
+  ~VisitURIObserver() {}
+
+public:
+  NS_DECL_ISUPPORTS
+
+  explicit VisitURIObserver(int aExpectedVisits = 1) :
+    mVisits(0),
+    mExpectedVisits(aExpectedVisits)
+  {
+    nsCOMPtr<nsIObserverService> observerService =
+      do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    do_check_true(observerService);
+    (void)observerService->AddObserver(this,
+                                       "uri-visit-saved",
+                                       false);
+  }
+
+  void WaitForNotification()
+  {
+    while (mVisits < mExpectedVisits) {
+      (void)NS_ProcessNextEvent();
+    }
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject,
+                     const char* aTopic,
+                     const char16_t* aData) override
+  {
+    mVisits++;
+
+    if (mVisits == mExpectedVisits) {
+      nsCOMPtr<nsIObserverService> observerService =
+        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+      (void)observerService->RemoveObserver(this, "uri-visit-saved");
+    }
+
+    return NS_OK;
+  }
+private:
+  int mVisits;
+  int mExpectedVisits;
+};
+NS_IMPL_ISUPPORTS(
+  VisitURIObserver,
+  nsIObserver
+)
+
+////////////////////////////////////////////////////////////////////////////////
+//// Test Functions
+
+void
+test_set_places_enabled()
+{
+  // Ensure places is enabled for everyone.
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch =
+    do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  do_check_success(rv);
+
+  rv = prefBranch->SetBoolPref("places.history.enabled", true);
+  do_check_success(rv);
+
+  // Run the next test.
+  run_next_test();
+}
+
+
+void
+test_wait_checkpoint()
+{
+  // This "fake" test is here to wait for the initial WAL checkpoint we force
+  // after creating the database schema, since that may happen at any time,
+  // and cause concurrent readers to access an older checkpoint.
+  nsCOMPtr<mozIStorageConnection> db = do_get_db();
+  nsCOMPtr<mozIStorageAsyncStatement> stmt;
+  db->CreateAsyncStatement(NS_LITERAL_CSTRING("SELECT 1"),
+                           getter_AddRefs(stmt));
+  RefPtr<AsyncStatementSpinner> spinner = new AsyncStatementSpinner();
+  nsCOMPtr<mozIStoragePendingStatement> pending;
+  (void)stmt->ExecuteAsync(spinner, getter_AddRefs(pending));
+  spinner->SpinUntilCompleted();
+
+  // Run the next test.
+  run_next_test();
+}
+
+// These variables are shared between part 1 and part 2 of the test.  Part 2
+// sets the nsCOMPtr's to nullptr, freeing the reference.
+namespace test_unvisited_does_not_notify {
+  nsCOMPtr<nsIURI> testURI;
+  RefPtr<Link> testLink;
+} // namespace test_unvisited_does_not_notify
+void
+test_unvisited_does_not_notify_part1()
+{
+  using namespace test_unvisited_does_not_notify;
+
+  // This test is done in two parts.  The first part registers for a URI that
+  // should not be visited.  We then run another test that will also do a
+  // lookup and will be notified.  Since requests are answered in the order they
+  // are requested (at least as long as the same URI isn't asked for later), we
+  // will know that the Link was not notified.
+
+  // First, we need a test URI.
+  testURI = new_test_uri();
+
+  // Create our test Link.
+  testLink = new mock_Link(expect_no_visit);
+
+  // Now, register our Link to be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->RegisterVisitedCallback(testURI, testLink);
+  do_check_success(rv);
+
+  // Run the next test.
+  run_next_test();
+}
+
+void
+test_visited_notifies()
+{
+  // First, we add our test URI to history.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  addURI(testURI);
+
+  // Create our test Link.  The callback function will release the reference we
+  // have on the Link.
+  RefPtr<Link> link = new mock_Link(expect_visit);
+
+  // Now, register our Link to be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->RegisterVisitedCallback(testURI, link);
+  do_check_success(rv);
+
+  // Note: test will continue upon notification.
+}
+
+void
+test_unvisited_does_not_notify_part2()
+{
+  using namespace test_unvisited_does_not_notify;
+
+  // We would have had a failure at this point had the content node been told it
+  // was visited.  Therefore, it is safe to unregister our content node.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->UnregisterVisitedCallback(testURI, testLink);
+  do_check_success(rv);
+
+  // Clear the stored variables now.
+  testURI = nullptr;
+  testLink = nullptr;
+
+  // Run the next test.
+  run_next_test();
+}
+
+void
+test_same_uri_notifies_both()
+{
+  // First, we add our test URI to history.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  addURI(testURI);
+
+  // Create our two test Links.  The callback function will release the
+  // reference we have on the Links.  Only the second Link should run the next
+  // test!
+  RefPtr<Link> link1 = new mock_Link(expect_visit, false);
+  RefPtr<Link> link2 = new mock_Link(expect_visit);
+
+  // Now, register our Link to be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->RegisterVisitedCallback(testURI, link1);
+  do_check_success(rv);
+  rv = history->RegisterVisitedCallback(testURI, link2);
+  do_check_success(rv);
+
+  // Note: test will continue upon notification.
+}
+
+void
+test_unregistered_visited_does_not_notify()
+{
+  // This test must have a test that has a successful notification after it.
+  // The Link would have been notified by now if we were buggy and notified
+  // unregistered Links (due to request serialization).
+
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  RefPtr<Link> link = new mock_Link(expect_no_visit);
+
+  // Now, register our Link to be notified.
+  nsCOMPtr<IHistory> history(do_get_IHistory());
+  nsresult rv = history->RegisterVisitedCallback(testURI, link);
+  do_check_success(rv);
+
+  // Unregister the Link.
+  rv = history->UnregisterVisitedCallback(testURI, link);
+  do_check_success(rv);
+
+  // And finally add a visit for the URI.
+  addURI(testURI);
+
+  // If history tries to notify us, we'll either crash because the Link will
+  // have been deleted (we are the only thing holding a reference to it), or our
+  // expect_no_visit call back will produce a failure.  Either way, the test
+  // will be reported as a failure.
+
+  // Run the next test.
+  run_next_test();
+}
+
+void
+test_new_visit_notifies_waiting_Link()
+{
+  // Create our test Link.  The callback function will release the reference we
+  // have on the link.
+  RefPtr<Link> link = new mock_Link(expect_visit);
+
+  // Now, register our content node to be notified.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->RegisterVisitedCallback(testURI, link);
+  do_check_success(rv);
+
+  // Add ourselves to history.
+  addURI(testURI);
+
+  // Note: test will continue upon notification.
+}
+
+void
+test_RegisterVisitedCallback_returns_before_notifying()
+{
+  // Add a URI so that it's already in history.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  addURI(testURI);
+
+  // Create our test Link.
+  RefPtr<Link> link = new mock_Link(expect_no_visit);
+
+  // Now, register our content node to be notified.  It should not be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->RegisterVisitedCallback(testURI, link);
+  do_check_success(rv);
+
+  // Remove ourselves as an observer.  We would have failed if we had been
+  // notified.
+  rv = history->UnregisterVisitedCallback(testURI, link);
+  do_check_success(rv);
+
+  run_next_test();
+}
+
+namespace test_observer_topic_dispatched_helpers {
+  #define URI_VISITED "visited"
+  #define URI_NOT_VISITED "not visited"
+  #define URI_VISITED_RESOLUTION_TOPIC "visited-status-resolution"
+  class statusObserver final : public nsIObserver
+  {
+    ~statusObserver() {}
+
+  public:
+    NS_DECL_ISUPPORTS
+
+    statusObserver(nsIURI* aURI,
+                   const bool aExpectVisit,
+                   bool& _notified)
+    : mURI(aURI)
+    , mExpectVisit(aExpectVisit)
+    , mNotified(_notified)
+    {
+      nsCOMPtr<nsIObserverService> observerService =
+        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+      do_check_true(observerService);
+      (void)observerService->AddObserver(this,
+                                         URI_VISITED_RESOLUTION_TOPIC,
+                                         false);
+    }
+
+    NS_IMETHOD Observe(nsISupports* aSubject,
+                       const char* aTopic,
+                       const char16_t* aData) override
+    {
+      // Make sure we got notified of the right topic.
+      do_check_false(strcmp(aTopic, URI_VISITED_RESOLUTION_TOPIC));
+
+      // If this isn't for our URI, do not do anything.
+      nsCOMPtr<nsIURI> notifiedURI = do_QueryInterface(aSubject);
+      do_check_true(notifiedURI);
+
+      bool isOurURI;
+      nsresult rv = notifiedURI->Equals(mURI, &isOurURI);
+      do_check_success(rv);
+      if (!isOurURI) {
+        return NS_OK;
+      }
+
+      // Check that we have either the visited or not visited string.
+      bool visited = !!NS_LITERAL_STRING(URI_VISITED).Equals(aData);
+      bool notVisited = !!NS_LITERAL_STRING(URI_NOT_VISITED).Equals(aData);
+      do_check_true(visited || notVisited);
+
+      // Check to make sure we got the state we expected.
+      do_check_eq(visited, mExpectVisit);
+
+      // Indicate that we've been notified.
+      mNotified = true;
+
+      // Remove ourselves as an observer.
+      nsCOMPtr<nsIObserverService> observerService =
+        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+      (void)observerService->RemoveObserver(this,
+                                            URI_VISITED_RESOLUTION_TOPIC);
+      return NS_OK;
+    }
+  private:
+    nsCOMPtr<nsIURI> mURI;
+    const bool mExpectVisit;
+    bool& mNotified;
+  };
+  NS_IMPL_ISUPPORTS(
+    statusObserver,
+    nsIObserver
+  )
+} // namespace test_observer_topic_dispatched_helpers
+void
+test_observer_topic_dispatched()
+{
+  using namespace test_observer_topic_dispatched_helpers;
+
+  // Create two URIs, making sure only one is in history.
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+  nsCOMPtr<nsIURI> notVisitedURI = new_test_uri();
+  bool urisEqual;
+  nsresult rv = visitedURI->Equals(notVisitedURI, &urisEqual);
+  do_check_success(rv);
+  do_check_false(urisEqual);
+  addURI(visitedURI);
+
+  // Need two Link objects as well - one for each URI.
+  RefPtr<Link> visitedLink = new mock_Link(expect_visit, false);
+  RefPtr<Link> visitedLinkCopy = visitedLink;
+  RefPtr<Link> notVisitedLink = new mock_Link(expect_no_visit);
+
+  // Add the right observers for the URIs to check results.
+  bool visitedNotified = false;
+  nsCOMPtr<nsIObserver> visitedObs =
+    new statusObserver(visitedURI, true, visitedNotified);
+  bool notVisitedNotified = false;
+  nsCOMPtr<nsIObserver> unvisitedObs =
+    new statusObserver(notVisitedURI, false, notVisitedNotified);
+
+  // Register our Links to be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  rv = history->RegisterVisitedCallback(visitedURI, visitedLink);
+  do_check_success(rv);
+  rv = history->RegisterVisitedCallback(notVisitedURI, notVisitedLink);
+  do_check_success(rv);
+
+  // Spin the event loop as long as we have not been properly notified.
+  while (!visitedNotified || !notVisitedNotified) {
+    (void)NS_ProcessNextEvent();
+  }
+
+  // Unregister our observer that would not have been released.
+  rv = history->UnregisterVisitedCallback(notVisitedURI, notVisitedLink);
+  do_check_success(rv);
+
+  run_next_test();
+}
+
+void
+test_visituri_inserts()
+{
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  history->VisitURI(visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL);
+
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  do_get_place(visitedURI, place);
+
+  do_check_true(place.id > 0);
+  do_check_false(place.hidden);
+  do_check_false(place.typed);
+  do_check_eq(place.visitCount, 1);
+
+  run_next_test();
+}
+
+void
+test_visituri_updates()
+{
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+  RefPtr<VisitURIObserver> finisher;
+
+  history->VisitURI(visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL);
+  finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  history->VisitURI(visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL);
+  finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  do_get_place(visitedURI, place);
+
+  do_check_eq(place.visitCount, 2);
+
+  run_next_test();
+}
+
+void
+test_visituri_preserves_shown_and_typed()
+{
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  history->VisitURI(visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL);
+  // this simulates the uri visit happening in a frame.  Normally frame
+  // transitions would be hidden unless it was previously loaded top-level
+  history->VisitURI(visitedURI, lastURI, 0);
+
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver(2);
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  do_get_place(visitedURI, place);
+  do_check_false(place.hidden);
+
+  run_next_test();
+}
+
+void
+test_visituri_creates_visit()
+{
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  history->VisitURI(visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL);
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  VisitRecord visit;
+  do_get_place(visitedURI, place);
+  do_get_lastVisit(place.id, visit);
+
+  do_check_true(visit.id > 0);
+  do_check_eq(visit.lastVisitId, 0);
+  do_check_eq(visit.transitionType, nsINavHistoryService::TRANSITION_LINK);
+
+  run_next_test();
+}
+
+void
+test_visituri_transition_typed()
+{
+  nsCOMPtr<nsINavHistoryService> navHistory = do_get_NavHistory();
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  navHistory->MarkPageAsTyped(visitedURI);
+  history->VisitURI(visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL);
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  VisitRecord visit;
+  do_get_place(visitedURI, place);
+  do_get_lastVisit(place.id, visit);
+
+  do_check_true(visit.transitionType == nsINavHistoryService::TRANSITION_TYPED);
+
+  run_next_test();
+}
+
+void
+test_visituri_transition_embed()
+{
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  history->VisitURI(visitedURI, lastURI, 0);
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  VisitRecord visit;
+  do_get_place(visitedURI, place);
+  do_get_lastVisit(place.id, visit);
+
+  do_check_eq(place.id, 0);
+  do_check_eq(visit.id, 0);
+
+  run_next_test();
+}
+
+void
+test_new_visit_adds_place_guid()
+{
+  // First, add a visit and wait.  This will also add a place.
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->VisitURI(visitedURI, nullptr,
+                                  mozilla::IHistory::TOP_LEVEL);
+  do_check_success(rv);
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  // Check that we have a guid for our visit.
+  PlaceRecord place;
+  do_get_place(visitedURI, place);
+  do_check_eq(place.visitCount, 1);
+  do_check_eq(place.guid.Length(), 12);
+
+  run_next_test();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// IPC-only Tests
+
+void
+test_two_null_links_same_uri()
+{
+  // Tests that we do not crash when we have had two nullptr Links passed to
+  // RegisterVisitedCallback and then the visit occurs (bug 607469).  This only
+  // happens in IPC builds.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->RegisterVisitedCallback(testURI, nullptr);
+  do_check_success(rv);
+  rv = history->RegisterVisitedCallback(testURI, nullptr);
+  do_check_success(rv);
+
+  rv = history->VisitURI(testURI, nullptr, mozilla::IHistory::TOP_LEVEL);
+  do_check_success(rv);
+
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  run_next_test();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// Test Harness
+
+/**
+ * Note: for tests marked "Order Important!", please see the test for details.
+ */
+Test gTests[] = {
+  TEST(test_set_places_enabled), // Must come first!
+  TEST(test_wait_checkpoint), // Must come second!
+  TEST(test_unvisited_does_not_notify_part1), // Order Important!
+  TEST(test_visited_notifies),
+  TEST(test_unvisited_does_not_notify_part2), // Order Important!
+  TEST(test_same_uri_notifies_both),
+  TEST(test_unregistered_visited_does_not_notify), // Order Important!
+  TEST(test_new_visit_notifies_waiting_Link),
+  TEST(test_RegisterVisitedCallback_returns_before_notifying),
+  TEST(test_observer_topic_dispatched),
+  TEST(test_visituri_inserts),
+  TEST(test_visituri_updates),
+  TEST(test_visituri_preserves_shown_and_typed),
+  TEST(test_visituri_creates_visit),
+  TEST(test_visituri_transition_typed),
+  TEST(test_visituri_transition_embed),
+  TEST(test_new_visit_adds_place_guid),
+
+  // The rest of these tests are tests that are only run in IPC builds.
+  TEST(test_two_null_links_same_uri),
+};
+
+const char* file = __FILE__;
+#define TEST_NAME "IHistory"
+#define TEST_FILE file
+#include "places_test_harness_tail.h"
diff --git a/toolkit/components/places/tests/expiration/.eslintrc.js b/toolkit/components/places/tests/expiration/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/expiration/head_expiration.js b/toolkit/components/places/tests/expiration/head_expiration.js
new file mode 100644
index 000000000..2be4af307
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/head_expiration.js
@@ -0,0 +1,124 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+// Import common head.
+{
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
+
+// Put any other stuff relative to this test folder below.
+
+
+// Simulates an expiration at shutdown.
+function shutdownExpiration()
+{
+  let expire = Cc["@mozilla.org/places/expiration;1"].getService(Ci.nsIObserver);
+  expire.observe(null, "places-will-close-connection", null);
+}
+
+
+/**
+ * Causes expiration component to start, otherwise it would wait for the first
+ * history notification.
+ */
+function force_expiration_start() {
+  Cc["@mozilla.org/places/expiration;1"]
+    .getService(Ci.nsIObserver)
+    .observe(null, "testing-mode", null);
+}
+
+
+/**
+ * Forces an expiration run.
+ *
+ * @param [optional] aLimit
+ *        Limit for the expiration.  Pass -1 for unlimited.
+ *        Any other non-positive value will just expire orphans.
+ *
+ * @return {Promise}
+ * @resolves When expiration finishes.
+ * @rejects Never.
+ */
+function promiseForceExpirationStep(aLimit) {
+  let promise = promiseTopicObserved(PlacesUtils.TOPIC_EXPIRATION_FINISHED);
+  let expire = Cc["@mozilla.org/places/expiration;1"].getService(Ci.nsIObserver);
+  expire.observe(null, "places-debug-start-expiration", aLimit);
+  return promise;
+}
+
+
+/**
+ * Expiration preferences helpers.
+ */
+
+function setInterval(aNewInterval) {
+  Services.prefs.setIntPref("places.history.expiration.interval_seconds", aNewInterval);
+}
+function getInterval() {
+  return Services.prefs.getIntPref("places.history.expiration.interval_seconds");
+}
+function clearInterval() {
+  try {
+    Services.prefs.clearUserPref("places.history.expiration.interval_seconds");
+  }
+  catch (ex) {}
+}
+
+
+function setMaxPages(aNewMaxPages) {
+  Services.prefs.setIntPref("places.history.expiration.max_pages", aNewMaxPages);
+}
+function getMaxPages() {
+  return Services.prefs.getIntPref("places.history.expiration.max_pages");
+}
+function clearMaxPages() {
+  try {
+    Services.prefs.clearUserPref("places.history.expiration.max_pages");
+  }
+  catch (ex) {}
+}
+
+
+function setHistoryEnabled(aHistoryEnabled) {
+  Services.prefs.setBoolPref("places.history.enabled", aHistoryEnabled);
+}
+function getHistoryEnabled() {
+  return Services.prefs.getBoolPref("places.history.enabled");
+}
+function clearHistoryEnabled() {
+  try {
+    Services.prefs.clearUserPref("places.history.enabled");
+  }
+  catch (ex) {}
+}
+
+/**
+ * Returns a PRTime in the past usable to add expirable visits.
+ *
+ * param [optional] daysAgo
+ *       Expiration ignores any visit added in the last 7 days, so by default
+ *       this will be set to 7.
+ * @note to be safe against DST issues we go back one day more.
+ */
+function getExpirablePRTime(daysAgo = 7) {
+  let dateObj = new Date();
+  // Normalize to midnight
+  dateObj.setHours(0);
+  dateObj.setMinutes(0);
+  dateObj.setSeconds(0);
+  dateObj.setMilliseconds(0);
+  dateObj = new Date(dateObj.getTime() - (daysAgo + 1) * 86400000);
+  return dateObj.getTime() * 1000;
+}
diff --git a/toolkit/components/places/tests/expiration/test_analyze_runs.js b/toolkit/components/places/tests/expiration/test_analyze_runs.js
new file mode 100644
index 000000000..1a84e1b38
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_analyze_runs.js
@@ -0,0 +1,118 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Constants
+
+const TOPIC_AUTOCOMPLETE_FEEDBACK_INCOMING = "autocomplete-will-enter-text";
+
+// Helpers
+
+/**
+ * Ensures that we have no data in the tables created by ANALYZE.
+ */
+function clearAnalyzeData() {
+  let db = DBConn();
+  if (!db.tableExists("sqlite_stat1")) {
+    return;
+  }
+  db.executeSimpleSQL("DELETE FROM sqlite_stat1");
+}
+
+/**
+ * Checks that we ran ANALYZE on the specified table.
+ *
+ * @param aTableName
+ *        The table to check if ANALYZE was ran.
+ * @param aRan
+ *        True if it was expected to run, false otherwise
+ */
+function do_check_analyze_ran(aTableName, aRan) {
+  let db = DBConn();
+  do_check_true(db.tableExists("sqlite_stat1"));
+  let stmt = db.createStatement("SELECT idx FROM sqlite_stat1 WHERE tbl = :table");
+  stmt.params.table = aTableName;
+  try {
+    if (aRan) {
+      do_check_true(stmt.executeStep());
+      do_check_neq(stmt.row.idx, null);
+    }
+    else {
+      do_check_false(stmt.executeStep());
+    }
+  }
+  finally {
+    stmt.finalize();
+  }
+}
+
+// Tests
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* init_tests() {
+  const TEST_URI = NetUtil.newURI("http://mozilla.org/");
+  const TEST_TITLE = "This is a test";
+
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    title: TEST_TITLE,
+    url: TEST_URI
+  });
+  yield PlacesTestUtils.addVisits(TEST_URI);
+  let thing = {
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompleteInput,
+                                           Ci.nsIAutoCompletePopup,
+                                           Ci.nsIAutoCompleteController]),
+    get popup() { return thing; },
+    get controller() { return thing; },
+    popupOpen: true,
+    selectedIndex: 0,
+    getValueAt: function() { return TEST_URI.spec; },
+    searchString: TEST_TITLE,
+  };
+  Services.obs.notifyObservers(thing, TOPIC_AUTOCOMPLETE_FEEDBACK_INCOMING,
+                               null);
+});
+
+add_task(function* test_timed() {
+  clearAnalyzeData();
+
+  // Set a low interval and wait for the timed expiration to start.
+  let promise = promiseTopicObserved(PlacesUtils.TOPIC_EXPIRATION_FINISHED);
+  setInterval(3);
+  yield promise;
+  setInterval(3600);
+
+  do_check_analyze_ran("moz_places", false);
+  do_check_analyze_ran("moz_bookmarks", false);
+  do_check_analyze_ran("moz_historyvisits", false);
+  do_check_analyze_ran("moz_inputhistory", true);
+});
+
+add_task(function* test_debug() {
+  clearAnalyzeData();
+
+  yield promiseForceExpirationStep(1);
+
+  do_check_analyze_ran("moz_places", true);
+  do_check_analyze_ran("moz_bookmarks", true);
+  do_check_analyze_ran("moz_historyvisits", true);
+  do_check_analyze_ran("moz_inputhistory", true);
+});
+
+add_task(function* test_clear_history() {
+  clearAnalyzeData();
+
+  let promise = promiseTopicObserved(PlacesUtils.TOPIC_EXPIRATION_FINISHED);
+  let listener = Cc["@mozilla.org/places/expiration;1"]
+                 .getService(Ci.nsINavHistoryObserver);
+  listener.onClearHistory();
+  yield promise;
+
+  do_check_analyze_ran("moz_places", true);
+  do_check_analyze_ran("moz_bookmarks", false);
+  do_check_analyze_ran("moz_historyvisits", true);
+  do_check_analyze_ran("moz_inputhistory", true);
+});
diff --git a/toolkit/components/places/tests/expiration/test_annos_expire_history.js b/toolkit/components/places/tests/expiration/test_annos_expire_history.js
new file mode 100644
index 000000000..f9568a769
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_annos_expire_history.js
@@ -0,0 +1,93 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * EXPIRE_WITH_HISTORY annotations should be expired when a page has no more
+ * visits, even if the page still exists in the database.
+ * This expiration policy is only valid for page annotations.
+ */
+
+var as = Cc["@mozilla.org/browser/annotation-service;1"].
+         getService(Ci.nsIAnnotationService);
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_annos_expire_history() {
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  // Expire all expirable pages.
+  setMaxPages(0);
+
+  // Add some visited page and a couple expire with history annotations for each.
+  let now = getExpirablePRTime();
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://page_anno." + i + ".mozilla.org/");
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now++ });
+    as.setPageAnnotation(pageURI, "page_expire1", "test", 0, as.EXPIRE_WITH_HISTORY);
+    as.setPageAnnotation(pageURI, "page_expire2", "test", 0, as.EXPIRE_WITH_HISTORY);
+  }
+
+  let pages = as.getPagesWithAnnotation("page_expire1");
+  do_check_eq(pages.length, 5);
+  pages = as.getPagesWithAnnotation("page_expire2");
+  do_check_eq(pages.length, 5);
+
+  // Add some bookmarked page and a couple session annotations for each.
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://item_anno." + i + ".mozilla.org/");
+    // We also add a visit before bookmarking.
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now++ });
+    yield PlacesUtils.bookmarks.insert({
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+      url: pageURI,
+      title: null
+    });
+    // Notice we use page annotations here, items annotations can't use this
+    // kind of expiration policy.
+    as.setPageAnnotation(pageURI, "item_persist1", "test", 0, as.EXPIRE_WITH_HISTORY);
+    as.setPageAnnotation(pageURI, "item_persist2", "test", 0, as.EXPIRE_WITH_HISTORY);
+  }
+
+  let items = as.getPagesWithAnnotation("item_persist1");
+  do_check_eq(items.length, 5);
+  items = as.getPagesWithAnnotation("item_persist2");
+  do_check_eq(items.length, 5);
+
+  // Add other visited page and a couple expire with history annotations for each.
+  // We won't expire these visits, so the annotations should survive.
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://persist_page_anno." + i + ".mozilla.org/");
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now++ });
+    as.setPageAnnotation(pageURI, "page_persist1", "test", 0, as.EXPIRE_WITH_HISTORY);
+    as.setPageAnnotation(pageURI, "page_persist2", "test", 0, as.EXPIRE_WITH_HISTORY);
+  }
+
+  pages = as.getPagesWithAnnotation("page_persist1");
+  do_check_eq(pages.length, 5);
+  pages = as.getPagesWithAnnotation("page_persist2");
+  do_check_eq(pages.length, 5);
+
+  // Expire all visits for the first 5 pages and the bookmarks.
+  yield promiseForceExpirationStep(10);
+
+  pages = as.getPagesWithAnnotation("page_expire1");
+  do_check_eq(pages.length, 0);
+  pages = as.getPagesWithAnnotation("page_expire2");
+  do_check_eq(pages.length, 0);
+  items = as.getItemsWithAnnotation("item_persist1");
+  do_check_eq(items.length, 0);
+  items = as.getItemsWithAnnotation("item_persist2");
+  do_check_eq(items.length, 0);
+  pages = as.getPagesWithAnnotation("page_persist1");
+  do_check_eq(pages.length, 5);
+  pages = as.getPagesWithAnnotation("page_persist2");
+  do_check_eq(pages.length, 5);
+});
diff --git a/toolkit/components/places/tests/expiration/test_annos_expire_never.js b/toolkit/components/places/tests/expiration/test_annos_expire_never.js
new file mode 100644
index 000000000..f146f25b5
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_annos_expire_never.js
@@ -0,0 +1,95 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * EXPIRE_NEVER annotations should be expired when a page is removed from the
+ * database.
+ * If the annotation is a page annotation this will happen when the page is
+ * expired, namely when the page has no visits and is not bookmarked.
+ * Otherwise if it's an item annotation the annotation will be expired when
+ * the item is removed, thus expiration won't handle this case at all.
+ */
+
+var as = Cc["@mozilla.org/browser/annotation-service;1"].
+         getService(Ci.nsIAnnotationService);
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_annos_expire_never() {
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  // Expire all expirable pages.
+  setMaxPages(0);
+
+  // Add some visited page and a couple expire never annotations for each.
+  let now = getExpirablePRTime();
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://page_anno." + i + ".mozilla.org/");
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now++ });
+    as.setPageAnnotation(pageURI, "page_expire1", "test", 0, as.EXPIRE_NEVER);
+    as.setPageAnnotation(pageURI, "page_expire2", "test", 0, as.EXPIRE_NEVER);
+  }
+
+  let pages = as.getPagesWithAnnotation("page_expire1");
+  do_check_eq(pages.length, 5);
+  pages = as.getPagesWithAnnotation("page_expire2");
+  do_check_eq(pages.length, 5);
+
+  // Add some bookmarked page and a couple expire never annotations for each.
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://item_anno." + i + ".mozilla.org/");
+    // We also add a visit before bookmarking.
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now++ });
+    let bm = yield PlacesUtils.bookmarks.insert({
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+      url: pageURI,
+      title: null
+    });
+    let id = yield PlacesUtils.promiseItemId(bm.guid);
+    as.setItemAnnotation(id, "item_persist1", "test", 0, as.EXPIRE_NEVER);
+    as.setItemAnnotation(id, "item_persist2", "test", 0, as.EXPIRE_NEVER);
+  }
+
+  let items = as.getItemsWithAnnotation("item_persist1");
+  do_check_eq(items.length, 5);
+  items = as.getItemsWithAnnotation("item_persist2");
+  do_check_eq(items.length, 5);
+
+  // Add other visited page and a couple expire never annotations for each.
+  // We won't expire these visits, so the annotations should survive.
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://persist_page_anno." + i + ".mozilla.org/");
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now++ });
+    as.setPageAnnotation(pageURI, "page_persist1", "test", 0, as.EXPIRE_NEVER);
+    as.setPageAnnotation(pageURI, "page_persist2", "test", 0, as.EXPIRE_NEVER);
+  }
+
+  pages = as.getPagesWithAnnotation("page_persist1");
+  do_check_eq(pages.length, 5);
+  pages = as.getPagesWithAnnotation("page_persist2");
+  do_check_eq(pages.length, 5);
+
+  // Expire all visits for the first 5 pages and the bookmarks.
+  yield promiseForceExpirationStep(10);
+
+  pages = as.getPagesWithAnnotation("page_expire1");
+  do_check_eq(pages.length, 0);
+  pages = as.getPagesWithAnnotation("page_expire2");
+  do_check_eq(pages.length, 0);
+  items = as.getItemsWithAnnotation("item_persist1");
+  do_check_eq(items.length, 5);
+  items = as.getItemsWithAnnotation("item_persist2");
+  do_check_eq(items.length, 5);
+  pages = as.getPagesWithAnnotation("page_persist1");
+  do_check_eq(pages.length, 5);
+  pages = as.getPagesWithAnnotation("page_persist2");
+  do_check_eq(pages.length, 5);
+});
diff --git a/toolkit/components/places/tests/expiration/test_annos_expire_policy.js b/toolkit/components/places/tests/expiration/test_annos_expire_policy.js
new file mode 100644
index 000000000..2fe50e13e
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_annos_expire_policy.js
@@ -0,0 +1,189 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * Annotations can be set with a timed expiration policy.
+ * Supported policies are:
+ * - EXPIRE_DAYS: annotation would be expired after 7 days
+ * - EXPIRE_WEEKS: annotation would be expired after 30 days
+ * - EXPIRE_MONTHS: annotation would be expired after 180 days
+ */
+
+var as = Cc["@mozilla.org/browser/annotation-service;1"].
+         getService(Ci.nsIAnnotationService);
+
+/**
+ * Creates an aged annotation.
+ *
+ * @param aIdentifier Either a page url or an item id.
+ * @param aIdentifier Name of the annotation.
+ * @param aValue Value for the annotation.
+ * @param aExpirePolicy Expiration policy of the annotation.
+ * @param aAgeInDays Age in days of the annotation.
+ * @param [optional] aLastModifiedAgeInDays Age in days of the annotation, for lastModified.
+ */
+var now = Date.now();
+function add_old_anno(aIdentifier, aName, aValue, aExpirePolicy,
+                      aAgeInDays, aLastModifiedAgeInDays) {
+  let expireDate = (now - (aAgeInDays * 86400 * 1000)) * 1000;
+  let lastModifiedDate = 0;
+  if (aLastModifiedAgeInDays)
+    lastModifiedDate = (now - (aLastModifiedAgeInDays * 86400 * 1000)) * 1000;
+
+  let sql;
+  if (typeof(aIdentifier) == "number") {
+    // Item annotation.
+    as.setItemAnnotation(aIdentifier, aName, aValue, 0, aExpirePolicy);
+    // Update dateAdded for the last added annotation.
+    sql = "UPDATE moz_items_annos SET dateAdded = :expire_date, lastModified = :last_modified " +
+          "WHERE id = (SELECT id FROM moz_items_annos " +
+                      "WHERE item_id = :id " +
+                      "ORDER BY dateAdded DESC LIMIT 1)";
+  }
+  else if (aIdentifier instanceof Ci.nsIURI) {
+    // Page annotation.
+    as.setPageAnnotation(aIdentifier, aName, aValue, 0, aExpirePolicy);
+    // Update dateAdded for the last added annotation.
+    sql = "UPDATE moz_annos SET dateAdded = :expire_date, lastModified = :last_modified " +
+          "WHERE id = (SELECT a.id FROM moz_annos a " +
+                      "LEFT JOIN moz_places h on h.id = a.place_id " +
+                      "WHERE h.url_hash = hash(:id) AND h.url = :id " +
+                      "ORDER BY a.dateAdded DESC LIMIT 1)";
+  }
+  else
+    do_throw("Wrong identifier type");
+
+  let stmt = DBConn().createStatement(sql);
+  stmt.params.id = (typeof(aIdentifier) == "number") ? aIdentifier
+                                                     : aIdentifier.spec;
+  stmt.params.expire_date = expireDate;
+  stmt.params.last_modified = lastModifiedDate;
+  try {
+    stmt.executeStep();
+  }
+  finally {
+    stmt.finalize();
+  }
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_annos_expire_policy() {
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  // Expire all expirable pages.
+  setMaxPages(0);
+
+  let now_specific_to_test = getExpirablePRTime();
+  // Add some bookmarked page and timed annotations for each.
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://item_anno." + i + ".mozilla.org/");
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now_specific_to_test++ });
+    let bm = yield PlacesUtils.bookmarks.insert({
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+      url: pageURI,
+      title: null
+    });
+    let id = yield PlacesUtils.promiseItemId(bm.guid);
+    // Add a 6 days old anno.
+    add_old_anno(id, "persist_days", "test", as.EXPIRE_DAYS, 6);
+    // Add a 8 days old anno, modified 5 days ago.
+    add_old_anno(id, "persist_lm_days", "test", as.EXPIRE_DAYS, 8, 6);
+    // Add a 8 days old anno.
+    add_old_anno(id, "expire_days", "test", as.EXPIRE_DAYS, 8);
+
+    // Add a 29 days old anno.
+    add_old_anno(id, "persist_weeks", "test", as.EXPIRE_WEEKS, 29);
+    // Add a 31 days old anno, modified 29 days ago.
+    add_old_anno(id, "persist_lm_weeks", "test", as.EXPIRE_WEEKS, 31, 29);
+    // Add a 31 days old anno.
+    add_old_anno(id, "expire_weeks", "test", as.EXPIRE_WEEKS, 31);
+
+    // Add a 179 days old anno.
+    add_old_anno(id, "persist_months", "test", as.EXPIRE_MONTHS, 179);
+    // Add a 181 days old anno, modified 179 days ago.
+    add_old_anno(id, "persist_lm_months", "test", as.EXPIRE_MONTHS, 181, 179);
+    // Add a 181 days old anno.
+    add_old_anno(id, "expire_months", "test", as.EXPIRE_MONTHS, 181);
+
+    // Add a 6 days old anno.
+    add_old_anno(pageURI, "persist_days", "test", as.EXPIRE_DAYS, 6);
+    // Add a 8 days old anno, modified 5 days ago.
+    add_old_anno(pageURI, "persist_lm_days", "test", as.EXPIRE_DAYS, 8, 6);
+    // Add a 8 days old anno.
+    add_old_anno(pageURI, "expire_days", "test", as.EXPIRE_DAYS, 8);
+
+    // Add a 29 days old anno.
+    add_old_anno(pageURI, "persist_weeks", "test", as.EXPIRE_WEEKS, 29);
+    // Add a 31 days old anno, modified 29 days ago.
+    add_old_anno(pageURI, "persist_lm_weeks", "test", as.EXPIRE_WEEKS, 31, 29);
+    // Add a 31 days old anno.
+    add_old_anno(pageURI, "expire_weeks", "test", as.EXPIRE_WEEKS, 31);
+
+    // Add a 179 days old anno.
+    add_old_anno(pageURI, "persist_months", "test", as.EXPIRE_MONTHS, 179);
+    // Add a 181 days old anno, modified 179 days ago.
+    add_old_anno(pageURI, "persist_lm_months", "test", as.EXPIRE_MONTHS, 181, 179);
+    // Add a 181 days old anno.
+    add_old_anno(pageURI, "expire_months", "test", as.EXPIRE_MONTHS, 181);
+  }
+
+  // Add some visited page and timed annotations for each.
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://page_anno." + i + ".mozilla.org/");
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now_specific_to_test++ });
+    // Add a 6 days old anno.
+    add_old_anno(pageURI, "persist_days", "test", as.EXPIRE_DAYS, 6);
+    // Add a 8 days old anno, modified 5 days ago.
+    add_old_anno(pageURI, "persist_lm_days", "test", as.EXPIRE_DAYS, 8, 6);
+    // Add a 8 days old anno.
+    add_old_anno(pageURI, "expire_days", "test", as.EXPIRE_DAYS, 8);
+
+    // Add a 29 days old anno.
+    add_old_anno(pageURI, "persist_weeks", "test", as.EXPIRE_WEEKS, 29);
+    // Add a 31 days old anno, modified 29 days ago.
+    add_old_anno(pageURI, "persist_lm_weeks", "test", as.EXPIRE_WEEKS, 31, 29);
+    // Add a 31 days old anno.
+    add_old_anno(pageURI, "expire_weeks", "test", as.EXPIRE_WEEKS, 31);
+
+    // Add a 179 days old anno.
+    add_old_anno(pageURI, "persist_months", "test", as.EXPIRE_MONTHS, 179);
+    // Add a 181 days old anno, modified 179 days ago.
+    add_old_anno(pageURI, "persist_lm_months", "test", as.EXPIRE_MONTHS, 181, 179);
+    // Add a 181 days old anno.
+    add_old_anno(pageURI, "expire_months", "test", as.EXPIRE_MONTHS, 181);
+  }
+
+  // Expire all visits for the bookmarks.
+  yield promiseForceExpirationStep(5);
+
+  ["expire_days", "expire_weeks", "expire_months"].forEach(function(aAnno) {
+    let pages = as.getPagesWithAnnotation(aAnno);
+    do_check_eq(pages.length, 0);
+  });
+
+  ["expire_days", "expire_weeks", "expire_months"].forEach(function(aAnno) {
+    let items = as.getItemsWithAnnotation(aAnno);
+    do_check_eq(items.length, 0);
+  });
+
+  ["persist_days", "persist_lm_days", "persist_weeks", "persist_lm_weeks",
+   "persist_months", "persist_lm_months"].forEach(function(aAnno) {
+    let pages = as.getPagesWithAnnotation(aAnno);
+    do_check_eq(pages.length, 10);
+  });
+
+  ["persist_days", "persist_lm_days", "persist_weeks", "persist_lm_weeks",
+   "persist_months", "persist_lm_months"].forEach(function(aAnno) {
+    let items = as.getItemsWithAnnotation(aAnno);
+    do_check_eq(items.length, 5);
+  });
+});
diff --git a/toolkit/components/places/tests/expiration/test_annos_expire_session.js b/toolkit/components/places/tests/expiration/test_annos_expire_session.js
new file mode 100644
index 000000000..68c995f80
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_annos_expire_session.js
@@ -0,0 +1,83 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * Session annotations should be expired when browsing session ends.
+ */
+
+var as = Cc["@mozilla.org/browser/annotation-service;1"].
+         getService(Ci.nsIAnnotationService);
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_annos_expire_session() {
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  // Add some visited page and a couple session annotations for each.
+  let now = Date.now() * 1000;
+  for (let i = 0; i < 10; i++) {
+    let pageURI = uri("http://session_page_anno." + i + ".mozilla.org/");
+    yield PlacesTestUtils.addVisits({ uri: pageURI, visitDate: now++ });
+    as.setPageAnnotation(pageURI, "test1", "test", 0, as.EXPIRE_SESSION);
+    as.setPageAnnotation(pageURI, "test2", "test", 0, as.EXPIRE_SESSION);
+  }
+
+  // Add some bookmarked page and a couple session annotations for each.
+  for (let i = 0; i < 10; i++) {
+    let pageURI = uri("http://session_item_anno." + i + ".mozilla.org/");
+    let bm = yield PlacesUtils.bookmarks.insert({
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+      url: pageURI,
+      title: null
+    });
+    let id = yield PlacesUtils.promiseItemId(bm.guid);
+    as.setItemAnnotation(id, "test1", "test", 0, as.EXPIRE_SESSION);
+    as.setItemAnnotation(id, "test2", "test", 0, as.EXPIRE_SESSION);
+  }
+
+
+  let pages = as.getPagesWithAnnotation("test1");
+  do_check_eq(pages.length, 10);
+  pages = as.getPagesWithAnnotation("test2");
+  do_check_eq(pages.length, 10);
+  let items = as.getItemsWithAnnotation("test1");
+  do_check_eq(items.length, 10);
+  items = as.getItemsWithAnnotation("test2");
+  do_check_eq(items.length, 10);
+
+  let deferred = Promise.defer();
+  waitForConnectionClosed(function() {
+    let stmt = DBConn(true).createAsyncStatement(
+      `SELECT id FROM moz_annos
+       UNION ALL
+       SELECT id FROM moz_items_annos
+       WHERE expiration = :expiration`
+    );
+    stmt.params.expiration = as.EXPIRE_SESSION;
+    stmt.executeAsync({
+      handleResult: function(aResultSet) {
+        dump_table("moz_annos");
+        dump_table("moz_items_annos");
+        do_throw("Should not find any leftover session annotations");
+      },
+      handleError: function(aError) {
+        do_throw("Error code " + aError.result + " with message '" +
+                 aError.message + "' returned.");
+      },
+      handleCompletion: function(aReason) {
+        do_check_eq(aReason, Ci.mozIStorageStatementCallback.REASON_FINISHED);
+        deferred.resolve();
+      }
+    });
+    stmt.finalize();
+  });
+  yield deferred.promise;
+});
diff --git a/toolkit/components/places/tests/expiration/test_clearHistory.js b/toolkit/components/places/tests/expiration/test_clearHistory.js
new file mode 100644
index 000000000..d3879d7ad
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_clearHistory.js
@@ -0,0 +1,157 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * History.clear() should expire everything but bookmarked pages and valid
+ * annos.
+ */
+
+var hs = PlacesUtils.history;
+var as = PlacesUtils.annotations;
+
+/**
+ * Creates an aged annotation.
+ *
+ * @param aIdentifier Either a page url or an item id.
+ * @param aIdentifier Name of the annotation.
+ * @param aValue Value for the annotation.
+ * @param aExpirePolicy Expiration policy of the annotation.
+ * @param aAgeInDays Age in days of the annotation.
+ * @param [optional] aLastModifiedAgeInDays Age in days of the annotation, for lastModified.
+ */
+var now = Date.now();
+function add_old_anno(aIdentifier, aName, aValue, aExpirePolicy,
+                      aAgeInDays, aLastModifiedAgeInDays) {
+  let expireDate = (now - (aAgeInDays * 86400 * 1000)) * 1000;
+  let lastModifiedDate = 0;
+  if (aLastModifiedAgeInDays)
+    lastModifiedDate = (now - (aLastModifiedAgeInDays * 86400 * 1000)) * 1000;
+
+  let sql;
+  if (typeof(aIdentifier) == "number") {
+    // Item annotation.
+    as.setItemAnnotation(aIdentifier, aName, aValue, 0, aExpirePolicy);
+    // Update dateAdded for the last added annotation.
+    sql = "UPDATE moz_items_annos SET dateAdded = :expire_date, lastModified = :last_modified " +
+          "WHERE id = ( " +
+            "SELECT a.id FROM moz_items_annos a " +
+            "JOIN moz_anno_attributes n ON n.id = a.anno_attribute_id " +
+            "WHERE a.item_id = :id " +
+              "AND n.name = :anno_name " +
+            "ORDER BY a.dateAdded DESC LIMIT 1 " +
+          ")";
+  }
+  else if (aIdentifier instanceof Ci.nsIURI) {
+    // Page annotation.
+    as.setPageAnnotation(aIdentifier, aName, aValue, 0, aExpirePolicy);
+    // Update dateAdded for the last added annotation.
+    sql = "UPDATE moz_annos SET dateAdded = :expire_date, lastModified = :last_modified " +
+          "WHERE id = ( " +
+            "SELECT a.id FROM moz_annos a " +
+            "JOIN moz_anno_attributes n ON n.id = a.anno_attribute_id " +
+            "JOIN moz_places h on h.id = a.place_id " +
+            "WHERE h.url_hash = hash(:id) AND h.url = :id " +
+            "AND n.name = :anno_name " +
+            "ORDER BY a.dateAdded DESC LIMIT 1 " +
+          ")";
+  }
+  else
+    do_throw("Wrong identifier type");
+
+  let stmt = DBConn().createStatement(sql);
+  stmt.params.id = (typeof(aIdentifier) == "number") ? aIdentifier
+                                                     : aIdentifier.spec;
+  stmt.params.expire_date = expireDate;
+  stmt.params.last_modified = lastModifiedDate;
+  stmt.params.anno_name = aName;
+  try {
+    stmt.executeStep();
+  }
+  finally {
+    stmt.finalize();
+  }
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_historyClear() {
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  // Expire all expirable pages.
+  setMaxPages(0);
+
+  // Add some bookmarked page with visit and annotations.
+  for (let i = 0; i < 5; i++) {
+    let pageURI = uri("http://item_anno." + i + ".mozilla.org/");
+    // This visit will be expired.
+    yield PlacesTestUtils.addVisits({ uri: pageURI });
+    let bm = yield PlacesUtils.bookmarks.insert({
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+      url: pageURI,
+      title: null
+    });
+    let id = yield PlacesUtils.promiseItemId(bm.guid);
+    // Will persist because it's an EXPIRE_NEVER item anno.
+    as.setItemAnnotation(id, "persist", "test", 0, as.EXPIRE_NEVER);
+    // Will persist because the page is bookmarked.
+    as.setPageAnnotation(pageURI, "persist", "test", 0, as.EXPIRE_NEVER);
+    // All EXPIRE_SESSION annotations are expected to expire on clear history.
+    as.setItemAnnotation(id, "expire_session", "test", 0, as.EXPIRE_SESSION);
+    as.setPageAnnotation(pageURI, "expire_session", "test", 0, as.EXPIRE_SESSION);
+    // Annotations with timed policy will expire regardless bookmarked status.
+    add_old_anno(id, "expire_days", "test", as.EXPIRE_DAYS, 8);
+    add_old_anno(id, "expire_weeks", "test", as.EXPIRE_WEEKS, 31);
+    add_old_anno(id, "expire_months", "test", as.EXPIRE_MONTHS, 181);
+    add_old_anno(pageURI, "expire_days", "test", as.EXPIRE_DAYS, 8);
+    add_old_anno(pageURI, "expire_weeks", "test", as.EXPIRE_WEEKS, 31);
+    add_old_anno(pageURI, "expire_months", "test", as.EXPIRE_MONTHS, 181);
+  }
+
+  // Add some visited page and annotations for each.
+  for (let i = 0; i < 5; i++) {
+    // All page annotations related to these expired pages are expected to
+    // expire as well.
+    let pageURI = uri("http://page_anno." + i + ".mozilla.org/");
+    yield PlacesTestUtils.addVisits({ uri: pageURI });
+    as.setPageAnnotation(pageURI, "expire", "test", 0, as.EXPIRE_NEVER);
+    as.setPageAnnotation(pageURI, "expire_session", "test", 0, as.EXPIRE_SESSION);
+    add_old_anno(pageURI, "expire_days", "test", as.EXPIRE_DAYS, 8);
+    add_old_anno(pageURI, "expire_weeks", "test", as.EXPIRE_WEEKS, 31);
+    add_old_anno(pageURI, "expire_months", "test", as.EXPIRE_MONTHS, 181);
+  }
+
+  // Expire all visits for the bookmarks
+  yield PlacesUtils.history.clear();
+
+  ["expire_days", "expire_weeks", "expire_months", "expire_session",
+   "expire"].forEach(function(aAnno) {
+    let pages = as.getPagesWithAnnotation(aAnno);
+    do_check_eq(pages.length, 0);
+  });
+
+  ["expire_days", "expire_weeks", "expire_months", "expire_session",
+   "expire"].forEach(function(aAnno) {
+    let items = as.getItemsWithAnnotation(aAnno);
+    do_check_eq(items.length, 0);
+  });
+
+  let pages = as.getPagesWithAnnotation("persist");
+  do_check_eq(pages.length, 5);
+
+  let items = as.getItemsWithAnnotation("persist");
+  do_check_eq(items.length, 5);
+
+  for (let itemId of items) {
+    // Check item exists.
+    let guid = yield PlacesUtils.promiseItemGuid(itemId);
+    do_check_true((yield PlacesUtils.bookmarks.fetch({guid})), "item exists");
+  }
+});
diff --git a/toolkit/components/places/tests/expiration/test_debug_expiration.js b/toolkit/components/places/tests/expiration/test_debug_expiration.js
new file mode 100644
index 000000000..456c03363
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_debug_expiration.js
@@ -0,0 +1,225 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * What this is aimed to test:
+ *
+ * Expiration can be manually triggered through a debug topic, but that should
+ * only expire orphan entries, unless -1 is passed as limit.
+ */
+
+var gNow = getExpirablePRTime(60);
+
+add_task(function* test_expire_orphans()
+{
+  // Add visits to 2 pages and force a orphan expiration. Visits should survive.
+  yield PlacesTestUtils.addVisits({
+    uri: uri("http://page1.mozilla.org/"),
+    visitDate: gNow++
+  });
+  yield PlacesTestUtils.addVisits({
+    uri: uri("http://page2.mozilla.org/"),
+    visitDate: gNow++
+  });
+  // Create a orphan place.
+  let bm = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: "http://page3.mozilla.org/",
+    title: ""
+  });
+  yield PlacesUtils.bookmarks.remove(bm);
+
+  // Expire now.
+  yield promiseForceExpirationStep(0);
+
+  // Check that visits survived.
+  do_check_eq(visits_in_database("http://page1.mozilla.org/"), 1);
+  do_check_eq(visits_in_database("http://page2.mozilla.org/"), 1);
+  do_check_false(page_in_database("http://page3.mozilla.org/"));
+
+  // Clean up.
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_expire_orphans_optionalarg()
+{
+  // Add visits to 2 pages and force a orphan expiration. Visits should survive.
+  yield PlacesTestUtils.addVisits({
+    uri: uri("http://page1.mozilla.org/"),
+    visitDate: gNow++
+  });
+  yield PlacesTestUtils.addVisits({
+    uri: uri("http://page2.mozilla.org/"),
+    visitDate: gNow++
+  });
+  // Create a orphan place.
+  let bm = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: "http://page3.mozilla.org/",
+    title: ""
+  });
+  yield PlacesUtils.bookmarks.remove(bm);
+
+  // Expire now.
+  yield promiseForceExpirationStep();
+
+  // Check that visits survived.
+  do_check_eq(visits_in_database("http://page1.mozilla.org/"), 1);
+  do_check_eq(visits_in_database("http://page2.mozilla.org/"), 1);
+  do_check_false(page_in_database("http://page3.mozilla.org/"));
+
+  // Clean up.
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_expire_limited()
+{
+  yield PlacesTestUtils.addVisits([
+    { // Should be expired cause it's the oldest visit
+      uri: "http://old.mozilla.org/",
+      visitDate: gNow++
+    },
+    { // Should not be expired cause we limit 1
+      uri: "http://new.mozilla.org/",
+      visitDate: gNow++
+    },
+  ]);
+
+  // Expire now.
+  yield promiseForceExpirationStep(1);
+
+  // Check that newer visit survived.
+  do_check_eq(visits_in_database("http://new.mozilla.org/"), 1);
+  // Other visits should have been expired.
+  do_check_false(page_in_database("http://old.mozilla.org/"));
+
+  // Clean up.
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_expire_limited_longurl()
+{
+  let longurl = "http://long.mozilla.org/" + "a".repeat(232);
+  yield PlacesTestUtils.addVisits([
+    { // Should be expired cause it's the oldest visit
+      uri: "http://old.mozilla.org/",
+      visitDate: gNow++
+    },
+    { // Should be expired cause it's a long url older than 60 days.
+      uri: longurl,
+      visitDate: gNow++
+    },
+    { // Should not be expired cause younger than 60 days.
+      uri: longurl,
+      visitDate: getExpirablePRTime(58)
+    }
+  ]);
+
+  yield promiseForceExpirationStep(1);
+
+  // Check that some visits survived.
+  do_check_eq(visits_in_database(longurl), 1);
+  // Other visits should have been expired.
+  do_check_false(page_in_database("http://old.mozilla.org/"));
+
+  // Clean up.
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_expire_limited_exoticurl()
+{
+  yield PlacesTestUtils.addVisits([
+    { // Should be expired cause it's the oldest visit
+      uri: "http://old.mozilla.org/",
+      visitDate: gNow++
+    },
+    { // Should be expired cause it's a long url older than 60 days.
+      uri: "http://download.mozilla.org",
+      visitDate: gNow++,
+      transition: 7
+    },
+    { // Should not be expired cause younger than 60 days.
+      uri: "http://nonexpirable-download.mozilla.org",
+      visitDate: getExpirablePRTime(58),
+      transition: 7
+    }
+  ]);
+
+  yield promiseForceExpirationStep(1);
+
+  // Check that some visits survived.
+  do_check_eq(visits_in_database("http://nonexpirable-download.mozilla.org/"), 1);
+  // The visits are gone, the url is not yet, cause we limited the expiration
+  // to one entry, and we already removed http://old.mozilla.org/.
+  // The page normally would be expired by the next expiration run.
+  do_check_eq(visits_in_database("http://download.mozilla.org/"), 0);
+  // Other visits should have been expired.
+  do_check_false(page_in_database("http://old.mozilla.org/"));
+
+  // Clean up.
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_expire_unlimited()
+{
+  let longurl = "http://long.mozilla.org/" + "a".repeat(232);
+  yield PlacesTestUtils.addVisits([
+    {
+      uri: "http://old.mozilla.org/",
+      visitDate: gNow++
+    },
+    {
+      uri: "http://new.mozilla.org/",
+      visitDate: gNow++
+    },
+    // Add expirable visits.
+    {
+      uri: "http://download.mozilla.org/",
+      visitDate: gNow++,
+      transition: PlacesUtils.history.TRANSITION_DOWNLOAD
+    },
+    {
+      uri: longurl,
+      visitDate: gNow++
+    },
+
+    // Add non-expirable visits
+    {
+      uri: "http://nonexpirable.mozilla.org/",
+      visitDate: getExpirablePRTime(5)
+    },
+    {
+      uri: "http://nonexpirable-download.mozilla.org/",
+      visitDate: getExpirablePRTime(5),
+      transition: PlacesUtils.history.TRANSITION_DOWNLOAD
+    },
+    {
+      uri: longurl,
+      visitDate: getExpirablePRTime(5)
+    }
+  ]);
+
+  yield promiseForceExpirationStep(-1);
+
+  // Check that some visits survived.
+  do_check_eq(visits_in_database("http://nonexpirable.mozilla.org/"), 1);
+  do_check_eq(visits_in_database("http://nonexpirable-download.mozilla.org/"), 1);
+  do_check_eq(visits_in_database(longurl), 1);
+  // Other visits should have been expired.
+  do_check_false(page_in_database("http://old.mozilla.org/"));
+  do_check_false(page_in_database("http://download.mozilla.org/"));
+  do_check_false(page_in_database("http://new.mozilla.org/"));
+
+  // Clean up.
+  yield PlacesTestUtils.clearHistory();
+});
+
+function run_test()
+{
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+  // Set maxPages to a low value, so it's easy to go over it.
+  setMaxPages(1);
+
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/expiration/test_idle_daily.js b/toolkit/components/places/tests/expiration/test_idle_daily.js
new file mode 100644
index 000000000..05e5a8125
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_idle_daily.js
@@ -0,0 +1,21 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that expiration runs on idle-daily.
+
+function run_test() {
+  do_test_pending();
+
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  Services.obs.addObserver(function observeExpiration(aSubject, aTopic, aData) {
+    Services.obs.removeObserver(observeExpiration,
+                                PlacesUtils.TOPIC_EXPIRATION_FINISHED);
+    do_test_finished();
+  }, PlacesUtils.TOPIC_EXPIRATION_FINISHED, false);
+
+  let expire = Cc["@mozilla.org/places/expiration;1"].
+               getService(Ci.nsIObserver);
+  expire.observe(null, "idle-daily", null);
+}
diff --git a/toolkit/components/places/tests/expiration/test_notifications.js b/toolkit/components/places/tests/expiration/test_notifications.js
new file mode 100644
index 000000000..06e585c6c
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_notifications.js
@@ -0,0 +1,38 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * Ensure that History (through category cache) notifies us just once.
+ */
+
+var os = Cc["@mozilla.org/observer-service;1"].
+         getService(Ci.nsIObserverService);
+
+var gObserver = {
+  notifications: 0,
+  observe: function(aSubject, aTopic, aData) {
+    this.notifications++;
+  }
+};
+os.addObserver(gObserver, PlacesUtils.TOPIC_EXPIRATION_FINISHED, false);
+
+function run_test() {
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  PlacesTestUtils.clearHistory();
+
+  do_timeout(2000, check_result);
+  do_test_pending();
+}
+
+function check_result() {
+  os.removeObserver(gObserver, PlacesUtils.TOPIC_EXPIRATION_FINISHED);
+  do_check_eq(gObserver.notifications, 1);
+  do_test_finished();
+}
diff --git a/toolkit/components/places/tests/expiration/test_notifications_onDeleteURI.js b/toolkit/components/places/tests/expiration/test_notifications_onDeleteURI.js
new file mode 100644
index 000000000..f70cd2b58
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_notifications_onDeleteURI.js
@@ -0,0 +1,114 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * Expiring a full page should fire an onDeleteURI notification.
+ */
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+
+var tests = [
+
+  { desc: "Add 1 bookmarked page.",
+    addPages: 1,
+    addBookmarks: 1,
+    expectedNotifications: 0, // No expirable pages.
+  },
+
+  { desc: "Add 2 pages, 1 bookmarked.",
+    addPages: 2,
+    addBookmarks: 1,
+    expectedNotifications: 1, // Only one expirable page.
+  },
+
+  { desc: "Add 10 pages, none bookmarked.",
+    addPages: 10,
+    addBookmarks: 0,
+    expectedNotifications: 10, // Will expire everything.
+  },
+
+  { desc: "Add 10 pages, all bookmarked.",
+    addPages: 10,
+    addBookmarks: 10,
+    expectedNotifications: 0, // No expirable pages.
+  },
+
+];
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_notifications_onDeleteURI() {
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  // Expire anything that is expirable.
+  setMaxPages(0);
+
+  for (let testIndex = 1; testIndex <= tests.length; testIndex++) {
+    let currentTest = tests[testIndex -1];
+    print("\nTEST " + testIndex + ": " + currentTest.desc);
+    currentTest.receivedNotifications = 0;
+
+    // Setup visits.
+    let now = getExpirablePRTime();
+    for (let i = 0; i < currentTest.addPages; i++) {
+      let page = "http://" + testIndex + "." + i + ".mozilla.org/";
+      yield PlacesTestUtils.addVisits({ uri: uri(page), visitDate: now++ });
+    }
+
+    // Setup bookmarks.
+    currentTest.bookmarks = [];
+    for (let i = 0; i < currentTest.addBookmarks; i++) {
+      let page = "http://" + testIndex + "." + i + ".mozilla.org/";
+      yield PlacesUtils.bookmarks.insert({
+        parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+        title: null,
+        url: page
+      });
+      currentTest.bookmarks.push(page);
+    }
+
+    // Observe history.
+    historyObserver = {
+      onBeginUpdateBatch: function PEX_onBeginUpdateBatch() {},
+      onEndUpdateBatch: function PEX_onEndUpdateBatch() {},
+      onClearHistory: function() {},
+      onVisit: function() {},
+      onTitleChanged: function() {},
+      onDeleteURI: function(aURI, aGUID, aReason) {
+        currentTest.receivedNotifications++;
+        // Check this uri was not bookmarked.
+        do_check_eq(currentTest.bookmarks.indexOf(aURI.spec), -1);
+        do_check_valid_places_guid(aGUID);
+        do_check_eq(aReason, Ci.nsINavHistoryObserver.REASON_EXPIRED);
+      },
+      onPageChanged: function() {},
+      onDeleteVisits: function(aURI, aTime) { },
+    };
+    hs.addObserver(historyObserver, false);
+
+    // Expire now.
+    yield promiseForceExpirationStep(-1);
+
+    hs.removeObserver(historyObserver, false);
+
+    do_check_eq(currentTest.receivedNotifications,
+                currentTest.expectedNotifications);
+
+    // Clean up.
+    yield PlacesUtils.bookmarks.eraseEverything();
+    yield PlacesTestUtils.clearHistory();
+  }
+
+  clearMaxPages();
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
diff --git a/toolkit/components/places/tests/expiration/test_notifications_onDeleteVisits.js b/toolkit/components/places/tests/expiration/test_notifications_onDeleteVisits.js
new file mode 100644
index 000000000..e6b99ff8b
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_notifications_onDeleteVisits.js
@@ -0,0 +1,142 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * Expiring only visits for a page, but not the full page, should fire an
+ * onDeleteVisits notification.
+ */
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+
+var tests = [
+
+  { desc: "Add 1 bookmarked page.",
+    addPages: 1,
+    visitsPerPage: 1,
+    addBookmarks: 1,
+    limitExpiration: -1,
+    expectedNotifications: 1, // Will expire visits for 1 page.
+  },
+
+  { desc: "Add 2 pages, 1 bookmarked.",
+    addPages: 2,
+    visitsPerPage: 1,
+    addBookmarks: 1,
+    limitExpiration: -1,
+    expectedNotifications: 1, // Will expire visits for 1 page.
+  },
+
+  { desc: "Add 10 pages, none bookmarked.",
+    addPages: 10,
+    visitsPerPage: 1,
+    addBookmarks: 0,
+    limitExpiration: -1,
+    expectedNotifications: 0, // Will expire only full pages.
+  },
+
+  { desc: "Add 10 pages, all bookmarked.",
+    addPages: 10,
+    visitsPerPage: 1,
+    addBookmarks: 10,
+    limitExpiration: -1,
+    expectedNotifications: 10, // Will expire visist for all pages.
+  },
+
+  { desc: "Add 10 pages with lot of visits, none bookmarked.",
+    addPages: 10,
+    visitsPerPage: 10,
+    addBookmarks: 0,
+    limitExpiration: 10,
+    expectedNotifications: 10, // Will expire 1 visist for each page, but won't
+  },                           // expire pages since they still have visits.
+
+];
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_notifications_onDeleteVisits() {
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  // Expire anything that is expirable.
+  setMaxPages(0);
+
+  for (let testIndex = 1; testIndex <= tests.length; testIndex++) {
+    let currentTest = tests[testIndex -1];
+    print("\nTEST " + testIndex + ": " + currentTest.desc);
+    currentTest.receivedNotifications = 0;
+
+    // Setup visits.
+    let timeInMicroseconds = getExpirablePRTime(8);
+
+    function newTimeInMicroseconds() {
+      timeInMicroseconds = timeInMicroseconds + 1000;
+      return timeInMicroseconds;
+    }
+
+    for (let j = 0; j < currentTest.visitsPerPage; j++) {
+      for (let i = 0; i < currentTest.addPages; i++) {
+        let page = "http://" + testIndex + "." + i + ".mozilla.org/";
+        yield PlacesTestUtils.addVisits({ uri: uri(page), visitDate: newTimeInMicroseconds() });
+      }
+    }
+
+    // Setup bookmarks.
+    currentTest.bookmarks = [];
+    for (let i = 0; i < currentTest.addBookmarks; i++) {
+      let page = "http://" + testIndex + "." + i + ".mozilla.org/";
+      yield PlacesUtils.bookmarks.insert({
+        parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+        title: null,
+        url: page
+      });
+      currentTest.bookmarks.push(page);
+    }
+
+    // Observe history.
+    historyObserver = {
+      onBeginUpdateBatch: function PEX_onBeginUpdateBatch() {},
+      onEndUpdateBatch: function PEX_onEndUpdateBatch() {},
+      onClearHistory: function() {},
+      onVisit: function() {},
+      onTitleChanged: function() {},
+      onDeleteURI: function(aURI, aGUID, aReason) {
+        // Check this uri was not bookmarked.
+        do_check_eq(currentTest.bookmarks.indexOf(aURI.spec), -1);
+        do_check_valid_places_guid(aGUID);
+        do_check_eq(aReason, Ci.nsINavHistoryObserver.REASON_EXPIRED);
+      },
+      onPageChanged: function() {},
+      onDeleteVisits: function(aURI, aTime, aGUID, aReason) {
+        currentTest.receivedNotifications++;
+        do_check_guid_for_uri(aURI, aGUID);
+        do_check_eq(aReason, Ci.nsINavHistoryObserver.REASON_EXPIRED);
+      },
+    };
+    hs.addObserver(historyObserver, false);
+
+    // Expire now.
+    yield promiseForceExpirationStep(currentTest.limitExpiration);
+
+    hs.removeObserver(historyObserver, false);
+
+    do_check_eq(currentTest.receivedNotifications,
+                currentTest.expectedNotifications);
+
+    // Clean up.
+    yield PlacesUtils.bookmarks.eraseEverything();
+    yield PlacesTestUtils.clearHistory();
+  }
+
+  clearMaxPages();
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
diff --git a/toolkit/components/places/tests/expiration/test_outdated_analyze.js b/toolkit/components/places/tests/expiration/test_outdated_analyze.js
new file mode 100644
index 000000000..9cf61f06b
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_outdated_analyze.js
@@ -0,0 +1,72 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that expiration executes ANALYZE when statistics are outdated.
+
+const TEST_URL = "http://www.mozilla.org/";
+
+XPCOMUtils.defineLazyServiceGetter(this, "gHistory",
+                                   "@mozilla.org/browser/history;1",
+                                   "mozIAsyncHistory");
+
+/**
+ * Object that represents a mozIVisitInfo object.
+ *
+ * @param [optional] aTransitionType
+ *        The transition type of the visit.  Defaults to TRANSITION_LINK if not
+ *        provided.
+ * @param [optional] aVisitTime
+ *        The time of the visit.  Defaults to now if not provided.
+ */
+function VisitInfo(aTransitionType, aVisitTime) {
+  this.transitionType =
+    aTransitionType === undefined ? TRANSITION_LINK : aTransitionType;
+  this.visitDate = aVisitTime || Date.now() * 1000;
+}
+
+function run_test() {
+  do_test_pending();
+
+  // Init expiration before "importing".
+  force_expiration_start();
+
+  // Add a bunch of pages (at laast IMPORT_PAGES_THRESHOLD pages).
+  let places = [];
+  for (let i = 0; i < 100; i++) {
+    places.push({
+      uri: NetUtil.newURI(TEST_URL + i),
+      title: "Title" + i,
+      visits: [new VisitInfo]
+    });
+  }
+  gHistory.updatePlaces(places);
+
+  // Set interval to a small value to expire on it.
+  setInterval(1); // 1s
+
+  Services.obs.addObserver(function observeExpiration(aSubject, aTopic, aData) {
+    Services.obs.removeObserver(observeExpiration,
+                                PlacesUtils.TOPIC_EXPIRATION_FINISHED);
+
+    // Check that statistica are up-to-date.
+    let stmt = DBConn().createAsyncStatement(
+      "SELECT (SELECT COUNT(*) FROM moz_places) - "
+      +        "(SELECT SUBSTR(stat,1,LENGTH(stat)-2) FROM sqlite_stat1 "
+      +         "WHERE idx = 'moz_places_url_hashindex')"
+    );
+    stmt.executeAsync({
+      handleResult: function(aResultSet) {
+        let row = aResultSet.getNextRow();
+        this._difference = row.getResultByIndex(0);
+      },
+      handleError: function(aError) {
+        do_throw("Unexpected error (" + aError.result + "): " + aError.message);
+      },
+      handleCompletion: function(aReason) {
+        do_check_true(this._difference === 0);
+        do_test_finished();
+      }
+    });
+    stmt.finalize();
+  }, PlacesUtils.TOPIC_EXPIRATION_FINISHED, false);
+}
diff --git a/toolkit/components/places/tests/expiration/test_pref_interval.js b/toolkit/components/places/tests/expiration/test_pref_interval.js
new file mode 100644
index 000000000..44c749d7a
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_pref_interval.js
@@ -0,0 +1,61 @@
+/**
+ * What this is aimed to test:
+ *
+ * Expiration relies on an interval, that is user-preffable setting
+ * "places.history.expiration.interval_seconds".
+ * On pref change it will stop current interval timer and fire a new one,
+ * that will obey the new value.
+ * If the pref is set to a number <= 0 we will use the default value.
+ */
+
+// Default timer value for expiration in seconds.  Must have same value as
+// PREF_INTERVAL_SECONDS_NOTSET in nsPlacesExpiration.
+const DEFAULT_TIMER_DELAY_SECONDS = 3 * 60;
+
+// Sync this with the const value in the component.
+const EXPIRE_AGGRESSIVITY_MULTIPLIER = 3;
+
+var tests = [
+
+  // This test should be the first, so the interval won't be influenced by
+  // status of history.
+  { desc: "Set interval to 1s.",
+    interval: 1,
+    expectedTimerDelay: 1
+  },
+
+  { desc: "Set interval to a negative value.",
+    interval: -1,
+    expectedTimerDelay: DEFAULT_TIMER_DELAY_SECONDS
+  },
+
+  { desc: "Set interval to 0.",
+    interval: 0,
+    expectedTimerDelay: DEFAULT_TIMER_DELAY_SECONDS
+  },
+
+  { desc: "Set interval to a large value.",
+    interval: 100,
+    expectedTimerDelay: 100
+  },
+
+];
+
+add_task(function* test() {
+  // The pref should not exist by default.
+  Assert.throws(() => getInterval());
+
+  // Force the component, so it will start observing preferences.
+  force_expiration_start();
+
+  for (let currentTest of tests) {
+    print(currentTest.desc);
+    let promise = promiseTopicObserved("test-interval-changed");
+    setInterval(currentTest.interval);
+    let [, data] = yield promise;
+    Assert.equal(data, currentTest.expectedTimerDelay * EXPIRE_AGGRESSIVITY_MULTIPLIER);
+  }
+
+  clearInterval();
+});
+
diff --git a/toolkit/components/places/tests/expiration/test_pref_maxpages.js b/toolkit/components/places/tests/expiration/test_pref_maxpages.js
new file mode 100644
index 000000000..6a237afbb
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/test_pref_maxpages.js
@@ -0,0 +1,124 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * What this is aimed to test:
+ *
+ * Expiration will obey to hardware spec, but user can set a custom maximum
+ * number of pages to retain, to restrict history, through
+ * "places.history.expiration.max_pages".
+ * This limit is used at next expiration run.
+ * If the pref is set to a number < 0 we will use the default value.
+ */
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+
+var tests = [
+
+  { desc: "Set max_pages to a negative value, with 1 page.",
+    maxPages: -1,
+    addPages: 1,
+    expectedNotifications: 0, // Will ignore and won't expire anything.
+  },
+
+  { desc: "Set max_pages to 0.",
+    maxPages: 0,
+    addPages: 1,
+    expectedNotifications: 1,
+  },
+
+  { desc: "Set max_pages to 0, with 2 pages.",
+    maxPages: 0,
+    addPages: 2,
+    expectedNotifications: 2, // Will expire everything.
+  },
+
+  // Notice if we are over limit we do a full step of expiration.  So we ensure
+  // that we will expire if we are over the limit, but we don't ensure that we
+  // will expire exactly up to the limit.  Thus in this case we expire
+  // everything.
+  { desc: "Set max_pages to 1 with 2 pages.",
+    maxPages: 1,
+    addPages: 2,
+    expectedNotifications: 2, // Will expire everything (in this case).
+  },
+
+  { desc: "Set max_pages to 10, with 9 pages.",
+    maxPages: 10,
+    addPages: 9,
+    expectedNotifications: 0, // We are at the limit, won't expire anything.
+  },
+
+  { desc: "Set max_pages to 10 with 10 pages.",
+    maxPages: 10,
+    addPages: 10,
+    expectedNotifications: 0, // We are below the limit, won't expire anything.
+  },
+];
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_pref_maxpages() {
+  // The pref should not exist by default.
+  try {
+    getMaxPages();
+    do_throw("interval pref should not exist by default");
+  }
+  catch (ex) {}
+
+  // Set interval to a large value so we don't expire on it.
+  setInterval(3600); // 1h
+
+  for (let testIndex = 1; testIndex <= tests.length; testIndex++) {
+    let currentTest = tests[testIndex -1];
+    print("\nTEST " + testIndex + ": " + currentTest.desc);
+    currentTest.receivedNotifications = 0;
+
+    // Setup visits.
+    let now = getExpirablePRTime();
+    for (let i = 0; i < currentTest.addPages; i++) {
+      let page = "http://" + testIndex + "." + i + ".mozilla.org/";
+      yield PlacesTestUtils.addVisits({ uri: uri(page), visitDate: now++ });
+    }
+
+    // Observe history.
+    let historyObserver = {
+      onBeginUpdateBatch: function PEX_onBeginUpdateBatch() {},
+      onEndUpdateBatch: function PEX_onEndUpdateBatch() {},
+      onClearHistory: function() {},
+      onVisit: function() {},
+      onTitleChanged: function() {},
+      onDeleteURI: function(aURI) {
+        print("onDeleteURI " + aURI.spec);
+        currentTest.receivedNotifications++;
+      },
+      onPageChanged: function() {},
+      onDeleteVisits: function(aURI, aTime) {
+        print("onDeleteVisits " + aURI.spec + " " + aTime);
+      },
+    };
+    hs.addObserver(historyObserver, false);
+
+    setMaxPages(currentTest.maxPages);
+
+    // Expire now.
+    yield promiseForceExpirationStep(-1);
+
+    hs.removeObserver(historyObserver, false);
+
+    do_check_eq(currentTest.receivedNotifications,
+                currentTest.expectedNotifications);
+
+    // Clean up.
+    yield PlacesTestUtils.clearHistory();
+  }
+
+  clearMaxPages();
+  yield PlacesTestUtils.clearHistory();
+});
diff --git a/toolkit/components/places/tests/expiration/xpcshell.ini b/toolkit/components/places/tests/expiration/xpcshell.ini
new file mode 100644
index 000000000..cda7ac052
--- /dev/null
+++ b/toolkit/components/places/tests/expiration/xpcshell.ini
@@ -0,0 +1,22 @@
+[DEFAULT]
+head = head_expiration.js
+tail = 
+skip-if = toolkit == 'android'
+
+[test_analyze_runs.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_annos_expire_history.js]
+[test_annos_expire_never.js]
+[test_annos_expire_policy.js]
+[test_annos_expire_session.js]
+[test_clearHistory.js]
+[test_debug_expiration.js]
+[test_idle_daily.js]
+[test_notifications.js]
+[test_notifications_onDeleteURI.js]
+[test_notifications_onDeleteVisits.js]
+[test_outdated_analyze.js]
+[test_pref_interval.js]
+[test_pref_maxpages.js]
+skip-if = os == "linux" # bug 1284083
diff --git a/toolkit/components/places/tests/favicons/.eslintrc.js b/toolkit/components/places/tests/favicons/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/favicons/expected-favicon-big32.jpg.png b/toolkit/components/places/tests/favicons/expected-favicon-big32.jpg.png
new file mode 100644
index 000000000..723008771
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/expected-favicon-big32.jpg.png
diff --git a/toolkit/components/places/tests/favicons/expected-favicon-big4.jpg.png b/toolkit/components/places/tests/favicons/expected-favicon-big4.jpg.png
new file mode 100644
index 000000000..9932c18fb
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/expected-favicon-big4.jpg.png
diff --git a/toolkit/components/places/tests/favicons/expected-favicon-big48.ico.png b/toolkit/components/places/tests/favicons/expected-favicon-big48.ico.png
new file mode 100644
index 000000000..9f16bef43
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/expected-favicon-big48.ico.png
diff --git a/toolkit/components/places/tests/favicons/expected-favicon-big64.png.png b/toolkit/components/places/tests/favicons/expected-favicon-big64.png.png
new file mode 100644
index 000000000..ed158d161
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/expected-favicon-big64.png.png
diff --git a/toolkit/components/places/tests/favicons/expected-favicon-scale160x3.jpg.png b/toolkit/components/places/tests/favicons/expected-favicon-scale160x3.jpg.png
new file mode 100644
index 000000000..585c9e897
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/expected-favicon-scale160x3.jpg.png
diff --git a/toolkit/components/places/tests/favicons/expected-favicon-scale3x160.jpg.png b/toolkit/components/places/tests/favicons/expected-favicon-scale3x160.jpg.png
new file mode 100644
index 000000000..e07dabc79
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/expected-favicon-scale3x160.jpg.png
diff --git a/toolkit/components/places/tests/favicons/favicon-big16.ico b/toolkit/components/places/tests/favicons/favicon-big16.ico
new file mode 100644
index 000000000..d44438903
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-big16.ico
diff --git a/toolkit/components/places/tests/favicons/favicon-big32.jpg b/toolkit/components/places/tests/favicons/favicon-big32.jpg
new file mode 100644
index 000000000..b2131bf0c
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-big32.jpg
diff --git a/toolkit/components/places/tests/favicons/favicon-big4.jpg b/toolkit/components/places/tests/favicons/favicon-big4.jpg
new file mode 100644
index 000000000..b84fcd35a
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-big4.jpg
diff --git a/toolkit/components/places/tests/favicons/favicon-big48.ico b/toolkit/components/places/tests/favicons/favicon-big48.ico
new file mode 100644
index 000000000..f22522411
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-big48.ico
diff --git a/toolkit/components/places/tests/favicons/favicon-big64.png b/toolkit/components/places/tests/favicons/favicon-big64.png
new file mode 100644
index 000000000..2756cf0cb
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-big64.png
diff --git a/toolkit/components/places/tests/favicons/favicon-normal16.png b/toolkit/components/places/tests/favicons/favicon-normal16.png
new file mode 100644
index 000000000..62b69a3d0
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-normal16.png
diff --git a/toolkit/components/places/tests/favicons/favicon-normal32.png b/toolkit/components/places/tests/favicons/favicon-normal32.png
new file mode 100644
index 000000000..5535363c9
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-normal32.png
diff --git a/toolkit/components/places/tests/favicons/favicon-scale160x3.jpg b/toolkit/components/places/tests/favicons/favicon-scale160x3.jpg
new file mode 100644
index 000000000..422ee7ea0
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-scale160x3.jpg
diff --git a/toolkit/components/places/tests/favicons/favicon-scale3x160.jpg b/toolkit/components/places/tests/favicons/favicon-scale3x160.jpg
new file mode 100644
index 000000000..e8514966a
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/favicon-scale3x160.jpg
diff --git a/toolkit/components/places/tests/favicons/head_favicons.js b/toolkit/components/places/tests/favicons/head_favicons.js
new file mode 100644
index 000000000..cc81791e8
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/head_favicons.js
@@ -0,0 +1,105 @@
+/* -*- 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/. */
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+// Import common head.
+{
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
+
+// Put any other stuff relative to this test folder below.
+
+
+// This error icon must stay in sync with FAVICON_ERRORPAGE_URL in
+// nsIFaviconService.idl, aboutCertError.xhtml and netError.xhtml.
+const FAVICON_ERRORPAGE_URI =
+  NetUtil.newURI("chrome://global/skin/icons/warning-16.png");
+
+/**
+ * Waits for the first OnPageChanged notification for ATTRIBUTE_FAVICON, and
+ * verifies that it matches the expected page URI and associated favicon URI.
+ *
+ * This function also double-checks the GUID parameter of the notification.
+ *
+ * @param aExpectedPageURI
+ *        nsIURI object of the page whose favicon should change.
+ * @param aExpectedFaviconURI
+ *        nsIURI object of the newly associated favicon.
+ * @param aCallback
+ *        This function is called after the check finished.
+ */
+function waitForFaviconChanged(aExpectedPageURI, aExpectedFaviconURI,
+                               aCallback) {
+  let historyObserver = {
+    __proto__: NavHistoryObserver.prototype,
+    onPageChanged: function WFFC_onPageChanged(aURI, aWhat, aValue, aGUID) {
+      if (aWhat != Ci.nsINavHistoryObserver.ATTRIBUTE_FAVICON) {
+        return;
+      }
+      PlacesUtils.history.removeObserver(this);
+
+      do_check_true(aURI.equals(aExpectedPageURI));
+      do_check_eq(aValue, aExpectedFaviconURI.spec);
+      do_check_guid_for_uri(aURI, aGUID);
+      aCallback();
+    }
+  };
+  PlacesUtils.history.addObserver(historyObserver, false);
+}
+
+/**
+ * Checks that the favicon for the given page matches the provided data.
+ *
+ * @param aPageURI
+ *        nsIURI object for the page to check.
+ * @param aExpectedMimeType
+ *        Expected MIME type of the icon, for example "image/png".
+ * @param aExpectedData
+ *        Expected icon data, expressed as an array of byte values.
+ * @param aCallback
+ *        This function is called after the check finished.
+ */
+function checkFaviconDataForPage(aPageURI, aExpectedMimeType, aExpectedData,
+                                 aCallback) {
+  PlacesUtils.favicons.getFaviconDataForPage(aPageURI,
+    function (aURI, aDataLen, aData, aMimeType) {
+      do_check_eq(aExpectedMimeType, aMimeType);
+      do_check_true(compareArrays(aExpectedData, aData));
+      do_check_guid_for_uri(aPageURI);
+      aCallback();
+    });
+}
+
+/**
+ * Checks that the given page has no associated favicon.
+ *
+ * @param aPageURI
+ *        nsIURI object for the page to check.
+ * @param aCallback
+ *        This function is called after the check finished.
+ */
+function checkFaviconMissingForPage(aPageURI, aCallback) {
+  PlacesUtils.favicons.getFaviconURLForPage(aPageURI,
+    function (aURI, aDataLen, aData, aMimeType) {
+      do_check_true(aURI === null);
+      aCallback();
+    });
+}
+
+function promiseFaviconMissingForPage(aPageURI) {
+  return new Promise(resolve => checkFaviconMissingForPage(aPageURI, resolve));
+}
+
+function promiseFaviconChanged(aExpectedPageURI, aExpectedFaviconURI) {
+  return new Promise(resolve => waitForFaviconChanged(aExpectedPageURI, aExpectedFaviconURI, resolve));
+}
diff --git a/toolkit/components/places/tests/favicons/test_expireAllFavicons.js b/toolkit/components/places/tests/favicons/test_expireAllFavicons.js
new file mode 100644
index 000000000..c5d8edfdd
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_expireAllFavicons.js
@@ -0,0 +1,39 @@
+/**
+ * This file tests that favicons are correctly expired by expireAllFavicons.
+ */
+
+"use strict";
+
+const TEST_PAGE_URI = NetUtil.newURI("http://example.com/");
+const BOOKMARKED_PAGE_URI = NetUtil.newURI("http://example.com/bookmarked");
+
+add_task(function* test_expireAllFavicons() {
+  // Add a visited page.
+  yield PlacesTestUtils.addVisits({ uri: TEST_PAGE_URI, transition: TRANSITION_TYPED });
+
+  // Set a favicon for our test page.
+  yield promiseSetIconForPage(TEST_PAGE_URI, SMALLPNG_DATA_URI);
+
+  // Add a page with a bookmark.
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    url: BOOKMARKED_PAGE_URI,
+    title: "Test bookmark"
+  });
+
+  // Set a favicon for our bookmark.
+  yield promiseSetIconForPage(BOOKMARKED_PAGE_URI, SMALLPNG_DATA_URI);
+
+  // Start expiration only after data has been saved in the database.
+  let promise = promiseTopicObserved(PlacesUtils.TOPIC_FAVICONS_EXPIRED);
+  PlacesUtils.favicons.expireAllFavicons();
+  yield promise;
+
+  // Check that the favicons for the pages we added were removed.
+  yield promiseFaviconMissingForPage(TEST_PAGE_URI);
+  yield promiseFaviconMissingForPage(BOOKMARKED_PAGE_URI);
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/favicons/test_favicons_conversions.js b/toolkit/components/places/tests/favicons/test_favicons_conversions.js
new file mode 100644
index 000000000..fa0d332ec
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_favicons_conversions.js
@@ -0,0 +1,131 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests the image conversions done by the favicon service.
+ */
+
+// Globals
+
+// The pixel values we get on Windows are sometimes +/- 1 value compared to
+// other platforms, so we need to skip some image content tests.
+var isWindows = ("@mozilla.org/windows-registry-key;1" in Cc);
+
+/**
+ * Checks the conversion of the given test image file.
+ *
+ * @param aFileName
+ *        File that contains the favicon image, located in the test folder.
+ * @param aFileMimeType
+ *        MIME type of the image contained in the file.
+ * @param aFileLength
+ *        Expected length of the file.
+ * @param aExpectConversion
+ *        If false, the icon should be stored as is.  If true, the expected data
+ *        is loaded from a file named "expected-" + aFileName + ".png".
+ * @param aVaryOnWindows
+ *        Indicates that the content of the converted image can be different on
+ *        Windows and should not be checked on that platform.
+ * @param aCallback
+ *        This function is called after the check finished.
+ */
+function checkFaviconDataConversion(aFileName, aFileMimeType, aFileLength,
+                                    aExpectConversion, aVaryOnWindows,
+                                    aCallback) {
+  let pageURI = NetUtil.newURI("http://places.test/page/" + aFileName);
+  PlacesTestUtils.addVisits({ uri: pageURI, transition: TRANSITION_TYPED }).then(
+    function () {
+      let faviconURI = NetUtil.newURI("http://places.test/icon/" + aFileName);
+      let fileData = readFileOfLength(aFileName, aFileLength);
+
+      PlacesUtils.favicons.replaceFaviconData(faviconURI, fileData, fileData.length,
+                                              aFileMimeType);
+      PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI, faviconURI, true,
+        PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+        function CFDC_verify(aURI, aDataLen, aData, aMimeType) {
+          if (!aExpectConversion) {
+            do_check_true(compareArrays(aData, fileData));
+            do_check_eq(aMimeType, aFileMimeType);
+          } else {
+            if (!aVaryOnWindows || !isWindows) {
+              let expectedFile = do_get_file("expected-" + aFileName + ".png");
+              do_check_true(compareArrays(aData, readFileData(expectedFile)));
+            }
+            do_check_eq(aMimeType, "image/png");
+          }
+
+          aCallback();
+        }, Services.scriptSecurityManager.getSystemPrincipal());
+    });
+}
+
+// Tests
+
+function run_test() {
+  run_next_test();
+}
+
+add_test(function test_storing_a_normal_16x16_icon() {
+  // 16x16 png, 286 bytes.
+  // optimized: no
+  checkFaviconDataConversion("favicon-normal16.png", "image/png", 286,
+                             false, false, run_next_test);
+});
+
+add_test(function test_storing_a_normal_32x32_icon() {
+  // 32x32 png, 344 bytes.
+  // optimized: no
+  checkFaviconDataConversion("favicon-normal32.png", "image/png", 344,
+                             false, false, run_next_test);
+});
+
+add_test(function test_storing_a_big_16x16_icon() {
+  //  in: 16x16 ico, 1406 bytes.
+  // optimized: no
+  checkFaviconDataConversion("favicon-big16.ico", "image/x-icon", 1406,
+                             false, false, run_next_test);
+});
+
+add_test(function test_storing_an_oversize_4x4_icon() {
+  //  in: 4x4 jpg, 4751 bytes.
+  // optimized: yes
+  checkFaviconDataConversion("favicon-big4.jpg", "image/jpeg", 4751,
+                             true, false, run_next_test);
+});
+
+add_test(function test_storing_an_oversize_32x32_icon() {
+  //  in: 32x32 jpg, 3494 bytes.
+  // optimized: yes
+  checkFaviconDataConversion("favicon-big32.jpg", "image/jpeg", 3494,
+                             true, true, run_next_test);
+});
+
+add_test(function test_storing_an_oversize_48x48_icon() {
+  //  in: 48x48 ico, 56646 bytes.
+  // (howstuffworks.com icon, contains 13 icons with sizes from 16x16 to
+  // 48x48 in varying depths)
+  // optimized: yes
+  checkFaviconDataConversion("favicon-big48.ico", "image/x-icon", 56646,
+                             true, false, run_next_test);
+});
+
+add_test(function test_storing_an_oversize_64x64_icon() {
+  //  in: 64x64 png, 10698 bytes.
+  // optimized: yes
+  checkFaviconDataConversion("favicon-big64.png", "image/png", 10698,
+                             true, false, run_next_test);
+});
+
+add_test(function test_scaling_an_oversize_160x3_icon() {
+  //  in: 160x3 jpg, 5095 bytes.
+  // optimized: yes
+  checkFaviconDataConversion("favicon-scale160x3.jpg", "image/jpeg", 5095,
+                             true, false, run_next_test);
+});
+
+add_test(function test_scaling_an_oversize_3x160_icon() {
+  //  in: 3x160 jpg, 5059 bytes.
+  // optimized: yes
+  checkFaviconDataConversion("favicon-scale3x160.jpg", "image/jpeg", 5059,
+                             true, false, run_next_test);
+});
diff --git a/toolkit/components/places/tests/favicons/test_getFaviconDataForPage.js b/toolkit/components/places/tests/favicons/test_getFaviconDataForPage.js
new file mode 100644
index 000000000..73eea7436
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_getFaviconDataForPage.js
@@ -0,0 +1,57 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests getFaviconDataForPage.
+ */
+
+// Globals
+
+const FAVICON_URI = NetUtil.newURI(do_get_file("favicon-normal32.png"));
+const FAVICON_DATA = readFileData(do_get_file("favicon-normal32.png"));
+const FAVICON_MIMETYPE = "image/png";
+
+// Tests
+
+function run_test()
+{
+  // Check that the favicon loaded correctly before starting the actual tests.
+  do_check_eq(FAVICON_DATA.length, 344);
+  run_next_test();
+}
+
+add_test(function test_normal()
+{
+  let pageURI = NetUtil.newURI("http://example.com/normal");
+
+  PlacesTestUtils.addVisits(pageURI).then(function () {
+    PlacesUtils.favicons.setAndFetchFaviconForPage(
+      pageURI, FAVICON_URI, true,
+        PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+        function () {
+        PlacesUtils.favicons.getFaviconDataForPage(pageURI,
+          function (aURI, aDataLen, aData, aMimeType) {
+            do_check_true(aURI.equals(FAVICON_URI));
+            do_check_eq(FAVICON_DATA.length, aDataLen);
+            do_check_true(compareArrays(FAVICON_DATA, aData));
+            do_check_eq(FAVICON_MIMETYPE, aMimeType);
+            run_next_test();
+          });
+      }, Services.scriptSecurityManager.getSystemPrincipal());
+  });
+});
+
+add_test(function test_missing()
+{
+  let pageURI = NetUtil.newURI("http://example.com/missing");
+
+  PlacesUtils.favicons.getFaviconDataForPage(pageURI,
+    function (aURI, aDataLen, aData, aMimeType) {
+      // Check also the expected data types.
+      do_check_true(aURI === null);
+      do_check_true(aDataLen === 0);
+      do_check_true(aData.length === 0);
+      do_check_true(aMimeType === "");
+      run_next_test();
+    });
+});
diff --git a/toolkit/components/places/tests/favicons/test_getFaviconURLForPage.js b/toolkit/components/places/tests/favicons/test_getFaviconURLForPage.js
new file mode 100644
index 000000000..fb2e23ff9
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_getFaviconURLForPage.js
@@ -0,0 +1,51 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests getFaviconURLForPage.
+ */
+
+// Tests
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_test(function test_normal()
+{
+  let pageURI = NetUtil.newURI("http://example.com/normal");
+
+  PlacesTestUtils.addVisits(pageURI).then(function () {
+    PlacesUtils.favicons.setAndFetchFaviconForPage(
+      pageURI, SMALLPNG_DATA_URI, true,
+        PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+        function () {
+        PlacesUtils.favicons.getFaviconURLForPage(pageURI,
+          function (aURI, aDataLen, aData, aMimeType) {
+            do_check_true(aURI.equals(SMALLPNG_DATA_URI));
+
+            // Check also the expected data types.
+            do_check_true(aDataLen === 0);
+            do_check_true(aData.length === 0);
+            do_check_true(aMimeType === "");
+            run_next_test();
+          });
+      }, Services.scriptSecurityManager.getSystemPrincipal());
+  });
+});
+
+add_test(function test_missing()
+{
+  let pageURI = NetUtil.newURI("http://example.com/missing");
+
+  PlacesUtils.favicons.getFaviconURLForPage(pageURI,
+    function (aURI, aDataLen, aData, aMimeType) {
+      // Check also the expected data types.
+      do_check_true(aURI === null);
+      do_check_true(aDataLen === 0);
+      do_check_true(aData.length === 0);
+      do_check_true(aMimeType === "");
+      run_next_test();
+    });
+});
diff --git a/toolkit/components/places/tests/favicons/test_moz-anno_favicon_mime_type.js b/toolkit/components/places/tests/favicons/test_moz-anno_favicon_mime_type.js
new file mode 100644
index 000000000..d055d8d61
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_moz-anno_favicon_mime_type.js
@@ -0,0 +1,90 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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 test ensures that the mime type is set for moz-anno channels of favicons
+ * properly.  Added with work in bug 481227.
+ */
+
+// Constants
+Cu.import("resource://gre/modules/NetUtil.jsm");
+
+const testFaviconData = "data:image/png,%89PNG%0D%0A%1A%0A%00%00%00%0DIHDR%00%00%00%10%00%00%00%10%08%06%00%00%00%1F%F3%FFa%00%00%00%04gAMA%00%00%AF%C87%05%8A%E9%00%00%00%19tEXtSoftware%00Adobe%20ImageReadyq%C9e%3C%00%00%01%D6IDATx%DAb%FC%FF%FF%3F%03%25%00%20%80%98%909%EF%DF%BFg%EF%EC%EC%FC%AD%AC%AC%FC%DF%95%91%F1%BF%89%89%C9%7F%20%FF%D7%EA%D5%AB%B7%DF%BBwO%16%9B%01%00%01%C4%00r%01%08%9F9s%C6%CD%D8%D8%F8%BF%0B%03%C3%FF3%40%BC%0A%88%EF%02q%1A%10%BB%40%F1%AAU%ABv%C1%D4%C30%40%00%81%89%993g%3E%06%1A%F6%3F%14%AA%11D%97%03%F1%7Fc%08%0D%E2%2B))%FD%17%04%89%A1%19%00%10%40%0C%D00%F8%0F3%00%C8%F8%BF%1B%E4%0Ac%88a%E5%60%17%19%FF%0F%0D%0D%05%1B%02v%D9%DD%BB%0A0%03%00%02%08%AC%B9%A3%A3%E3%17%03%D4v%90%01%EF%18%106%C3%0Cz%07%C5%BB%A1%DE%82y%07%20%80%A0%A6%08B%FCn%0C1%60%26%D4%20d%C3VA%C3%06%26%BE%0A%EA-%80%00%82%B9%E0%F7L4%0D%EF%90%F8%C6%60%2F%0A%82%BD%01%13%07%0700%D0%01%02%88%11%E4%02P%B41%DC%BB%C7%D0%014%0D%E8l%06W%20%06%BA%88%A1%1C%1AS%15%40%7C%16%CA6.%2Fgx%BFg%0F%83%CB%D9%B3%0C%7B%80%7C%80%00%02%BB%00%E8%9F%ED%20%1B%3A%A0%A6%9F%81%DA%DC%01%C5%B0%80%ED%80%FA%BF%BC%BC%FC%3F%83%12%90%9D%96%F6%1F%20%80%18%DE%BD%7B%C7%0E%8E%05AD%20%FEGr%A6%A0%A0%E0%7F%25P%80%02%9D%0F%D28%13%18%23%C6%C0%B0%02E%3D%C8%F5%00%01%04%8F%05P%A8%BA%40my%87%E4%12c%A8%8D%20%8B%D0%D3%00%08%03%04%10%9C%01R%E4%82d%3B%C8%A0%99%C6%90%90%C6%A5%19%84%01%02%08%9E%17%80%C9x%F7%7B%A0%DBVC%F9%A0%C0%5C%7D%16%2C%CE%00%F4%C6O%5C%99%09%20%800L%04y%A5%03%1A%95%A0%80%05%05%14.%DBA%18%20%80%18)%CD%CE%00%01%06%00%0C'%94%C7%C0k%C9%2C%00%00%00%00IEND%AEB%60%82";
+const moz_anno_favicon_prefix = "moz-anno:favicon:";
+
+// streamListener
+
+function streamListener(aExpectedContentType)
+{
+  this._expectedContentType = aExpectedContentType;
+}
+streamListener.prototype =
+{
+  onStartRequest: function(aRequest, aContext)
+  {
+    // We have other tests that make sure the data is what we expect.  We just
+    // need to check the content type here.
+    let channel = aRequest.QueryInterface(Ci.nsIChannel);
+    dump("*** Checking " + channel.URI.spec + "\n");
+    do_check_eq(channel.contentType, this._expectedContentType);
+
+    // If we somehow throw before doing the above check, the test will pass, so
+    // we do this for extra sanity.
+    this._checked = true;
+  },
+  onStopRequest: function()
+  {
+    do_check_true(this._checked);
+    do_test_finished();
+  },
+  onDataAvailable: function(aRequest, aContext, aInputStream, aOffset, aCount)
+  {
+    aRequest.cancel(Cr.NS_ERROR_ABORT);
+  }
+};
+
+// Test Runner
+
+function run_test()
+{
+  let fs = Cc["@mozilla.org/browser/favicon-service;1"].
+           getService(Ci.nsIFaviconService);
+
+  // Test that the default icon has the content type of image/png.
+  let channel = NetUtil.newChannel({
+    uri: fs.defaultFavicon,
+    loadUsingSystemPrincipal: true,
+    contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE_FAVICON
+  });
+  channel.asyncOpen2(new streamListener("image/png"));
+  do_test_pending();
+
+  // Test URI that we don't know anything about.  Will end up being the default
+  // icon, so expect image/png.
+  channel = NetUtil.newChannel({
+    uri: moz_anno_favicon_prefix + "http://mozilla.org",
+    loadUsingSystemPrincipal: true,
+    contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE_FAVICON
+  });
+  channel.asyncOpen2(new streamListener("image/png"));
+  do_test_pending();
+
+  // Test that the content type of a favicon we add ends up being image/png.
+  let testURI = uri("http://mozilla.org/");
+  // Add the data before opening
+  fs.replaceFaviconDataFromDataURL(testURI, testFaviconData,
+                                   (Date.now() + 60 * 60 * 24 * 1000) * 1000,
+                                   Services.scriptSecurityManager.getSystemPrincipal());
+
+  // Open the channel
+  channel = NetUtil.newChannel({
+    uri: moz_anno_favicon_prefix + testURI.spec,
+    loadUsingSystemPrincipal: true,
+    contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE_FAVICON
+  });
+  channel.asyncOpen2(new streamListener("image/png"));
+  do_test_pending();
+}
diff --git a/toolkit/components/places/tests/favicons/test_page-icon_protocol.js b/toolkit/components/places/tests/favicons/test_page-icon_protocol.js
new file mode 100644
index 000000000..5533d5135
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_page-icon_protocol.js
@@ -0,0 +1,66 @@
+const ICON_DATA = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVQI12NgAAAAAgAB4iG8MwAAAABJRU5ErkJggg==";
+const TEST_URI = NetUtil.newURI("http://mozilla.org/");
+const ICON_URI = NetUtil.newURI("http://mozilla.org/favicon.ico");
+
+function fetchIconForSpec(spec) {
+ return new Promise((resolve, reject) => {
+    NetUtil.asyncFetch({
+      uri: NetUtil.newURI("page-icon:" + TEST_URI.spec),
+      loadUsingSystemPrincipal: true,
+      contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE_FAVICON
+    }, (input, status, request) => {
+       if (!Components.isSuccessCode(status)) {
+        reject(new Error("unable to load icon"));
+        return;
+      }
+
+      try {
+        let data = NetUtil.readInputStreamToString(input, input.available());
+        let contentType = request.QueryInterface(Ci.nsIChannel).contentType;
+        input.close();
+        resolve({ data, contentType });
+      } catch (ex) {
+        reject(ex);
+      }
+    });
+  });
+}
+
+var gDefaultFavicon;
+var gFavicon;
+
+add_task(function* setup() {
+  yield PlacesTestUtils.addVisits({ uri: TEST_URI });
+
+  PlacesUtils.favicons.replaceFaviconDataFromDataURL(
+    ICON_URI, ICON_DATA, (Date.now() + 8640000) * 1000,
+    Services.scriptSecurityManager.getSystemPrincipal());
+
+  yield new Promise(resolve => {
+    PlacesUtils.favicons.setAndFetchFaviconForPage(
+      TEST_URI, ICON_URI, false,
+      PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+      resolve, Services.scriptSecurityManager.getSystemPrincipal());
+  });
+
+  gDefaultFavicon = yield fetchIconForSpec(PlacesUtils.favicons.defaultFavicon);
+  gFavicon = yield fetchIconForSpec(ICON_DATA);
+});
+
+add_task(function* known_url() {
+  let {data, contentType} = yield fetchIconForSpec(TEST_URI.spec);
+  Assert.equal(contentType, gFavicon.contentType);
+  Assert.ok(data == gFavicon.data, "Got the favicon data");
+});
+
+add_task(function* unknown_url() {
+  let {data, contentType} = yield fetchIconForSpec("http://www.moz.org/");
+  Assert.equal(contentType, gDefaultFavicon.contentType);
+  Assert.ok(data == gDefaultFavicon.data, "Got the default favicon data");
+});
+
+add_task(function* invalid_url() {
+  let {data, contentType} = yield fetchIconForSpec("test");
+  Assert.equal(contentType, gDefaultFavicon.contentType);
+  Assert.ok(data == gDefaultFavicon.data, "Got the default favicon data");
+});
diff --git a/toolkit/components/places/tests/favicons/test_query_result_favicon_changed_on_child.js b/toolkit/components/places/tests/favicons/test_query_result_favicon_changed_on_child.js
new file mode 100644
index 000000000..df61c22cd
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_query_result_favicon_changed_on_child.js
@@ -0,0 +1,74 @@
+/**
+ * Test for bug 451499 <https://bugzilla.mozilla.org/show_bug.cgi?id=451499>:
+ * Wrong folder icon appears on smart bookmarks.
+ */
+
+"use strict";
+
+const PAGE_URI = NetUtil.newURI("http://example.com/test_query_result");
+
+add_task(function* test_query_result_favicon_changed_on_child() {
+  // Bookmark our test page, so it will appear in the query resultset.
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.menuGuid,
+    title: "test_bookmark",
+    url: PAGE_URI
+  });
+
+  // Get the last 10 bookmarks added to the menu or the toolbar.
+  let query = PlacesUtils.history.getNewQuery();
+  query.setFolders([PlacesUtils.bookmarksMenuFolderId,
+                    PlacesUtils.toolbarFolderId], 2);
+
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  options.maxResults = 10;
+  options.excludeQueries = 1;
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+
+  let result = PlacesUtils.history.executeQuery(query, options);
+  let resultObserver = {
+    __proto__: NavHistoryResultObserver.prototype,
+    containerStateChanged(aContainerNode, aOldState, aNewState) {
+      if (aNewState == Ci.nsINavHistoryContainerResultNode.STATE_OPENED) {
+        // We set a favicon on PAGE_URI while the container is open.  The
+        // favicon for the page must have data associated with it in order for
+        // the icon changed notifications to be sent, so we use a valid image
+        // data URI.
+        PlacesUtils.favicons.setAndFetchFaviconForPage(PAGE_URI,
+                                                       SMALLPNG_DATA_URI,
+                                                       false,
+                                                       PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+                                                       null,
+                                                       Services.scriptSecurityManager.getSystemPrincipal());
+      }
+    },
+    nodeIconChanged(aNode) {
+      do_throw("The icon should be set only for the page," +
+               " not for the containing query.");
+    }
+  };
+  result.addObserver(resultObserver, false);
+
+  // Open the container and wait for containerStateChanged. We should start
+  // observing before setting |containerOpen| as that's caused by the
+  // setAndFetchFaviconForPage() call caused by the containerStateChanged
+  // observer above.
+  let promise = promiseFaviconChanged(PAGE_URI, SMALLPNG_DATA_URI);
+  result.root.containerOpen = true;
+  yield promise;
+
+  // We must wait for the asynchronous database thread to finish the
+  // operation, and then for the main thread to process any pending
+  // notifications that came from the asynchronous thread, before we can be
+  // sure that nodeIconChanged was not invoked in the meantime.
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  result.removeObserver(resultObserver);
+
+  // Free the resources immediately.
+  result.root.containerOpen = false;
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/favicons/test_replaceFaviconData.js b/toolkit/components/places/tests/favicons/test_replaceFaviconData.js
new file mode 100644
index 000000000..ac53e70e9
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_replaceFaviconData.js
@@ -0,0 +1,264 @@
+/* Any copyright is dedicated to the Public Domain.
+ *    http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests for mozIAsyncFavicons::replaceFaviconData()
+ */
+
+var iconsvc = PlacesUtils.favicons;
+var histsvc = PlacesUtils.history;
+var systemPrincipal = Services.scriptSecurityManager.getSystemPrincipal();
+
+var originalFavicon = {
+  file: do_get_file("favicon-normal16.png"),
+  uri: uri(do_get_file("favicon-normal16.png")),
+  data: readFileData(do_get_file("favicon-normal16.png")),
+  mimetype: "image/png"
+};
+
+var uniqueFaviconId = 0;
+function createFavicon(fileName) {
+  let tempdir = Services.dirsvc.get("TmpD", Ci.nsILocalFile);
+
+  // remove any existing file at the path we're about to copy to
+  let outfile = tempdir.clone();
+  outfile.append(fileName);
+  try { outfile.remove(false); } catch (e) {}
+
+  originalFavicon.file.copyToFollowingLinks(tempdir, fileName);
+
+  let stream = Cc["@mozilla.org/network/file-output-stream;1"]
+    .createInstance(Ci.nsIFileOutputStream);
+  stream.init(outfile, 0x02 | 0x08 | 0x10, 0o600, 0);
+
+  // append some data that sniffers/encoders will ignore that will distinguish
+  // the different favicons we'll create
+  uniqueFaviconId++;
+  let uniqueStr = "uid:" + uniqueFaviconId;
+  stream.write(uniqueStr, uniqueStr.length);
+  stream.close();
+
+  do_check_eq(outfile.leafName.substr(0, fileName.length), fileName);
+
+  return {
+    file: outfile,
+    uri: uri(outfile),
+    data: readFileData(outfile),
+    mimetype: "image/png"
+  };
+}
+
+function checkCallbackSucceeded(callbackMimetype, callbackData, sourceMimetype, sourceData) {
+  do_check_eq(callbackMimetype, sourceMimetype);
+  do_check_true(compareArrays(callbackData, sourceData));
+}
+
+function run_test() {
+  // check that the favicon loaded correctly
+  do_check_eq(originalFavicon.data.length, 286);
+  run_next_test();
+}
+
+add_task(function* test_replaceFaviconData_validHistoryURI() {
+  do_print("test replaceFaviconData for valid history uri");
+
+  let pageURI = uri("http://test1.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let favicon = createFavicon("favicon1.png");
+
+  iconsvc.replaceFaviconData(favicon.uri, favicon.data, favicon.data.length,
+    favicon.mimetype);
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(pageURI, favicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconData_validHistoryURI_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, favicon.mimetype, favicon.data);
+      checkFaviconDataForPage(
+        pageURI, favicon.mimetype, favicon.data,
+        function test_replaceFaviconData_validHistoryURI_callback() {
+          favicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, systemPrincipal);
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconData_overrideDefaultFavicon() {
+  do_print("test replaceFaviconData to override a later setAndFetchFaviconForPage");
+
+  let pageURI = uri("http://test2.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let firstFavicon = createFavicon("favicon2.png");
+  let secondFavicon = createFavicon("favicon3.png");
+
+  iconsvc.replaceFaviconData(
+    firstFavicon.uri, secondFavicon.data, secondFavicon.data.length,
+    secondFavicon.mimetype);
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, firstFavicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconData_overrideDefaultFavicon_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, secondFavicon.mimetype, secondFavicon.data);
+      checkFaviconDataForPage(
+        pageURI, secondFavicon.mimetype, secondFavicon.data,
+        function test_replaceFaviconData_overrideDefaultFavicon_callback() {
+          firstFavicon.file.remove(false);
+          secondFavicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, systemPrincipal);
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconData_replaceExisting() {
+  do_print("test replaceFaviconData to override a previous setAndFetchFaviconForPage");
+
+  let pageURI = uri("http://test3.bar");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let firstFavicon = createFavicon("favicon4.png");
+  let secondFavicon = createFavicon("favicon5.png");
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, firstFavicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconData_replaceExisting_firstSet_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, firstFavicon.mimetype, firstFavicon.data);
+      checkFaviconDataForPage(
+        pageURI, firstFavicon.mimetype, firstFavicon.data,
+        function test_replaceFaviconData_overrideDefaultFavicon_firstCallback() {
+          iconsvc.replaceFaviconData(
+            firstFavicon.uri, secondFavicon.data, secondFavicon.data.length,
+            secondFavicon.mimetype);
+          PlacesTestUtils.promiseAsyncUpdates().then(() => {
+            checkFaviconDataForPage(
+              pageURI, secondFavicon.mimetype, secondFavicon.data,
+              function test_replaceFaviconData_overrideDefaultFavicon_secondCallback() {
+                firstFavicon.file.remove(false);
+                secondFavicon.file.remove(false);
+                deferSetAndFetchFavicon.resolve();
+              }, systemPrincipal);
+          });
+        });
+    }, systemPrincipal);
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconData_unrelatedReplace() {
+  do_print("test replaceFaviconData to not make unrelated changes");
+
+  let pageURI = uri("http://test4.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let favicon = createFavicon("favicon6.png");
+  let unrelatedFavicon = createFavicon("favicon7.png");
+
+  iconsvc.replaceFaviconData(
+    unrelatedFavicon.uri, unrelatedFavicon.data, unrelatedFavicon.data.length,
+    unrelatedFavicon.mimetype);
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, favicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconData_unrelatedReplace_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, favicon.mimetype, favicon.data);
+      checkFaviconDataForPage(
+        pageURI, favicon.mimetype, favicon.data,
+        function test_replaceFaviconData_unrelatedReplace_callback() {
+          favicon.file.remove(false);
+          unrelatedFavicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, systemPrincipal);
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconData_badInputs() {
+  do_print("test replaceFaviconData to throw on bad inputs");
+
+  let favicon = createFavicon("favicon8.png");
+
+  let ex = null;
+  try {
+    iconsvc.replaceFaviconData(
+      favicon.uri, favicon.data, favicon.data.length, "");
+  } catch (e) {
+    ex = e;
+  } finally {
+    do_check_true(!!ex);
+  }
+
+  ex = null;
+  try {
+    iconsvc.replaceFaviconData(
+      null, favicon.data, favicon.data.length, favicon.mimeType);
+  } catch (e) {
+    ex = e;
+  } finally {
+    do_check_true(!!ex);
+  }
+
+  ex = null;
+  try {
+    iconsvc.replaceFaviconData(
+      favicon.uri, null, 0, favicon.mimeType);
+  } catch (e) {
+    ex = e;
+  } finally {
+    do_check_true(!!ex);
+  }
+
+  favicon.file.remove(false);
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconData_twiceReplace() {
+  do_print("test replaceFaviconData on multiple replacements");
+
+  let pageURI = uri("http://test5.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let firstFavicon = createFavicon("favicon9.png");
+  let secondFavicon = createFavicon("favicon10.png");
+
+  iconsvc.replaceFaviconData(
+    firstFavicon.uri, firstFavicon.data, firstFavicon.data.length,
+    firstFavicon.mimetype);
+  iconsvc.replaceFaviconData(
+    firstFavicon.uri, secondFavicon.data, secondFavicon.data.length,
+    secondFavicon.mimetype);
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, firstFavicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconData_twiceReplace_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, secondFavicon.mimetype, secondFavicon.data);
+      checkFaviconDataForPage(
+        pageURI, secondFavicon.mimetype, secondFavicon.data,
+        function test_replaceFaviconData_twiceReplace_callback() {
+          firstFavicon.file.remove(false);
+          secondFavicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        }, systemPrincipal);
+    }, systemPrincipal);
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
diff --git a/toolkit/components/places/tests/favicons/test_replaceFaviconDataFromDataURL.js b/toolkit/components/places/tests/favicons/test_replaceFaviconDataFromDataURL.js
new file mode 100644
index 000000000..69a5ba852
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/test_replaceFaviconDataFromDataURL.js
@@ -0,0 +1,352 @@
+/* Any copyright is dedicated to the Public Domain.
+ *    http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Tests for mozIAsyncFavicons::replaceFaviconData()
+ */
+
+var iconsvc = PlacesUtils.favicons;
+var histsvc = PlacesUtils.history;
+
+var originalFavicon = {
+  file: do_get_file("favicon-normal16.png"),
+  uri: uri(do_get_file("favicon-normal16.png")),
+  data: readFileData(do_get_file("favicon-normal16.png")),
+  mimetype: "image/png"
+};
+
+var uniqueFaviconId = 0;
+function createFavicon(fileName) {
+  let tempdir = Services.dirsvc.get("TmpD", Ci.nsILocalFile);
+
+  // remove any existing file at the path we're about to copy to
+  let outfile = tempdir.clone();
+  outfile.append(fileName);
+  try { outfile.remove(false); } catch (e) {}
+
+  originalFavicon.file.copyToFollowingLinks(tempdir, fileName);
+
+  let stream = Cc["@mozilla.org/network/file-output-stream;1"]
+    .createInstance(Ci.nsIFileOutputStream);
+  stream.init(outfile, 0x02 | 0x08 | 0x10, 0o600, 0);
+
+  // append some data that sniffers/encoders will ignore that will distinguish
+  // the different favicons we'll create
+  uniqueFaviconId++;
+  let uniqueStr = "uid:" + uniqueFaviconId;
+  stream.write(uniqueStr, uniqueStr.length);
+  stream.close();
+
+  do_check_eq(outfile.leafName.substr(0, fileName.length), fileName);
+
+  return {
+    file: outfile,
+    uri: uri(outfile),
+    data: readFileData(outfile),
+    mimetype: "image/png"
+  };
+}
+
+function createDataURLForFavicon(favicon) {
+  return "data:" + favicon.mimetype + ";base64," + toBase64(favicon.data);
+}
+
+function checkCallbackSucceeded(callbackMimetype, callbackData, sourceMimetype, sourceData) {
+  do_check_eq(callbackMimetype, sourceMimetype);
+  do_check_true(compareArrays(callbackData, sourceData));
+}
+
+function run_test() {
+  // check that the favicon loaded correctly
+  do_check_eq(originalFavicon.data.length, 286);
+  run_next_test();
+}
+
+add_task(function* test_replaceFaviconDataFromDataURL_validHistoryURI() {
+  do_print("test replaceFaviconDataFromDataURL for valid history uri");
+
+  let pageURI = uri("http://test1.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let favicon = createFavicon("favicon1.png");
+  iconsvc.replaceFaviconDataFromDataURL(favicon.uri, createDataURLForFavicon(favicon), 0,
+                                        Services.scriptSecurityManager.getSystemPrincipal());
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(pageURI, favicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconDataFromDataURL_validHistoryURI_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, favicon.mimetype, favicon.data);
+      checkFaviconDataForPage(
+        pageURI, favicon.mimetype, favicon.data,
+        function test_replaceFaviconDataFromDataURL_validHistoryURI_callback() {
+          favicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, Services.scriptSecurityManager.getSystemPrincipal());
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconDataFromDataURL_overrideDefaultFavicon() {
+  do_print("test replaceFaviconDataFromDataURL to override a later setAndFetchFaviconForPage");
+
+  let pageURI = uri("http://test2.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let firstFavicon = createFavicon("favicon2.png");
+  let secondFavicon = createFavicon("favicon3.png");
+
+  iconsvc.replaceFaviconDataFromDataURL(firstFavicon.uri, createDataURLForFavicon(secondFavicon), 0,
+                                        Services.scriptSecurityManager.getSystemPrincipal());
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, firstFavicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconDataFromDataURL_overrideDefaultFavicon_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, secondFavicon.mimetype, secondFavicon.data);
+      checkFaviconDataForPage(
+        pageURI, secondFavicon.mimetype, secondFavicon.data,
+        function test_replaceFaviconDataFromDataURL_overrideDefaultFavicon_callback() {
+          firstFavicon.file.remove(false);
+          secondFavicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, Services.scriptSecurityManager.getSystemPrincipal());
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconDataFromDataURL_replaceExisting() {
+  do_print("test replaceFaviconDataFromDataURL to override a previous setAndFetchFaviconForPage");
+
+  let pageURI = uri("http://test3.bar");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let firstFavicon = createFavicon("favicon4.png");
+  let secondFavicon = createFavicon("favicon5.png");
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, firstFavicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconDataFromDataURL_replaceExisting_firstSet_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, firstFavicon.mimetype, firstFavicon.data);
+      checkFaviconDataForPage(
+        pageURI, firstFavicon.mimetype, firstFavicon.data,
+        function test_replaceFaviconDataFromDataURL_replaceExisting_firstCallback() {
+          iconsvc.replaceFaviconDataFromDataURL(firstFavicon.uri, createDataURLForFavicon(secondFavicon), 0,
+                                                Services.scriptSecurityManager.getSystemPrincipal());
+          checkFaviconDataForPage(
+            pageURI, secondFavicon.mimetype, secondFavicon.data,
+            function test_replaceFaviconDataFromDataURL_replaceExisting_secondCallback() {
+              firstFavicon.file.remove(false);
+              secondFavicon.file.remove(false);
+              deferSetAndFetchFavicon.resolve();
+            });
+        });
+    }, Services.scriptSecurityManager.getSystemPrincipal());
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconDataFromDataURL_unrelatedReplace() {
+  do_print("test replaceFaviconDataFromDataURL to not make unrelated changes");
+
+  let pageURI = uri("http://test4.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let favicon = createFavicon("favicon6.png");
+  let unrelatedFavicon = createFavicon("favicon7.png");
+
+  iconsvc.replaceFaviconDataFromDataURL(unrelatedFavicon.uri, createDataURLForFavicon(unrelatedFavicon), 0,
+                                        Services.scriptSecurityManager.getSystemPrincipal());
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, favicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconDataFromDataURL_unrelatedReplace_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, favicon.mimetype, favicon.data);
+      checkFaviconDataForPage(
+        pageURI, favicon.mimetype, favicon.data,
+        function test_replaceFaviconDataFromDataURL_unrelatedReplace_callback() {
+          favicon.file.remove(false);
+          unrelatedFavicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, Services.scriptSecurityManager.getSystemPrincipal());
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconDataFromDataURL_badInputs() {
+  do_print("test replaceFaviconDataFromDataURL to throw on bad inputs");
+
+  let favicon = createFavicon("favicon8.png");
+
+  let ex = null;
+  try {
+    iconsvc.replaceFaviconDataFromDataURL(favicon.uri, "", 0,
+                                          Services.scriptSecurityManager.getSystemPrincipal());
+  } catch (e) {
+    ex = e;
+  } finally {
+    do_check_true(!!ex);
+  }
+
+  ex = null;
+  try {
+    iconsvc.replaceFaviconDataFromDataURL(null, createDataURLForFavicon(favicon), 0,
+                                          Services.scriptSecurityManager.getSystemPrincipal());
+  } catch (e) {
+    ex = e;
+  } finally {
+    do_check_true(!!ex);
+  }
+
+  favicon.file.remove(false);
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconDataFromDataURL_twiceReplace() {
+  do_print("test replaceFaviconDataFromDataURL on multiple replacements");
+
+  let pageURI = uri("http://test5.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let firstFavicon = createFavicon("favicon9.png");
+  let secondFavicon = createFavicon("favicon10.png");
+
+  iconsvc.replaceFaviconDataFromDataURL(firstFavicon.uri, createDataURLForFavicon(firstFavicon), 0,
+                                        Services.scriptSecurityManager.getSystemPrincipal());
+  iconsvc.replaceFaviconDataFromDataURL(firstFavicon.uri, createDataURLForFavicon(secondFavicon), 0,
+                                        Services.scriptSecurityManager.getSystemPrincipal());
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, firstFavicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconDataFromDataURL_twiceReplace_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, secondFavicon.mimetype, secondFavicon.data);
+      checkFaviconDataForPage(
+        pageURI, secondFavicon.mimetype, secondFavicon.data,
+        function test_replaceFaviconDataFromDataURL_twiceReplace_callback() {
+          firstFavicon.file.remove(false);
+          secondFavicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, Services.scriptSecurityManager.getSystemPrincipal());
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconDataFromDataURL_afterRegularAssign() {
+  do_print("test replaceFaviconDataFromDataURL after replaceFaviconData");
+
+  let pageURI = uri("http://test6.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let firstFavicon = createFavicon("favicon11.png");
+  let secondFavicon = createFavicon("favicon12.png");
+
+  iconsvc.replaceFaviconData(
+    firstFavicon.uri, firstFavicon.data, firstFavicon.data.length,
+    firstFavicon.mimetype);
+  iconsvc.replaceFaviconDataFromDataURL(firstFavicon.uri, createDataURLForFavicon(secondFavicon), 0,
+                                        Services.scriptSecurityManager.getSystemPrincipal());
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, firstFavicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconDataFromDataURL_afterRegularAssign_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, secondFavicon.mimetype, secondFavicon.data);
+      checkFaviconDataForPage(
+        pageURI, secondFavicon.mimetype, secondFavicon.data,
+        function test_replaceFaviconDataFromDataURL_afterRegularAssign_callback() {
+          firstFavicon.file.remove(false);
+          secondFavicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, Services.scriptSecurityManager.getSystemPrincipal());
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_replaceFaviconDataFromDataURL_beforeRegularAssign() {
+  do_print("test replaceFaviconDataFromDataURL before replaceFaviconData");
+
+  let pageURI = uri("http://test7.bar/");
+  yield PlacesTestUtils.addVisits(pageURI);
+
+  let firstFavicon = createFavicon("favicon13.png");
+  let secondFavicon = createFavicon("favicon14.png");
+
+  iconsvc.replaceFaviconDataFromDataURL(firstFavicon.uri, createDataURLForFavicon(firstFavicon), 0,
+                                        Services.scriptSecurityManager.getSystemPrincipal());
+  iconsvc.replaceFaviconData(
+    firstFavicon.uri, secondFavicon.data, secondFavicon.data.length,
+    secondFavicon.mimetype);
+
+  let deferSetAndFetchFavicon = Promise.defer();
+  iconsvc.setAndFetchFaviconForPage(
+    pageURI, firstFavicon.uri, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    function test_replaceFaviconDataFromDataURL_beforeRegularAssign_check(aURI, aDataLen, aData, aMimeType) {
+      checkCallbackSucceeded(aMimeType, aData, secondFavicon.mimetype, secondFavicon.data);
+      checkFaviconDataForPage(
+        pageURI, secondFavicon.mimetype, secondFavicon.data,
+        function test_replaceFaviconDataFromDataURL_beforeRegularAssign_callback() {
+          firstFavicon.file.remove(false);
+          secondFavicon.file.remove(false);
+          deferSetAndFetchFavicon.resolve();
+        });
+    }, Services.scriptSecurityManager.getSystemPrincipal());
+  yield deferSetAndFetchFavicon.promise;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+/* toBase64 copied from image/test/unit/test_encoder_png.js */
+
+/* Convert data (an array of integers) to a Base64 string. */
+const toBase64Table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' +
+    '0123456789+/';
+const base64Pad = '=';
+function toBase64(data) {
+  let result = '';
+  let length = data.length;
+  let i;
+  // Convert every three bytes to 4 ascii characters.
+  for (i = 0; i < (length - 2); i += 3) {
+    result += toBase64Table[data[i] >> 2];
+    result += toBase64Table[((data[i] & 0x03) << 4) + (data[i+1] >> 4)];
+    result += toBase64Table[((data[i+1] & 0x0f) << 2) + (data[i+2] >> 6)];
+    result += toBase64Table[data[i+2] & 0x3f];
+  }
+
+  // Convert the remaining 1 or 2 bytes, pad out to 4 characters.
+  if (length%3) {
+    i = length - (length%3);
+    result += toBase64Table[data[i] >> 2];
+    if ((length%3) == 2) {
+      result += toBase64Table[((data[i] & 0x03) << 4) + (data[i+1] >> 4)];
+      result += toBase64Table[(data[i+1] & 0x0f) << 2];
+      result += base64Pad;
+    } else {
+      result += toBase64Table[(data[i] & 0x03) << 4];
+      result += base64Pad + base64Pad;
+    }
+  }
+
+  return result;
+}
diff --git a/toolkit/components/places/tests/favicons/xpcshell.ini b/toolkit/components/places/tests/favicons/xpcshell.ini
new file mode 100644
index 000000000..851f193c7
--- /dev/null
+++ b/toolkit/components/places/tests/favicons/xpcshell.ini
@@ -0,0 +1,32 @@
+[DEFAULT]
+head = head_favicons.js
+tail =
+skip-if = toolkit == 'android'
+support-files =
+  expected-favicon-big32.jpg.png
+  expected-favicon-big4.jpg.png
+  expected-favicon-big48.ico.png
+  expected-favicon-big64.png.png
+  expected-favicon-scale160x3.jpg.png
+  expected-favicon-scale3x160.jpg.png
+  favicon-big16.ico
+  favicon-big32.jpg
+  favicon-big4.jpg
+  favicon-big48.ico
+  favicon-big64.png
+  favicon-normal16.png
+  favicon-normal32.png
+  favicon-scale160x3.jpg
+  favicon-scale3x160.jpg
+
+[test_expireAllFavicons.js]
+[test_favicons_conversions.js]
+# Bug 676989: test fails consistently on Android
+fail-if = os == "android"
+[test_getFaviconDataForPage.js]
+[test_getFaviconURLForPage.js]
+[test_moz-anno_favicon_mime_type.js]
+[test_page-icon_protocol.js]
+[test_query_result_favicon_changed_on_child.js]
+[test_replaceFaviconData.js]
+[test_replaceFaviconDataFromDataURL.js]
diff --git a/toolkit/components/places/tests/head_common.js b/toolkit/components/places/tests/head_common.js
new file mode 100644
index 000000000..ddb6dcbd7
--- /dev/null
+++ b/toolkit/components/places/tests/head_common.js
@@ -0,0 +1,869 @@
+/* -*- 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/. */
+
+const CURRENT_SCHEMA_VERSION = 35;
+const FIRST_UPGRADABLE_SCHEMA_VERSION = 11;
+
+const NS_APP_USER_PROFILE_50_DIR = "ProfD";
+const NS_APP_PROFILE_DIR_STARTUP = "ProfDS";
+
+// Shortcuts to transitions type.
+const TRANSITION_LINK = Ci.nsINavHistoryService.TRANSITION_LINK;
+const TRANSITION_TYPED = Ci.nsINavHistoryService.TRANSITION_TYPED;
+const TRANSITION_BOOKMARK = Ci.nsINavHistoryService.TRANSITION_BOOKMARK;
+const TRANSITION_EMBED = Ci.nsINavHistoryService.TRANSITION_EMBED;
+const TRANSITION_FRAMED_LINK = Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK;
+const TRANSITION_REDIRECT_PERMANENT = Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT;
+const TRANSITION_REDIRECT_TEMPORARY = Ci.nsINavHistoryService.TRANSITION_REDIRECT_TEMPORARY;
+const TRANSITION_DOWNLOAD = Ci.nsINavHistoryService.TRANSITION_DOWNLOAD;
+const TRANSITION_RELOAD = Ci.nsINavHistoryService.TRANSITION_RELOAD;
+
+const TITLE_LENGTH_MAX = 4096;
+
+Cu.importGlobalProperties(["URL"]);
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
+                                  "resource://gre/modules/FileUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+                                  "resource://gre/modules/NetUtil.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+                                  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Services",
+                                  "resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+                                  "resource://gre/modules/Task.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "BookmarkJSONUtils",
+                                  "resource://gre/modules/BookmarkJSONUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "BookmarkHTMLUtils",
+                                  "resource://gre/modules/BookmarkHTMLUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PlacesBackups",
+                                  "resource://gre/modules/PlacesBackups.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PlacesTestUtils",
+                                  "resource://testing-common/PlacesTestUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PlacesTransactions",
+                                  "resource://gre/modules/PlacesTransactions.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+                                  "resource://gre/modules/osfile.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Sqlite",
+                                  "resource://gre/modules/Sqlite.jsm");
+
+// This imports various other objects in addition to PlacesUtils.
+Cu.import("resource://gre/modules/PlacesUtils.jsm");
+
+XPCOMUtils.defineLazyGetter(this, "SMALLPNG_DATA_URI", function() {
+  return NetUtil.newURI(
+         "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAA" +
+         "AAAA6fptVAAAACklEQVQI12NgAAAAAgAB4iG8MwAAAABJRU5ErkJggg==");
+});
+XPCOMUtils.defineLazyGetter(this, "SMALLSVG_DATA_URI", function() {
+  return NetUtil.newURI(
+         "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy5" +
+         "3My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMDAgMTAwIiBmaWxs" +
+         "PSIjNDI0ZTVhIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iN" +
+         "DQiIHN0cm9rZT0iIzQyNGU1YSIgc3Ryb2tlLXdpZHRoPSIxMSIgZmlsbD" +
+         "0ibm9uZSIvPg0KICA8Y2lyY2xlIGN4PSI1MCIgY3k9IjI0LjYiIHI9IjY" +
+         "uNCIvPg0KICA8cmVjdCB4PSI0NSIgeT0iMzkuOSIgd2lkdGg9IjEwLjEi" +
+         "IGhlaWdodD0iNDEuOCIvPg0KPC9zdmc%2BDQo%3D");
+});
+
+var gTestDir = do_get_cwd();
+
+// Initialize profile.
+var gProfD = do_get_profile(true);
+
+// Remove any old database.
+clearDB();
+
+/**
+ * Shortcut to create a nsIURI.
+ *
+ * @param aSpec
+ *        URLString of the uri.
+ */
+function uri(aSpec) {
+  return NetUtil.newURI(aSpec);
+}
+
+
+/**
+ * Gets the database connection.  If the Places connection is invalid it will
+ * try to create a new connection.
+ *
+ * @param [optional] aForceNewConnection
+ *        Forces creation of a new connection to the database.  When a
+ *        connection is asyncClosed it cannot anymore schedule async statements,
+ *        though connectionReady will keep returning true (Bug 726990).
+ *
+ * @return The database connection or null if unable to get one.
+ */
+var gDBConn;
+function DBConn(aForceNewConnection) {
+  if (!aForceNewConnection) {
+    let db = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
+                                .DBConnection;
+    if (db.connectionReady)
+      return db;
+  }
+
+  // If the Places database connection has been closed, create a new connection.
+  if (!gDBConn || aForceNewConnection) {
+    let file = Services.dirsvc.get('ProfD', Ci.nsIFile);
+    file.append("places.sqlite");
+    let dbConn = gDBConn = Services.storage.openDatabase(file);
+
+    // Be sure to cleanly close this connection.
+    promiseTopicObserved("profile-before-change").then(() => dbConn.asyncClose());
+  }
+
+  return gDBConn.connectionReady ? gDBConn : null;
+}
+
+/**
+ * Reads data from the provided inputstream.
+ *
+ * @return an array of bytes.
+ */
+function readInputStreamData(aStream) {
+  let bistream = Cc["@mozilla.org/binaryinputstream;1"].
+                 createInstance(Ci.nsIBinaryInputStream);
+  try {
+    bistream.setInputStream(aStream);
+    let expectedData = [];
+    let avail;
+    while ((avail = bistream.available())) {
+      expectedData = expectedData.concat(bistream.readByteArray(avail));
+    }
+    return expectedData;
+  } finally {
+    bistream.close();
+  }
+}
+
+/**
+ * Reads the data from the specified nsIFile.
+ *
+ * @param aFile
+ *        The nsIFile to read from.
+ * @return an array of bytes.
+ */
+function readFileData(aFile) {
+  let inputStream = Cc["@mozilla.org/network/file-input-stream;1"].
+                    createInstance(Ci.nsIFileInputStream);
+  // init the stream as RD_ONLY, -1 == default permissions.
+  inputStream.init(aFile, 0x01, -1, null);
+
+  // Check the returned size versus the expected size.
+  let size  = inputStream.available();
+  let bytes = readInputStreamData(inputStream);
+  if (size != bytes.length) {
+    throw "Didn't read expected number of bytes";
+  }
+  return bytes;
+}
+
+/**
+ * Reads the data from the named file, verifying the expected file length.
+ *
+ * @param aFileName
+ *        This file should be located in the same folder as the test.
+ * @param aExpectedLength
+ *        Expected length of the file.
+ *
+ * @return The array of bytes read from the file.
+ */
+function readFileOfLength(aFileName, aExpectedLength) {
+  let data = readFileData(do_get_file(aFileName));
+  do_check_eq(data.length, aExpectedLength);
+  return data;
+}
+
+
+/**
+ * Returns the base64-encoded version of the given string.  This function is
+ * similar to window.btoa, but is available to xpcshell tests also.
+ *
+ * @param aString
+ *        Each character in this string corresponds to a byte, and must be a
+ *        code point in the range 0-255.
+ *
+ * @return The base64-encoded string.
+ */
+function base64EncodeString(aString) {
+  var stream = Cc["@mozilla.org/io/string-input-stream;1"]
+               .createInstance(Ci.nsIStringInputStream);
+  stream.setData(aString, aString.length);
+  var encoder = Cc["@mozilla.org/scriptablebase64encoder;1"]
+                .createInstance(Ci.nsIScriptableBase64Encoder);
+  return encoder.encodeToString(stream, aString.length);
+}
+
+
+/**
+ * Compares two arrays, and returns true if they are equal.
+ *
+ * @param aArray1
+ *        First array to compare.
+ * @param aArray2
+ *        Second array to compare.
+ */
+function compareArrays(aArray1, aArray2) {
+  if (aArray1.length != aArray2.length) {
+    print("compareArrays: array lengths differ\n");
+    return false;
+  }
+
+  for (let i = 0; i < aArray1.length; i++) {
+    if (aArray1[i] != aArray2[i]) {
+      print("compareArrays: arrays differ at index " + i + ": " +
+            "(" + aArray1[i] + ") != (" + aArray2[i] +")\n");
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+/**
+ * Deletes a previously created sqlite file from the profile folder.
+ */
+function clearDB() {
+  try {
+    let file = Services.dirsvc.get('ProfD', Ci.nsIFile);
+    file.append("places.sqlite");
+    if (file.exists())
+      file.remove(false);
+  } catch (ex) { dump("Exception: " + ex); }
+}
+
+
+/**
+ * Dumps the rows of a table out to the console.
+ *
+ * @param aName
+ *        The name of the table or view to output.
+ */
+function dump_table(aName)
+{
+  let stmt = DBConn().createStatement("SELECT * FROM " + aName);
+
+  print("\n*** Printing data from " + aName);
+  let count = 0;
+  while (stmt.executeStep()) {
+    let columns = stmt.numEntries;
+
+    if (count == 0) {
+      // Print the column names.
+      for (let i = 0; i < columns; i++)
+        dump(stmt.getColumnName(i) + "\t");
+      dump("\n");
+    }
+
+    // Print the rows.
+    for (let i = 0; i < columns; i++) {
+      switch (stmt.getTypeOfIndex(i)) {
+        case Ci.mozIStorageValueArray.VALUE_TYPE_NULL:
+          dump("NULL\t");
+          break;
+        case Ci.mozIStorageValueArray.VALUE_TYPE_INTEGER:
+          dump(stmt.getInt64(i) + "\t");
+          break;
+        case Ci.mozIStorageValueArray.VALUE_TYPE_FLOAT:
+          dump(stmt.getDouble(i) + "\t");
+          break;
+        case Ci.mozIStorageValueArray.VALUE_TYPE_TEXT:
+          dump(stmt.getString(i) + "\t");
+          break;
+      }
+    }
+    dump("\n");
+
+    count++;
+  }
+  print("*** There were a total of " + count + " rows of data.\n");
+
+  stmt.finalize();
+}
+
+
+/**
+ * Checks if an address is found in the database.
+ * @param aURI
+ *        nsIURI or address to look for.
+ * @return place id of the page or 0 if not found
+ */
+function page_in_database(aURI)
+{
+  let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
+  let stmt = DBConn().createStatement(
+    "SELECT id FROM moz_places WHERE url_hash = hash(:url) AND url = :url"
+  );
+  stmt.params.url = url;
+  try {
+    if (!stmt.executeStep())
+      return 0;
+    return stmt.getInt64(0);
+  }
+  finally {
+    stmt.finalize();
+  }
+}
+
+/**
+ * Checks how many visits exist for a specified page.
+ * @param aURI
+ *        nsIURI or address to look for.
+ * @return number of visits found.
+ */
+function visits_in_database(aURI)
+{
+  let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
+  let stmt = DBConn().createStatement(
+    `SELECT count(*) FROM moz_historyvisits v
+     JOIN moz_places h ON h.id = v.place_id
+     WHERE url_hash = hash(:url) AND url = :url`
+  );
+  stmt.params.url = url;
+  try {
+    if (!stmt.executeStep())
+      return 0;
+    return stmt.getInt64(0);
+  }
+  finally {
+    stmt.finalize();
+  }
+}
+
+/**
+ * Checks that we don't have any bookmark
+ */
+function check_no_bookmarks() {
+  let query = PlacesUtils.history.getNewQuery();
+  let folders = [
+    PlacesUtils.bookmarks.toolbarFolder,
+    PlacesUtils.bookmarks.bookmarksMenuFolder,
+    PlacesUtils.bookmarks.unfiledBookmarksFolder,
+  ];
+  query.setFolders(folders, 3);
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  if (root.childCount != 0)
+    do_throw("Unable to remove all bookmarks");
+  root.containerOpen = false;
+}
+
+/**
+ * Allows waiting for an observer notification once.
+ *
+ * @param aTopic
+ *        Notification topic to observe.
+ *
+ * @return {Promise}
+ * @resolves The array [aSubject, aData] from the observed notification.
+ * @rejects Never.
+ */
+function promiseTopicObserved(aTopic)
+{
+  return new Promise(resolve => {
+    Services.obs.addObserver(function observe(aObsSubject, aObsTopic, aObsData) {
+      Services.obs.removeObserver(observe, aObsTopic);
+      resolve([aObsSubject, aObsData]);
+    }, aTopic, false);
+  });
+}
+
+/**
+ * Simulates a Places shutdown.
+ */
+var shutdownPlaces = function() {
+  do_print("shutdownPlaces: starting");
+  let promise = new Promise(resolve => {
+    Services.obs.addObserver(resolve, "places-connection-closed", false);
+  });
+  let hs = PlacesUtils.history.QueryInterface(Ci.nsIObserver);
+  hs.observe(null, "profile-change-teardown", null);
+  do_print("shutdownPlaces: sent profile-change-teardown");
+  hs.observe(null, "test-simulate-places-shutdown", null);
+  do_print("shutdownPlaces: sent test-simulate-places-shutdown");
+  return promise.then(() => {
+    do_print("shutdownPlaces: complete");
+  });
+};
+
+const FILENAME_BOOKMARKS_HTML = "bookmarks.html";
+const FILENAME_BOOKMARKS_JSON = "bookmarks-" +
+  (PlacesBackups.toISODateString(new Date())) + ".json";
+
+/**
+ * Creates a bookmarks.html file in the profile folder from a given source file.
+ *
+ * @param aFilename
+ *        Name of the file to copy to the profile folder.  This file must
+ *        exist in the directory that contains the test files.
+ *
+ * @return nsIFile object for the file.
+ */
+function create_bookmarks_html(aFilename) {
+  if (!aFilename)
+    do_throw("you must pass a filename to create_bookmarks_html function");
+  remove_bookmarks_html();
+  let bookmarksHTMLFile = gTestDir.clone();
+  bookmarksHTMLFile.append(aFilename);
+  do_check_true(bookmarksHTMLFile.exists());
+  bookmarksHTMLFile.copyTo(gProfD, FILENAME_BOOKMARKS_HTML);
+  let profileBookmarksHTMLFile = gProfD.clone();
+  profileBookmarksHTMLFile.append(FILENAME_BOOKMARKS_HTML);
+  do_check_true(profileBookmarksHTMLFile.exists());
+  return profileBookmarksHTMLFile;
+}
+
+
+/**
+ * Remove bookmarks.html file from the profile folder.
+ */
+function remove_bookmarks_html() {
+  let profileBookmarksHTMLFile = gProfD.clone();
+  profileBookmarksHTMLFile.append(FILENAME_BOOKMARKS_HTML);
+  if (profileBookmarksHTMLFile.exists()) {
+    profileBookmarksHTMLFile.remove(false);
+    do_check_false(profileBookmarksHTMLFile.exists());
+  }
+}
+
+
+/**
+ * Check bookmarks.html file exists in the profile folder.
+ *
+ * @return nsIFile object for the file.
+ */
+function check_bookmarks_html() {
+  let profileBookmarksHTMLFile = gProfD.clone();
+  profileBookmarksHTMLFile.append(FILENAME_BOOKMARKS_HTML);
+  do_check_true(profileBookmarksHTMLFile.exists());
+  return profileBookmarksHTMLFile;
+}
+
+
+/**
+ * Creates a JSON backup in the profile folder folder from a given source file.
+ *
+ * @param aFilename
+ *        Name of the file to copy to the profile folder.  This file must
+ *        exist in the directory that contains the test files.
+ *
+ * @return nsIFile object for the file.
+ */
+function create_JSON_backup(aFilename) {
+  if (!aFilename)
+    do_throw("you must pass a filename to create_JSON_backup function");
+  let bookmarksBackupDir = gProfD.clone();
+  bookmarksBackupDir.append("bookmarkbackups");
+  if (!bookmarksBackupDir.exists()) {
+    bookmarksBackupDir.create(Ci.nsIFile.DIRECTORY_TYPE, parseInt("0755", 8));
+    do_check_true(bookmarksBackupDir.exists());
+  }
+  let profileBookmarksJSONFile = bookmarksBackupDir.clone();
+  profileBookmarksJSONFile.append(FILENAME_BOOKMARKS_JSON);
+  if (profileBookmarksJSONFile.exists()) {
+    profileBookmarksJSONFile.remove();
+  }
+  let bookmarksJSONFile = gTestDir.clone();
+  bookmarksJSONFile.append(aFilename);
+  do_check_true(bookmarksJSONFile.exists());
+  bookmarksJSONFile.copyTo(bookmarksBackupDir, FILENAME_BOOKMARKS_JSON);
+  profileBookmarksJSONFile = bookmarksBackupDir.clone();
+  profileBookmarksJSONFile.append(FILENAME_BOOKMARKS_JSON);
+  do_check_true(profileBookmarksJSONFile.exists());
+  return profileBookmarksJSONFile;
+}
+
+
+/**
+ * Remove bookmarksbackup dir and all backups from the profile folder.
+ */
+function remove_all_JSON_backups() {
+  let bookmarksBackupDir = gProfD.clone();
+  bookmarksBackupDir.append("bookmarkbackups");
+  if (bookmarksBackupDir.exists()) {
+    bookmarksBackupDir.remove(true);
+    do_check_false(bookmarksBackupDir.exists());
+  }
+}
+
+
+/**
+ * Check a JSON backup file for today exists in the profile folder.
+ *
+ * @param aIsAutomaticBackup The boolean indicates whether it's an automatic
+ *        backup.
+ * @return nsIFile object for the file.
+ */
+function check_JSON_backup(aIsAutomaticBackup) {
+  let profileBookmarksJSONFile;
+  if (aIsAutomaticBackup) {
+    let bookmarksBackupDir = gProfD.clone();
+    bookmarksBackupDir.append("bookmarkbackups");
+    let files = bookmarksBackupDir.directoryEntries;
+    while (files.hasMoreElements()) {
+      let entry = files.getNext().QueryInterface(Ci.nsIFile);
+      if (PlacesBackups.filenamesRegex.test(entry.leafName)) {
+        profileBookmarksJSONFile = entry;
+        break;
+      }
+    }
+  } else {
+    profileBookmarksJSONFile = gProfD.clone();
+    profileBookmarksJSONFile.append("bookmarkbackups");
+    profileBookmarksJSONFile.append(FILENAME_BOOKMARKS_JSON);
+  }
+  do_check_true(profileBookmarksJSONFile.exists());
+  return profileBookmarksJSONFile;
+}
+
+/**
+ * Returns the frecency of a url.
+ *
+ * @param aURI
+ *        The URI or spec to get frecency for.
+ * @return the frecency value.
+ */
+function frecencyForUrl(aURI)
+{
+  let url = aURI;
+  if (aURI instanceof Ci.nsIURI) {
+    url = aURI.spec;
+  } else if (aURI instanceof URL) {
+    url = aURI.href;
+  }
+  let stmt = DBConn().createStatement(
+    "SELECT frecency FROM moz_places WHERE url_hash = hash(?1) AND url = ?1"
+  );
+  stmt.bindByIndex(0, url);
+  try {
+    if (!stmt.executeStep()) {
+      throw new Error("No result for frecency.");
+    }
+    return stmt.getInt32(0);
+  } finally {
+    stmt.finalize();
+  }
+}
+
+/**
+ * Returns the hidden status of a url.
+ *
+ * @param aURI
+ *        The URI or spec to get hidden for.
+ * @return @return true if the url is hidden, false otherwise.
+ */
+function isUrlHidden(aURI)
+{
+  let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
+  let stmt = DBConn().createStatement(
+    "SELECT hidden FROM moz_places WHERE url_hash = hash(?1) AND url = ?1"
+  );
+  stmt.bindByIndex(0, url);
+  if (!stmt.executeStep())
+    throw new Error("No result for hidden.");
+  let hidden = stmt.getInt32(0);
+  stmt.finalize();
+
+  return !!hidden;
+}
+
+/**
+ * Compares two times in usecs, considering eventual platform timers skews.
+ *
+ * @param aTimeBefore
+ *        The older time in usecs.
+ * @param aTimeAfter
+ *        The newer time in usecs.
+ * @return true if times are ordered, false otherwise.
+ */
+function is_time_ordered(before, after) {
+  // Windows has an estimated 16ms timers precision, since Date.now() and
+  // PR_Now() use different code atm, the results can be unordered by this
+  // amount of time.  See bug 558745 and bug 557406.
+  let isWindows = ("@mozilla.org/windows-registry-key;1" in Cc);
+  // Just to be safe we consider 20ms.
+  let skew = isWindows ? 20000000 : 0;
+  return after - before > -skew;
+}
+
+/**
+ * Shutdowns Places, invoking the callback when the connection has been closed.
+ *
+ * @param aCallback
+ *        Function to be called when done.
+ */
+function waitForConnectionClosed(aCallback)
+{
+  promiseTopicObserved("places-connection-closed").then(aCallback);
+  shutdownPlaces();
+}
+
+/**
+ * Tests if a given guid is valid for use in Places or not.
+ *
+ * @param aGuid
+ *        The guid to test.
+ * @param [optional] aStack
+ *        The stack frame used to report the error.
+ */
+function do_check_valid_places_guid(aGuid,
+                                    aStack)
+{
+  if (!aStack) {
+    aStack = Components.stack.caller;
+  }
+  do_check_true(/^[a-zA-Z0-9\-_]{12}$/.test(aGuid), aStack);
+}
+
+/**
+ * Retrieves the guid for a given uri.
+ *
+ * @param aURI
+ *        The uri to check.
+ * @param [optional] aStack
+ *        The stack frame used to report the error.
+ * @return the associated the guid.
+ */
+function do_get_guid_for_uri(aURI,
+                             aStack)
+{
+  if (!aStack) {
+    aStack = Components.stack.caller;
+  }
+  let stmt = DBConn().createStatement(
+    `SELECT guid
+     FROM moz_places
+     WHERE url_hash = hash(:url) AND url = :url`
+  );
+  stmt.params.url = aURI.spec;
+  do_check_true(stmt.executeStep(), aStack);
+  let guid = stmt.row.guid;
+  stmt.finalize();
+  do_check_valid_places_guid(guid, aStack);
+  return guid;
+}
+
+/**
+ * Tests that a guid was set in moz_places for a given uri.
+ *
+ * @param aURI
+ *        The uri to check.
+ * @param [optional] aGUID
+ *        The expected guid in the database.
+ */
+function do_check_guid_for_uri(aURI,
+                               aGUID)
+{
+  let caller = Components.stack.caller;
+  let guid = do_get_guid_for_uri(aURI, caller);
+  if (aGUID) {
+    do_check_valid_places_guid(aGUID, caller);
+    do_check_eq(guid, aGUID, caller);
+  }
+}
+
+/**
+ * Retrieves the guid for a given bookmark.
+ *
+ * @param aId
+ *        The bookmark id to check.
+ * @param [optional] aStack
+ *        The stack frame used to report the error.
+ * @return the associated the guid.
+ */
+function do_get_guid_for_bookmark(aId,
+                                  aStack)
+{
+  if (!aStack) {
+    aStack = Components.stack.caller;
+  }
+  let stmt = DBConn().createStatement(
+    `SELECT guid
+     FROM moz_bookmarks
+     WHERE id = :item_id`
+  );
+  stmt.params.item_id = aId;
+  do_check_true(stmt.executeStep(), aStack);
+  let guid = stmt.row.guid;
+  stmt.finalize();
+  do_check_valid_places_guid(guid, aStack);
+  return guid;
+}
+
+/**
+ * Tests that a guid was set in moz_places for a given bookmark.
+ *
+ * @param aId
+ *        The bookmark id to check.
+ * @param [optional] aGUID
+ *        The expected guid in the database.
+ */
+function do_check_guid_for_bookmark(aId,
+                                    aGUID)
+{
+  let caller = Components.stack.caller;
+  let guid = do_get_guid_for_bookmark(aId, caller);
+  if (aGUID) {
+    do_check_valid_places_guid(aGUID, caller);
+    do_check_eq(guid, aGUID, caller);
+  }
+}
+
+/**
+ * Compares 2 arrays returning whether they contains the same elements.
+ *
+ * @param a1
+ *        First array to compare.
+ * @param a2
+ *        Second array to compare.
+ * @param [optional] sorted
+ *        Whether the comparison should take in count position of the elements.
+ * @return true if the arrays contain the same elements, false otherwise.
+ */
+function do_compare_arrays(a1, a2, sorted)
+{
+  if (a1.length != a2.length)
+    return false;
+
+  if (sorted) {
+    return a1.every((e, i) => e == a2[i]);
+  }
+  return a1.filter(e => !a2.includes(e)).length == 0 &&
+         a2.filter(e => !a1.includes(e)).length == 0;
+}
+
+/**
+ * Generic nsINavBookmarkObserver that doesn't implement anything, but provides
+ * dummy methods to prevent errors about an object not having a certain method.
+ */
+function NavBookmarkObserver() {}
+
+NavBookmarkObserver.prototype = {
+  onBeginUpdateBatch: function () {},
+  onEndUpdateBatch: function () {},
+  onItemAdded: function () {},
+  onItemRemoved: function () {},
+  onItemChanged: function () {},
+  onItemVisited: function () {},
+  onItemMoved: function () {},
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsINavBookmarkObserver,
+  ])
+};
+
+/**
+ * Generic nsINavHistoryObserver that doesn't implement anything, but provides
+ * dummy methods to prevent errors about an object not having a certain method.
+ */
+function NavHistoryObserver() {}
+
+NavHistoryObserver.prototype = {
+  onBeginUpdateBatch: function () {},
+  onEndUpdateBatch: function () {},
+  onVisit: function () {},
+  onTitleChanged: function () {},
+  onDeleteURI: function () {},
+  onClearHistory: function () {},
+  onPageChanged: function () {},
+  onDeleteVisits: function () {},
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsINavHistoryObserver,
+  ])
+};
+
+/**
+ * Generic nsINavHistoryResultObserver that doesn't implement anything, but
+ * provides dummy methods to prevent errors about an object not having a certain
+ * method.
+ */
+function NavHistoryResultObserver() {}
+
+NavHistoryResultObserver.prototype = {
+  batching: function () {},
+  containerStateChanged: function () {},
+  invalidateContainer: function () {},
+  nodeAnnotationChanged: function () {},
+  nodeDateAddedChanged: function () {},
+  nodeHistoryDetailsChanged: function () {},
+  nodeIconChanged: function () {},
+  nodeInserted: function () {},
+  nodeKeywordChanged: function () {},
+  nodeLastModifiedChanged: function () {},
+  nodeMoved: function () {},
+  nodeRemoved: function () {},
+  nodeTagsChanged: function () {},
+  nodeTitleChanged: function () {},
+  nodeURIChanged: function () {},
+  sortingChanged: function () {},
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsINavHistoryResultObserver,
+  ])
+};
+
+/**
+ * Asynchronously check a url is visited.
+ *
+ * @param aURI The URI.
+ * @return {Promise}
+ * @resolves When the check has been added successfully.
+ * @rejects JavaScript exception.
+ */
+function promiseIsURIVisited(aURI) {
+  let deferred = Promise.defer();
+
+  PlacesUtils.asyncHistory.isURIVisited(aURI, function(unused, aIsVisited) {
+    deferred.resolve(aIsVisited);
+  });
+
+  return deferred.promise;
+}
+
+/**
+ * Asynchronously set the favicon associated with a page.
+ * @param aPageURI
+ *        The page's URI
+ * @param aIconURI
+ *        The URI of the favicon to be set.
+ */
+function promiseSetIconForPage(aPageURI, aIconURI) {
+  let deferred = Promise.defer();
+  PlacesUtils.favicons.setAndFetchFaviconForPage(
+    aPageURI, aIconURI, true,
+    PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    () => { deferred.resolve(); },
+    Services.scriptSecurityManager.getSystemPrincipal());
+  return deferred.promise;
+}
+
+function checkBookmarkObject(info) {
+  do_check_valid_places_guid(info.guid);
+  do_check_valid_places_guid(info.parentGuid);
+  Assert.ok(typeof info.index == "number", "index should be a number");
+  Assert.ok(info.dateAdded.constructor.name == "Date", "dateAdded should be a Date");
+  Assert.ok(info.lastModified.constructor.name == "Date", "lastModified should be a Date");
+  Assert.ok(info.lastModified >= info.dateAdded, "lastModified should never be smaller than dateAdded");
+  Assert.ok(typeof info.type == "number", "type should be a number");
+}
+
+/**
+ * Reads foreign_count value for a given url.
+ */
+function* foreign_count(url) {
+  if (url instanceof Ci.nsIURI)
+    url = url.spec;
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.executeCached(
+    `SELECT foreign_count FROM moz_places
+     WHERE url_hash = hash(:url) AND url = :url
+    `, { url });
+  return rows.length == 0 ? 0 : rows[0].getResultByName("foreign_count");
+}
diff --git a/toolkit/components/places/tests/history/.eslintrc.js b/toolkit/components/places/tests/history/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/places/tests/history/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/history/head_history.js b/toolkit/components/places/tests/history/head_history.js
new file mode 100644
index 000000000..870802dc1
--- /dev/null
+++ b/toolkit/components/places/tests/history/head_history.js
@@ -0,0 +1,19 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+// Import common head.
+{
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
diff --git a/toolkit/components/places/tests/history/test_insert.js b/toolkit/components/places/tests/history/test_insert.js
new file mode 100644
index 000000000..e2884af8c
--- /dev/null
+++ b/toolkit/components/places/tests/history/test_insert.js
@@ -0,0 +1,257 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+
+// Tests for `History.insert` and `History.insertMany`, as implemented in History.jsm
+
+"use strict";
+
+add_task(function* test_insert_error_cases() {
+  const TEST_URL = "http://mozilla.com";
+
+  Assert.throws(
+    () =>  PlacesUtils.history.insert(),
+    /TypeError: pageInfo must be an object/,
+    "passing a null into History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert(1),
+    /TypeError: pageInfo must be an object/,
+    "passing a non object into History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({}),
+    /TypeError: PageInfo object must have a url property/,
+    "passing an object without a url to History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({url: 123}),
+    /TypeError: Invalid url or guid: 123/,
+    "passing an object with an invalid url to History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({url: TEST_URL}),
+    /TypeError: PageInfo object must have an array of visits/,
+    "passing an object without a visits property to History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({url: TEST_URL, visits: 1}),
+    /TypeError: PageInfo object must have an array of visits/,
+    "passing an object with a non-array visits property to History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({url: TEST_URL, visits: []}),
+    /TypeError: PageInfo object must have an array of visits/,
+    "passing an object with an empty array as the visits property to History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({
+      url: TEST_URL,
+      visits: [
+        {
+          transition: TRANSITION_LINK,
+          date: "a"
+        }
+      ]}),
+    /TypeError: Expected a Date, got a/,
+    "passing a visit object with an invalid date to History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({
+      url: TEST_URL,
+      visits: [
+        {
+          transition: TRANSITION_LINK
+        },
+        {
+          transition: TRANSITION_LINK,
+          date: "a"
+        }
+      ]}),
+    /TypeError: Expected a Date, got a/,
+    "passing a second visit object with an invalid date to History.insert should throw a TypeError"
+  );
+  let futureDate = new Date();
+  futureDate.setDate(futureDate.getDate() + 1000);
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({
+      url: TEST_URL,
+      visits: [
+        {
+          transition: TRANSITION_LINK,
+          date: futureDate,
+        }
+      ]}),
+    `TypeError: date: ${futureDate} is not a valid date`,
+    "passing a visit object with a future date to History.insert should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insert({
+      url: TEST_URL,
+      visits: [
+        {transition: "a"}
+      ]}),
+    /TypeError: transition: a is not a valid transition type/,
+    "passing a visit object with an invalid transition to History.insert should throw a TypeError"
+  );
+});
+
+add_task(function* test_history_insert() {
+  const TEST_URL = "http://mozilla.com/";
+
+  let inserter = Task.async(function*(name, filter, referrer, date, transition) {
+    do_print(name);
+    do_print(`filter: ${filter}, referrer: ${referrer}, date: ${date}, transition: ${transition}`);
+
+    let uri = NetUtil.newURI(TEST_URL + Math.random());
+    let title = "Visit " + Math.random();
+
+    let pageInfo = {
+      title,
+      visits: [
+        {transition: transition, referrer: referrer, date: date, }
+      ]
+    };
+
+    pageInfo.url = yield filter(uri);
+
+    let result = yield PlacesUtils.history.insert(pageInfo);
+
+    Assert.ok(PlacesUtils.isValidGuid(result.guid), "guid for pageInfo object is valid");
+    Assert.equal(uri.spec, result.url.href, "url is correct for pageInfo object");
+    Assert.equal(title, result.title, "title is correct for pageInfo object");
+    Assert.equal(TRANSITION_LINK, result.visits[0].transition, "transition is correct for pageInfo object");
+    if (referrer) {
+      Assert.equal(referrer, result.visits[0].referrer.href, "url of referrer for visit is correct");
+    } else {
+      Assert.equal(null, result.visits[0].referrer, "url of referrer for visit is correct");
+    }
+    if (date) {
+      Assert.equal(Number(date),
+                   Number(result.visits[0].date),
+                   "date of visit is correct");
+    }
+
+    Assert.ok(yield PlacesTestUtils.isPageInDB(uri), "Page was added");
+    Assert.ok(yield PlacesTestUtils.visitsInDB(uri), "Visit was added");
+  });
+
+  try {
+    for (let referrer of [TEST_URL, null]) {
+      for (let date of [new Date(), null]) {
+        for (let transition of [TRANSITION_LINK, null]) {
+          yield inserter("Testing History.insert() with an nsIURI", x => x, referrer, date, transition);
+          yield inserter("Testing History.insert() with a string url", x => x.spec, referrer, date, transition);
+          yield inserter("Testing History.insert() with a URL object", x => new URL(x.spec), referrer, date, transition);
+        }
+      }
+    }
+  } finally {
+    yield PlacesTestUtils.clearHistory();
+  }
+});
+
+add_task(function* test_insert_multiple_error_cases() {
+  let validPageInfo = {
+    url: "http://mozilla.com",
+    visits: [
+      {transition: TRANSITION_LINK}
+    ]
+  };
+
+  Assert.throws(
+    () =>  PlacesUtils.history.insertMany(),
+    /TypeError: pageInfos must be an array/,
+    "passing a null into History.insertMany should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insertMany([]),
+    /TypeError: pageInfos may not be an empty array/,
+    "passing an empty array into History.insertMany should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.insertMany([validPageInfo, {}]),
+    /TypeError: PageInfo object must have a url property/,
+    "passing a second invalid PageInfo object to History.insertMany should throw a TypeError"
+  );
+});
+
+add_task(function* test_history_insertMany() {
+  const BAD_URLS = ["about:config", "chrome://browser/content/browser.xul"];
+  const GOOD_URLS = [1, 2, 3].map(x => { return `http://mozilla.com/${x}`; });
+
+  let makePageInfos = Task.async(function*(urls, filter = x => x) {
+    let pageInfos = [];
+    for (let url of urls) {
+      let uri = NetUtil.newURI(url);
+
+      let pageInfo = {
+        title: `Visit to ${url}`,
+        visits: [
+          {transition: TRANSITION_LINK}
+        ]
+      };
+
+      pageInfo.url = yield filter(uri);
+      pageInfos.push(pageInfo);
+    }
+    return pageInfos;
+  });
+
+  let inserter = Task.async(function*(name, filter, useCallbacks) {
+    do_print(name);
+    do_print(`filter: ${filter}`);
+    do_print(`useCallbacks: ${useCallbacks}`);
+    yield PlacesTestUtils.clearHistory();
+
+    let result;
+    let allUrls = GOOD_URLS.concat(BAD_URLS);
+    let pageInfos = yield makePageInfos(allUrls, filter);
+
+    if (useCallbacks) {
+      let onResultUrls = [];
+      let onErrorUrls = [];
+      result = yield PlacesUtils.history.insertMany(pageInfos, pageInfo => {
+        let url = pageInfo.url.href;
+        Assert.ok(GOOD_URLS.includes(url), "onResult callback called for correct url");
+        onResultUrls.push(url);
+        Assert.equal(`Visit to ${url}`, pageInfo.title, "onResult callback provides the correct title");
+        Assert.ok(PlacesUtils.isValidGuid(pageInfo.guid), "onResult callback provides a valid guid");
+      }, pageInfo => {
+        let url = pageInfo.url.href;
+        Assert.ok(BAD_URLS.includes(url), "onError callback called for correct uri");
+        onErrorUrls.push(url);
+        Assert.equal(undefined, pageInfo.title, "onError callback provides the correct title");
+        Assert.equal(undefined, pageInfo.guid, "onError callback provides the expected guid");
+      });
+      Assert.equal(GOOD_URLS.sort().toString(), onResultUrls.sort().toString(), "onResult callback was called for each good url");
+      Assert.equal(BAD_URLS.sort().toString(), onErrorUrls.sort().toString(), "onError callback was called for each bad url");
+    } else {
+      result = yield PlacesUtils.history.insertMany(pageInfos);
+    }
+
+    Assert.equal(undefined, result, "insertMany returned undefined");
+
+    for (let url of allUrls) {
+      let expected = GOOD_URLS.includes(url);
+      Assert.equal(expected, yield PlacesTestUtils.isPageInDB(url), `isPageInDB for ${url} is ${expected}`);
+      Assert.equal(expected, yield PlacesTestUtils.visitsInDB(url), `visitsInDB for ${url} is ${expected}`);
+    }
+  });
+
+  try {
+    for (let useCallbacks of [false, true]) {
+      yield inserter("Testing History.insertMany() with an nsIURI", x => x, useCallbacks);
+      yield inserter("Testing History.insertMany() with a string url", x => x.spec, useCallbacks);
+      yield inserter("Testing History.insertMany() with a URL object", x => new URL(x.spec), useCallbacks);
+    }
+    // Test rejection when no items added
+    let pageInfos = yield makePageInfos(BAD_URLS);
+    PlacesUtils.history.insertMany(pageInfos).then(() => {
+      Assert.ok(false, "History.insertMany rejected promise with all bad URLs");
+    }, error => {
+      Assert.equal("No items were added to history.", error.message, "History.insertMany rejected promise with all bad URLs");
+    });
+  } finally {
+    yield PlacesTestUtils.clearHistory();
+  }
+});
diff --git a/toolkit/components/places/tests/history/test_remove.js b/toolkit/components/places/tests/history/test_remove.js
new file mode 100644
index 000000000..7423f6464
--- /dev/null
+++ b/toolkit/components/places/tests/history/test_remove.js
@@ -0,0 +1,360 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+
+// Tests for `History.remove`, as implemented in History.jsm
+
+"use strict";
+
+Cu.importGlobalProperties(["URL"]);
+
+
+// Test removing a single page
+add_task(function* test_remove_single() {
+  yield PlacesTestUtils.clearHistory();
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+
+  let WITNESS_URI = NetUtil.newURI("http://mozilla.com/test_browserhistory/test_remove/" + Math.random());
+  yield PlacesTestUtils.addVisits(WITNESS_URI);
+  Assert.ok(page_in_database(WITNESS_URI));
+
+  let remover = Task.async(function*(name, filter, options) {
+    do_print(name);
+    do_print(JSON.stringify(options));
+    do_print("Setting up visit");
+
+    let uri = NetUtil.newURI("http://mozilla.com/test_browserhistory/test_remove/" + Math.random());
+    let title = "Visit " + Math.random();
+    yield PlacesTestUtils.addVisits({uri: uri, title: title});
+    Assert.ok(visits_in_database(uri), "History entry created");
+
+    let removeArg = yield filter(uri);
+
+    if (options.addBookmark) {
+      PlacesUtils.bookmarks.insertBookmark(
+        PlacesUtils.unfiledBookmarksFolderId,
+        uri,
+        PlacesUtils.bookmarks.DEFAULT_INDEX,
+        "test bookmark");
+    }
+
+    let shouldRemove = !options.addBookmark;
+    let observer;
+    let promiseObserved = new Promise((resolve, reject) => {
+      observer = {
+        onBeginUpdateBatch: function() {},
+        onEndUpdateBatch: function() {},
+        onVisit: function(aUri) {
+          reject(new Error("Unexpected call to onVisit " + aUri.spec));
+        },
+        onTitleChanged: function(aUri) {
+          reject(new Error("Unexpected call to onTitleChanged " + aUri.spec));
+        },
+        onClearHistory: function() {
+          reject("Unexpected call to onClearHistory");
+        },
+        onPageChanged: function(aUri) {
+          reject(new Error("Unexpected call to onPageChanged " + aUri.spec));
+        },
+        onFrecencyChanged: function(aURI) {
+          try {
+            Assert.ok(!shouldRemove, "Observing onFrecencyChanged");
+            Assert.equal(aURI.spec, uri.spec, "Observing effect on the right uri");
+          } finally {
+            resolve();
+          }
+        },
+        onManyFrecenciesChanged: function() {
+          try {
+            Assert.ok(!shouldRemove, "Observing onManyFrecenciesChanged");
+          } finally {
+            resolve();
+          }
+        },
+        onDeleteURI: function(aURI) {
+          try {
+            Assert.ok(shouldRemove, "Observing onDeleteURI");
+            Assert.equal(aURI.spec, uri.spec, "Observing effect on the right uri");
+          } finally {
+            resolve();
+          }
+        },
+        onDeleteVisits: function(aURI) {
+          Assert.equal(aURI.spec, uri.spec, "Observing onDeleteVisits on the right uri");
+        }
+      };
+    });
+    PlacesUtils.history.addObserver(observer, false);
+
+    do_print("Performing removal");
+    let removed = false;
+    if (options.useCallback) {
+      let onRowCalled = false;
+      let guid = do_get_guid_for_uri(uri);
+      removed = yield PlacesUtils.history.remove(removeArg, page => {
+        Assert.equal(onRowCalled, false, "Callback has not been called yet");
+        onRowCalled = true;
+        Assert.equal(page.url.href, uri.spec, "Callback provides the correct url");
+        Assert.equal(page.guid, guid, "Callback provides the correct guid");
+        Assert.equal(page.title, title, "Callback provides the correct title");
+      });
+      Assert.ok(onRowCalled, "Callback has been called");
+    } else {
+      removed = yield PlacesUtils.history.remove(removeArg);
+    }
+
+    yield promiseObserved;
+    PlacesUtils.history.removeObserver(observer);
+
+    Assert.equal(visits_in_database(uri), 0, "History entry has disappeared");
+    Assert.notEqual(visits_in_database(WITNESS_URI), 0, "Witness URI still has visits");
+    Assert.notEqual(page_in_database(WITNESS_URI), 0, "Witness URI is still here");
+    if (shouldRemove) {
+      Assert.ok(removed, "Something was removed");
+      Assert.equal(page_in_database(uri), 0, "Page has disappeared");
+    } else {
+      Assert.ok(!removed, "The page was not removed, as there was a bookmark");
+      Assert.notEqual(page_in_database(uri), 0, "The page is still present");
+    }
+  });
+
+  try {
+    for (let useCallback of [false, true]) {
+      for (let addBookmark of [false, true]) {
+        let options = { useCallback: useCallback, addBookmark: addBookmark };
+        yield remover("Testing History.remove() with a single URI", x => x, options);
+        yield remover("Testing History.remove() with a single string url", x => x.spec, options);
+        yield remover("Testing History.remove() with a single string guid", x => do_get_guid_for_uri(x), options);
+        yield remover("Testing History.remove() with a single URI in an array", x => [x], options);
+        yield remover("Testing History.remove() with a single string url in an array", x => [x.spec], options);
+        yield remover("Testing History.remove() with a single string guid in an array", x => [do_get_guid_for_uri(x)], options);
+      }
+    }
+  } finally {
+    yield PlacesTestUtils.clearHistory();
+  }
+  return;
+});
+
+// Test removing a list of pages
+add_task(function* test_remove_many() {
+  const SIZE = 10;
+
+  yield PlacesTestUtils.clearHistory();
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  do_print("Adding a witness page");
+  let WITNESS_URI = NetUtil.newURI("http://mozilla.com/test_browserhistory/test_remove/" + Math.random());
+  yield PlacesTestUtils.addVisits(WITNESS_URI);
+  Assert.ok(page_in_database(WITNESS_URI), "Witness page added");
+
+  do_print("Generating samples");
+  let pages = [];
+  for (let i = 0; i < SIZE; ++i) {
+    let uri = NetUtil.newURI("http://mozilla.com/test_browserhistory/test_remove?sample=" + i + "&salt=" + Math.random());
+    let title = "Visit " + i + ", " + Math.random();
+    let hasBookmark = i % 3 == 0;
+    let page = {
+      uri: uri,
+      title: title,
+      hasBookmark: hasBookmark,
+      // `true` once `onResult` has been called for this page
+      onResultCalled: false,
+      // `true` once `onDeleteVisits` has been called for this page
+      onDeleteVisitsCalled: false,
+      // `true` once `onFrecencyChangedCalled` has been called for this page
+      onFrecencyChangedCalled: false,
+      // `true` once `onDeleteURI` has been called for this page
+      onDeleteURICalled: false,
+    };
+    do_print("Pushing: " + uri.spec);
+    pages.push(page);
+
+    yield PlacesTestUtils.addVisits(page);
+    page.guid = do_get_guid_for_uri(uri);
+    if (hasBookmark) {
+      PlacesUtils.bookmarks.insertBookmark(
+        PlacesUtils.unfiledBookmarksFolderId,
+        uri,
+        PlacesUtils.bookmarks.DEFAULT_INDEX,
+        "test bookmark " + i);
+    }
+    Assert.ok(page_in_database(uri), "Page added");
+  }
+
+  do_print("Mixing key types and introducing dangling keys");
+  let keys = [];
+  for (let i = 0; i < SIZE; ++i) {
+    if (i % 4 == 0) {
+      keys.push(pages[i].uri);
+      keys.push(NetUtil.newURI("http://example.org/dangling/nsIURI/" + i));
+    } else if (i % 4 == 1) {
+      keys.push(new URL(pages[i].uri.spec));
+      keys.push(new URL("http://example.org/dangling/URL/" + i));
+    } else if (i % 4 == 2) {
+      keys.push(pages[i].uri.spec);
+      keys.push("http://example.org/dangling/stringuri/" + i);
+    } else {
+      keys.push(pages[i].guid);
+      keys.push(("guid_" + i + "_01234567890").substr(0, 12));
+    }
+  }
+
+  let observer = {
+    onBeginUpdateBatch: function() {},
+    onEndUpdateBatch: function() {},
+    onVisit: function(aURI) {
+      Assert.ok(false, "Unexpected call to onVisit " + aURI.spec);
+    },
+    onTitleChanged: function(aURI) {
+      Assert.ok(false, "Unexpected call to onTitleChanged " + aURI.spec);
+    },
+    onClearHistory: function() {
+      Assert.ok(false, "Unexpected call to onClearHistory");
+    },
+    onPageChanged: function(aURI) {
+      Assert.ok(false, "Unexpected call to onPageChanged " + aURI.spec);
+    },
+    onFrecencyChanged: function(aURI) {
+      let origin = pages.find(x =>  x.uri.spec == aURI.spec);
+      Assert.ok(origin);
+      Assert.ok(origin.hasBookmark, "Observing onFrecencyChanged on a page with a bookmark");
+      origin.onFrecencyChangedCalled = true;
+      // We do not make sure that `origin.onFrecencyChangedCalled` is `false`, as
+    },
+    onManyFrecenciesChanged: function() {
+      Assert.ok(false, "Observing onManyFrecenciesChanges, this is most likely correct but not covered by this test");
+    },
+    onDeleteURI: function(aURI) {
+      let origin = pages.find(x => x.uri.spec == aURI.spec);
+      Assert.ok(origin);
+      Assert.ok(!origin.hasBookmark, "Observing onDeleteURI on a page without a bookmark");
+      Assert.ok(!origin.onDeleteURICalled, "Observing onDeleteURI for the first time");
+      origin.onDeleteURICalled = true;
+    },
+    onDeleteVisits: function(aURI) {
+      let origin = pages.find(x => x.uri.spec == aURI.spec);
+      Assert.ok(origin);
+      Assert.ok(!origin.onDeleteVisitsCalled, "Observing onDeleteVisits for the first time");
+      origin.onDeleteVisitsCalled = true;
+    }
+  };
+  PlacesUtils.history.addObserver(observer, false);
+
+  do_print("Removing the pages and checking the callbacks");
+  let removed = yield PlacesUtils.history.remove(keys, page => {
+    let origin = pages.find(candidate => candidate.uri.spec == page.url.href);
+
+    Assert.ok(origin, "onResult has a valid page");
+    Assert.ok(!origin.onResultCalled, "onResult has not seen this page yet");
+    origin.onResultCalled = true;
+    Assert.equal(page.guid, origin.guid, "onResult has the right guid");
+    Assert.equal(page.title, origin.title, "onResult has the right title");
+  });
+  Assert.ok(removed, "Something was removed");
+
+  PlacesUtils.history.removeObserver(observer);
+
+  do_print("Checking out results");
+  // By now the observers should have been called.
+  for (let i = 0; i < pages.length; ++i) {
+    let page = pages[i];
+    do_print("Page: " + i);
+    Assert.ok(page.onResultCalled, "We have reached the page from the callback");
+    Assert.ok(visits_in_database(page.uri) == 0, "History entry has disappeared");
+    Assert.equal(page_in_database(page.uri) != 0, page.hasBookmark, "Page is present only if it also has bookmarks");
+    Assert.equal(page.onFrecencyChangedCalled, page.onDeleteVisitsCalled, "onDeleteVisits was called iff onFrecencyChanged was called");
+    Assert.ok(page.onFrecencyChangedCalled ^ page.onDeleteURICalled, "Either onFrecencyChanged or onDeleteURI was called");
+  }
+
+  Assert.notEqual(visits_in_database(WITNESS_URI), 0, "Witness URI still has visits");
+  Assert.notEqual(page_in_database(WITNESS_URI), 0, "Witness URI is still here");
+});
+
+add_task(function* cleanup() {
+  yield PlacesTestUtils.clearHistory();
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+// Test the various error cases
+add_task(function* test_error_cases() {
+  Assert.throws(
+    () =>  PlacesUtils.history.remove(),
+    /TypeError: Invalid url/,
+    "History.remove with no argument should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.remove(null),
+    /TypeError: Invalid url/,
+    "History.remove with `null` should throw a TypeError"
+  );
+  Assert.throws(
+    () =>  PlacesUtils.history.remove(undefined),
+    /TypeError: Invalid url/,
+    "History.remove with `undefined` should throw a TypeError"
+  );
+  Assert.throws(
+    () => PlacesUtils.history.remove("not a guid, obviously"),
+    /TypeError: .* is not a valid URL/,
+    "History.remove with an ill-formed guid/url argument should throw a TypeError"
+  );
+  Assert.throws(
+    () => PlacesUtils.history.remove({"not the kind of object we know how to handle": true}),
+    /TypeError: Invalid url/,
+    "History.remove with an unexpected object should throw a TypeError"
+  );
+  Assert.throws(
+    () => PlacesUtils.history.remove([]),
+    /TypeError: Expected at least one page/,
+    "History.remove with an empty array should throw a TypeError"
+  );
+  Assert.throws(
+    () => PlacesUtils.history.remove([null]),
+    /TypeError: Invalid url or guid/,
+    "History.remove with an array containing null should throw a TypeError"
+  );
+  Assert.throws(
+    () => PlacesUtils.history.remove(["http://example.org", "not a guid, obviously"]),
+    /TypeError: .* is not a valid URL/,
+    "History.remove with an array containing an ill-formed guid/url argument should throw a TypeError"
+  );
+  Assert.throws(
+    () => PlacesUtils.history.remove(["0123456789ab"/* valid guid*/, null]),
+    /TypeError: Invalid url or guid: null/,
+    "History.remove with an array containing a guid and a second argument that is null should throw a TypeError"
+  );
+  Assert.throws(
+    () => PlacesUtils.history.remove(["http://example.org", {"not the kind of object we know how to handle": true}]),
+    /TypeError: Invalid url/,
+    "History.remove with an array containing an unexpected objecgt should throw a TypeError"
+  );
+  Assert.throws(
+    () => PlacesUtils.history.remove("http://example.org", "not a function, obviously"),
+    /TypeError: Invalid function/,
+    "History.remove with a second argument that is not a function argument should throw a TypeError"
+  );
+  try {
+    PlacesUtils.history.remove("http://example.org/I/have/clearly/not/been/added", null);
+    Assert.ok(true, "History.remove should ignore `null` as a second argument");
+  } catch (ex) {
+    Assert.ok(false, "History.remove should ignore `null` as a second argument");
+  }
+});
+
+add_task(function* test_orphans() {
+  let uri = NetUtil.newURI("http://moz.org/");
+  yield PlacesTestUtils.addVisits({ uri });
+
+  PlacesUtils.favicons.setAndFetchFaviconForPage(
+    uri, SMALLPNG_DATA_URI, true,  PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    null, Services.scriptSecurityManager.getSystemPrincipal());
+  PlacesUtils.annotations.setPageAnnotation(uri, "test", "restval", 0,
+                                            PlacesUtils.annotations.EXPIRE_NEVER);
+
+  yield PlacesUtils.history.remove(uri);
+  Assert.ok(!(yield PlacesTestUtils.isPageInDB(uri)), "Page should have been removed");
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.execute(`SELECT (SELECT count(*) FROM moz_annos) +
+                                      (SELECT count(*) FROM moz_favicons) AS count`);
+  Assert.equal(rows[0].getResultByName("count"), 0, "Should not find orphans");
+});
diff --git a/toolkit/components/places/tests/history/test_removeVisits.js b/toolkit/components/places/tests/history/test_removeVisits.js
new file mode 100644
index 000000000..8df0c81a9
--- /dev/null
+++ b/toolkit/components/places/tests/history/test_removeVisits.js
@@ -0,0 +1,316 @@
+const JS_NOW = Date.now();
+const DB_NOW = JS_NOW * 1000;
+const TEST_URI = uri("http://example.com/");
+const PLACE_URI = uri("place:queryType=0&sort=8&maxResults=10");
+
+function* cleanup() {
+  yield PlacesTestUtils.clearHistory();
+  yield PlacesUtils.bookmarks.eraseEverything();
+  // This is needed to remove place: entries.
+  DBConn().executeSimpleSQL("DELETE FROM moz_places");
+}
+
+add_task(function* remove_visits_outside_unbookmarked_uri() {
+  do_print("*** TEST: Remove some visits outside valid timeframe from an unbookmarked URI");
+
+  do_print("Add 10 visits for the URI from way in the past.");
+  let visits = [];
+  for (let i = 0; i < 10; i++) {
+    visits.push({ uri: TEST_URI, visitDate: DB_NOW - 100000 - (i * 1000) });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+
+  do_print("Remove visits using timerange outside the URI's visits.");
+  let filter = {
+    beginDate: new Date(JS_NOW - 10),
+    endDate: new Date(JS_NOW)
+  };
+  yield PlacesUtils.history.removeVisitsByFilter(filter);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("URI should still exist in moz_places.");
+  do_check_true(page_in_database(TEST_URI.spec));
+
+  do_print("Run a history query and check that all visits still exist.");
+  let query = PlacesUtils.history.getNewQuery();
+  let opts = PlacesUtils.history.getNewQueryOptions();
+  opts.resultType = opts.RESULTS_AS_VISIT;
+  opts.sortingMode = opts.SORT_BY_DATE_DESCENDING;
+  let root = PlacesUtils.history.executeQuery(query, opts).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 10);
+  for (let i = 0; i < root.childCount; i++) {
+    let visitTime = root.getChild(i).time;
+    do_check_eq(visitTime, DB_NOW - 100000 - (i * 1000));
+  }
+  root.containerOpen = false;
+
+  do_print("asyncHistory.isURIVisited should return true.");
+  do_check_true(yield promiseIsURIVisited(TEST_URI));
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("Frecency should be positive.")
+  do_check_true(frecencyForUrl(TEST_URI) > 0);
+
+  yield cleanup();
+});
+
+add_task(function* remove_visits_outside_bookmarked_uri() {
+  do_print("*** TEST: Remove some visits outside valid timeframe from a bookmarked URI");
+
+  do_print("Add 10 visits for the URI from way in the past.");
+  let visits = [];
+  for (let i = 0; i < 10; i++) {
+    visits.push({ uri: TEST_URI, visitDate: DB_NOW - 100000 - (i * 1000) });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+  do_print("Bookmark the URI.");
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       TEST_URI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "bookmark title");
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Remove visits using timerange outside the URI's visits.");
+  let filter = {
+    beginDate: new Date(JS_NOW - 10),
+    endDate: new Date(JS_NOW)
+  };
+  yield PlacesUtils.history.removeVisitsByFilter(filter);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("URI should still exist in moz_places.");
+  do_check_true(page_in_database(TEST_URI.spec));
+
+  do_print("Run a history query and check that all visits still exist.");
+  let query = PlacesUtils.history.getNewQuery();
+  let opts = PlacesUtils.history.getNewQueryOptions();
+  opts.resultType = opts.RESULTS_AS_VISIT;
+  opts.sortingMode = opts.SORT_BY_DATE_DESCENDING;
+  let root = PlacesUtils.history.executeQuery(query, opts).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 10);
+  for (let i = 0; i < root.childCount; i++) {
+    let visitTime = root.getChild(i).time;
+    do_check_eq(visitTime, DB_NOW - 100000 - (i * 1000));
+  }
+  root.containerOpen = false;
+
+  do_print("asyncHistory.isURIVisited should return true.");
+  do_check_true(yield promiseIsURIVisited(TEST_URI));
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Frecency should be positive.")
+  do_check_true(frecencyForUrl(TEST_URI) > 0);
+
+  yield cleanup();
+});
+
+add_task(function* remove_visits_unbookmarked_uri() {
+  do_print("*** TEST: Remove some visits from an unbookmarked URI");
+
+  do_print("Add 10 visits for the URI from now to 9 usecs in the past.");
+  let visits = [];
+  for (let i = 0; i < 10; i++) {
+    visits.push({ uri: TEST_URI, visitDate: DB_NOW - (i * 1000) });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+
+  do_print("Remove the 5 most recent visits.");
+  let filter = {
+    beginDate: new Date(JS_NOW - 4),
+    endDate: new Date(JS_NOW)
+  };
+  yield PlacesUtils.history.removeVisitsByFilter(filter);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("URI should still exist in moz_places.");
+  do_check_true(page_in_database(TEST_URI.spec));
+
+  do_print("Run a history query and check that only the older 5 visits still exist.");
+  let query = PlacesUtils.history.getNewQuery();
+  let opts = PlacesUtils.history.getNewQueryOptions();
+  opts.resultType = opts.RESULTS_AS_VISIT;
+  opts.sortingMode = opts.SORT_BY_DATE_DESCENDING;
+  let root = PlacesUtils.history.executeQuery(query, opts).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 5);
+  for (let i = 0; i < root.childCount; i++) {
+    let visitTime = root.getChild(i).time;
+    do_check_eq(visitTime, DB_NOW - (i * 1000) - 5000);
+  }
+  root.containerOpen = false;
+
+  do_print("asyncHistory.isURIVisited should return true.");
+  do_check_true(yield promiseIsURIVisited(TEST_URI));
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Frecency should be positive.")
+  do_check_true(frecencyForUrl(TEST_URI) > 0);
+
+  yield cleanup();
+});
+
+add_task(function* remove_visits_bookmarked_uri() {
+  do_print("*** TEST: Remove some visits from a bookmarked URI");
+
+  do_print("Add 10 visits for the URI from now to 9 usecs in the past.");
+  let visits = [];
+  for (let i = 0; i < 10; i++) {
+    visits.push({ uri: TEST_URI, visitDate: DB_NOW - (i * 1000) });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+  do_print("Bookmark the URI.");
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       TEST_URI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "bookmark title");
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Remove the 5 most recent visits.");
+  let filter = {
+    beginDate: new Date(JS_NOW - 4),
+    endDate: new Date(JS_NOW)
+  };
+  yield PlacesUtils.history.removeVisitsByFilter(filter);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("URI should still exist in moz_places.");
+  do_check_true(page_in_database(TEST_URI.spec));
+
+  do_print("Run a history query and check that only the older 5 visits still exist.");
+  let query = PlacesUtils.history.getNewQuery();
+  let opts = PlacesUtils.history.getNewQueryOptions();
+  opts.resultType = opts.RESULTS_AS_VISIT;
+  opts.sortingMode = opts.SORT_BY_DATE_DESCENDING;
+  let root = PlacesUtils.history.executeQuery(query, opts).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 5);
+  for (let i = 0; i < root.childCount; i++) {
+    let visitTime = root.getChild(i).time;
+    do_check_eq(visitTime, DB_NOW - (i * 1000) - 5000);
+  }
+  root.containerOpen = false;
+
+  do_print("asyncHistory.isURIVisited should return true.");
+  do_check_true(yield promiseIsURIVisited(TEST_URI));
+  yield PlacesTestUtils.promiseAsyncUpdates()
+
+  do_print("Frecency should be positive.")
+  do_check_true(frecencyForUrl(TEST_URI) > 0);
+
+  yield cleanup();
+});
+
+add_task(function* remove_all_visits_unbookmarked_uri() {
+  do_print("*** TEST: Remove all visits from an unbookmarked URI");
+
+  do_print("Add some visits for the URI.");
+  let visits = [];
+  for (let i = 0; i < 10; i++) {
+    visits.push({ uri: TEST_URI, visitDate: DB_NOW - (i * 1000) });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+
+  do_print("Remove all visits.");
+  let filter = {
+    beginDate: new Date(JS_NOW - 10),
+    endDate: new Date(JS_NOW)
+  };
+  yield PlacesUtils.history.removeVisitsByFilter(filter);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("URI should no longer exist in moz_places.");
+  do_check_false(page_in_database(TEST_URI.spec));
+
+  do_print("Run a history query and check that no visits exist.");
+  let query = PlacesUtils.history.getNewQuery();
+  let opts = PlacesUtils.history.getNewQueryOptions();
+  opts.resultType = opts.RESULTS_AS_VISIT;
+  opts.sortingMode = opts.SORT_BY_DATE_DESCENDING;
+  let root = PlacesUtils.history.executeQuery(query, opts).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 0);
+  root.containerOpen = false;
+
+  do_print("asyncHistory.isURIVisited should return false.");
+  do_check_false(yield promiseIsURIVisited(TEST_URI));
+
+  yield cleanup();
+});
+
+add_task(function* remove_all_visits_bookmarked_uri() {
+  do_print("*** TEST: Remove all visits from a bookmarked URI");
+
+  do_print("Add some visits for the URI.");
+  let visits = [];
+  for (let i = 0; i < 10; i++) {
+    visits.push({ uri: TEST_URI, visitDate: DB_NOW - (i * 1000) });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+  do_print("Bookmark the URI.");
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       TEST_URI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "bookmark title");
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  let initialFrecency = frecencyForUrl(TEST_URI);
+
+  do_print("Remove all visits.");
+  let filter = {
+    beginDate: new Date(JS_NOW - 10),
+    endDate: new Date(JS_NOW)
+  };
+  yield PlacesUtils.history.removeVisitsByFilter(filter);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("URI should still exist in moz_places.");
+  do_check_true(page_in_database(TEST_URI.spec));
+
+  do_print("Run a history query and check that no visits exist.");
+  let query = PlacesUtils.history.getNewQuery();
+  let opts = PlacesUtils.history.getNewQueryOptions();
+  opts.resultType = opts.RESULTS_AS_VISIT;
+  opts.sortingMode = opts.SORT_BY_DATE_DESCENDING;
+  let root = PlacesUtils.history.executeQuery(query, opts).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 0);
+  root.containerOpen = false;
+
+  do_print("asyncHistory.isURIVisited should return false.");
+  do_check_false(yield promiseIsURIVisited(TEST_URI));
+
+  do_print("nsINavBookmarksService.isBookmarked should return true.");
+  do_check_true(PlacesUtils.bookmarks.isBookmarked(TEST_URI));
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Frecency should be smaller.")
+  do_check_true(frecencyForUrl(TEST_URI) < initialFrecency);
+
+  yield cleanup();
+});
+
+add_task(function* remove_all_visits_bookmarked_uri() {
+  do_print("*** TEST: Remove some visits from a zero frecency URI retains zero frecency");
+
+  do_print("Add some visits for the URI.");
+  yield PlacesTestUtils.addVisits([
+    { uri: TEST_URI, transition: TRANSITION_FRAMED_LINK, visitDate: (DB_NOW - 86400000000000) },
+    { uri: TEST_URI, transition: TRANSITION_FRAMED_LINK, visitDate: DB_NOW }
+  ]);
+
+  do_print("Remove newer visit.");
+  let filter = {
+    beginDate: new Date(JS_NOW - 10),
+    endDate: new Date(JS_NOW)
+  };
+  yield PlacesUtils.history.removeVisitsByFilter(filter);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("URI should still exist in moz_places.");
+  do_check_true(page_in_database(TEST_URI.spec));
+  do_print("Frecency should be zero.")
+  do_check_eq(frecencyForUrl(TEST_URI), 0);
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/history/test_removeVisitsByFilter.js b/toolkit/components/places/tests/history/test_removeVisitsByFilter.js
new file mode 100644
index 000000000..699420e43
--- /dev/null
+++ b/toolkit/components/places/tests/history/test_removeVisitsByFilter.js
@@ -0,0 +1,345 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+
+// Tests for `History.removeVisitsByFilter`, as implemented in History.jsm
+
+"use strict";
+
+Cu.importGlobalProperties(["URL"]);
+
+Cu.import("resource://gre/modules/PromiseUtils.jsm", this);
+
+add_task(function* test_removeVisitsByFilter() {
+  let referenceDate = new Date(1999, 9, 9, 9, 9);
+
+  // Populate a database with 20 entries, remove a subset of entries,
+  // ensure consistency.
+  let remover = Task.async(function*(options) {
+    do_print("Remover with options " + JSON.stringify(options));
+    let SAMPLE_SIZE = options.sampleSize;
+
+    yield PlacesTestUtils.clearHistory();
+    yield PlacesUtils.bookmarks.eraseEverything();
+
+    // Populate the database.
+    // Create `SAMPLE_SIZE` visits, from the oldest to the newest.
+
+    let bookmarkIndices = new Set(options.bookmarks);
+    let visits = [];
+    let frecencyChangePromises = new Map();
+    let uriDeletePromises = new Map();
+    let getURL = options.url ?
+      i => "http://mozilla.com/test_browserhistory/test_removeVisitsByFilter/removeme/byurl/" + Math.floor(i / (SAMPLE_SIZE / 5)) + "/" :
+      i => "http://mozilla.com/test_browserhistory/test_removeVisitsByFilter/removeme/" + i + "/" + Math.random();
+    for (let i = 0; i < SAMPLE_SIZE; ++i) {
+      let spec = getURL(i);
+      let uri = NetUtil.newURI(spec);
+      let jsDate = new Date(Number(referenceDate) + 3600 * 1000 * i);
+      let dbDate = jsDate * 1000;
+      let hasBookmark = bookmarkIndices.has(i);
+      let hasOwnBookmark = hasBookmark;
+      if (!hasOwnBookmark && options.url) {
+        // Also mark as bookmarked if one of the earlier bookmarked items has the same URL.
+        hasBookmark =
+          options.bookmarks.filter(n => n < i).some(n => visits[n].uri.spec == spec && visits[n].test.hasBookmark);
+      }
+      do_print("Generating " + uri.spec + ", " + dbDate);
+      let visit = {
+        uri,
+        title: "visit " + i,
+        visitDate: dbDate,
+        test: {
+          // `visitDate`, as a Date
+          jsDate: jsDate,
+          // `true` if we expect that the visit will be removed
+          toRemove: false,
+          // `true` if `onRow` informed of the removal of this visit
+          announcedByOnRow: false,
+          // `true` if there is a bookmark for this URI, i.e. of the page
+          // should not be entirely removed.
+          hasBookmark: hasBookmark,
+          onFrecencyChanged: null,
+          onDeleteURI: null,
+        },
+      };
+      visits.push(visit);
+      if (hasOwnBookmark) {
+        do_print("Adding a bookmark to visit " + i);
+        yield PlacesUtils.bookmarks.insert({
+          url: uri,
+          parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+          title: "test bookmark"
+        });
+        do_print("Bookmark added");
+      }
+    }
+
+    do_print("Adding visits");
+    yield PlacesTestUtils.addVisits(visits);
+
+    do_print("Preparing filters");
+    let filter = {
+    };
+    let beginIndex = 0;
+    let endIndex = visits.length - 1;
+    if ("begin" in options) {
+      let ms = Number(visits[options.begin].test.jsDate) - 1000;
+      filter.beginDate = new Date(ms);
+      beginIndex = options.begin;
+    }
+    if ("end" in options) {
+      let ms = Number(visits[options.end].test.jsDate) + 1000;
+      filter.endDate = new Date(ms);
+      endIndex = options.end;
+    }
+    if ("limit" in options) {
+      endIndex = beginIndex + options.limit - 1; // -1 because the start index is inclusive.
+      filter.limit = options.limit;
+    }
+    let removedItems = visits.slice(beginIndex);
+    endIndex -= beginIndex;
+    if (options.url) {
+      let rawURL = "";
+      switch (options.url) {
+        case 1:
+          filter.url = new URL(removedItems[0].uri.spec);
+          rawURL = filter.url.href;
+          break;
+        case 2:
+          filter.url = removedItems[0].uri;
+          rawURL = filter.url.spec;
+          break;
+        case 3:
+          filter.url = removedItems[0].uri.spec;
+          rawURL = filter.url;
+          break;
+      }
+      endIndex = Math.min(endIndex, removedItems.findIndex((v, index) => v.uri.spec != rawURL) - 1);
+    }
+    removedItems.splice(endIndex + 1);
+    let remainingItems = visits.filter(v => !removedItems.includes(v));
+    for (let i = 0; i < removedItems.length; i++) {
+      let test = removedItems[i].test;
+      do_print("Marking visit " + (beginIndex + i) + " as expecting removal");
+      test.toRemove = true;
+      if (test.hasBookmark ||
+          (options.url && remainingItems.some(v => v.uri.spec == removedItems[i].uri.spec))) {
+        frecencyChangePromises.set(removedItems[i].uri.spec, PromiseUtils.defer());
+      } else if (!options.url || i == 0) {
+        uriDeletePromises.set(removedItems[i].uri.spec, PromiseUtils.defer());
+      }
+    }
+
+    let observer = {
+      deferred: PromiseUtils.defer(),
+      onBeginUpdateBatch: function() {},
+      onEndUpdateBatch: function() {},
+      onVisit: function(uri) {
+        this.deferred.reject(new Error("Unexpected call to onVisit " + uri.spec));
+      },
+      onTitleChanged: function(uri) {
+        this.deferred.reject(new Error("Unexpected call to onTitleChanged " + uri.spec));
+      },
+      onClearHistory: function() {
+        this.deferred.reject("Unexpected call to onClearHistory");
+      },
+      onPageChanged: function(uri) {
+        this.deferred.reject(new Error("Unexpected call to onPageChanged " + uri.spec));
+      },
+      onFrecencyChanged: function(aURI) {
+        do_print("onFrecencyChanged " + aURI.spec);
+        let deferred = frecencyChangePromises.get(aURI.spec);
+        Assert.ok(!!deferred, "Observing onFrecencyChanged");
+        deferred.resolve();
+      },
+      onManyFrecenciesChanged: function() {
+        do_print("Many frecencies changed");
+        for (let [, deferred] of frecencyChangePromises) {
+          deferred.resolve();
+        }
+      },
+      onDeleteURI: function(aURI) {
+        do_print("onDeleteURI " + aURI.spec);
+        let deferred = uriDeletePromises.get(aURI.spec);
+        Assert.ok(!!deferred, "Observing onDeleteURI");
+        deferred.resolve();
+      },
+      onDeleteVisits: function(aURI) {
+        // Not sure we can test anything.
+      }
+    };
+    PlacesUtils.history.addObserver(observer, false);
+
+    let cbarg;
+    if (options.useCallback) {
+      do_print("Setting up callback");
+      cbarg = [info => {
+        for (let visit of visits) {
+          do_print("Comparing " + info.date + " and " + visit.test.jsDate);
+          if (Math.abs(visit.test.jsDate - info.date) < 100) { // Assume rounding errors
+            Assert.ok(!visit.test.announcedByOnRow,
+              "This is the first time we announce the removal of this visit");
+            Assert.ok(visit.test.toRemove,
+              "This is a visit we intended to remove");
+            visit.test.announcedByOnRow = true;
+            return;
+          }
+        }
+        Assert.ok(false, "Could not find the visit we attempt to remove");
+      }];
+    } else {
+      do_print("No callback");
+      cbarg = [];
+    }
+    let result = yield PlacesUtils.history.removeVisitsByFilter(filter, ...cbarg);
+
+    Assert.ok(result, "Removal succeeded");
+
+    // Make sure that we have eliminated exactly the entries we expected
+    // to eliminate.
+    for (let i = 0; i < visits.length; ++i) {
+      let visit = visits[i];
+      do_print("Controlling the results on visit " + i);
+      let remainingVisitsForURI = remainingItems.filter(v => visit.uri.spec == v.uri.spec).length;
+      Assert.equal(
+        visits_in_database(visit.uri),
+        remainingVisitsForURI,
+        "Visit is still present iff expected");
+      if (options.useCallback) {
+        Assert.equal(
+          visit.test.toRemove,
+          visit.test.announcedByOnRow,
+          "Visit removal has been announced by onResult iff expected");
+      }
+      if (visit.test.hasBookmark || remainingVisitsForURI) {
+        Assert.notEqual(page_in_database(visit.uri), 0, "The page should still appear in the db");
+      } else {
+        Assert.equal(page_in_database(visit.uri), 0, "The page should have been removed from the db");
+      }
+    }
+
+    // Make sure that the observer has been called wherever applicable.
+    do_print("Checking URI delete promises.");
+    yield Promise.all(Array.from(uriDeletePromises.values()));
+    do_print("Checking frecency change promises.");
+    yield Promise.all(Array.from(frecencyChangePromises.values()));
+    PlacesUtils.history.removeObserver(observer);
+  });
+
+  let size = 20;
+  for (let range of [
+    {begin: 0},
+    {end: 19},
+    {begin: 0, end: 10},
+    {begin: 3, end: 4},
+    {begin: 5, end: 8, limit: 2},
+    {begin: 10, end: 18, limit: 5},
+  ]) {
+    for (let bookmarks of [[], [5, 6]]) {
+      let options = {
+        sampleSize: size,
+        bookmarks: bookmarks,
+      };
+      if ("begin" in range) {
+        options.begin = range.begin;
+      }
+      if ("end" in range) {
+        options.end = range.end;
+      }
+      if ("limit" in range) {
+        options.limit = range.limit;
+      }
+      yield remover(options);
+      options.url = 1;
+      yield remover(options);
+      options.url = 2;
+      yield remover(options);
+      options.url = 3;
+      yield remover(options);
+    }
+  }
+  yield PlacesTestUtils.clearHistory();
+});
+
+// Test the various error cases
+add_task(function* test_error_cases() {
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter(),
+    /TypeError: Expected a filter/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter("obviously, not a filter"),
+    /TypeError: Expected a filter/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({}),
+    /TypeError: Expected a non-empty filter/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({beginDate: "now"}),
+    /TypeError: Expected a Date/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({beginDate: Date.now()}),
+    /TypeError: Expected a Date/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({beginDate: new Date()}, "obviously, not a callback"),
+    /TypeError: Invalid function/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({beginDate: new Date(1000), endDate: new Date(0)}),
+    /TypeError: `beginDate` should be at least as old/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({limit: {}}),
+    /Expected a non-zero positive integer as a limit/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({limit: -1}),
+    /Expected a non-zero positive integer as a limit/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({limit: 0.1}),
+    /Expected a non-zero positive integer as a limit/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({limit: Infinity}),
+    /Expected a non-zero positive integer as a limit/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({url: {}}),
+    /Expected a valid URL for `url`/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({url: 0}),
+    /Expected a valid URL for `url`/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({beginDate: new Date(1000), endDate: new Date(0)}),
+    /TypeError: `beginDate` should be at least as old/
+  );
+  Assert.throws(
+    () => PlacesUtils.history.removeVisitsByFilter({beginDate: new Date(1000), endDate: new Date(0)}),
+    /TypeError: `beginDate` should be at least as old/
+  );
+});
+
+add_task(function* test_orphans() {
+  let uri = NetUtil.newURI("http://moz.org/");
+  yield PlacesTestUtils.addVisits({ uri });
+
+  PlacesUtils.favicons.setAndFetchFaviconForPage(
+    uri, SMALLPNG_DATA_URI, true,  PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+    null, Services.scriptSecurityManager.getSystemPrincipal());
+  PlacesUtils.annotations.setPageAnnotation(uri, "test", "restval", 0,
+                                            PlacesUtils.annotations.EXPIRE_NEVER);
+
+  yield PlacesUtils.history.removeVisitsByFilter({ beginDate: new Date(1999, 9, 9, 9, 9),
+                                                   endDate: new Date() });
+  Assert.ok(!(yield PlacesTestUtils.isPageInDB(uri)), "Page should have been removed");
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.execute(`SELECT (SELECT count(*) FROM moz_annos) +
+                                      (SELECT count(*) FROM moz_favicons) AS count`);
+  Assert.equal(rows[0].getResultByName("count"), 0, "Should not find orphans");
+});
diff --git a/toolkit/components/places/tests/history/test_updatePlaces_sameUri_titleChanged.js b/toolkit/components/places/tests/history/test_updatePlaces_sameUri_titleChanged.js
new file mode 100644
index 000000000..832df9d9a
--- /dev/null
+++ b/toolkit/components/places/tests/history/test_updatePlaces_sameUri_titleChanged.js
@@ -0,0 +1,52 @@
+// Test that repeated additions of the same URI through updatePlaces, properly
+// update from_visit and notify titleChanged.
+
+add_task(function* test() {
+  let uri = "http://test.com/";
+
+  let promiseTitleChangedNotifications = new Promise(resolve => {
+    let historyObserver = {
+      _count: 0,
+      __proto__: NavHistoryObserver.prototype,
+      onTitleChanged(aURI, aTitle, aGUID) {
+        Assert.equal(aURI.spec, uri, "Should notify the proper url");
+        if (++this._count == 2) {
+          PlacesUtils.history.removeObserver(historyObserver);
+          resolve();
+        }
+      }
+    };
+    PlacesUtils.history.addObserver(historyObserver, false);
+  });
+
+  // This repeats the url on purpose, don't merge it into a single place entry.
+  yield PlacesTestUtils.addVisits([
+    { uri, title: "test" },
+    { uri, referrer: uri, title: "test2" },
+  ]);
+
+  let options = PlacesUtils.history.getNewQueryOptions();
+  let query = PlacesUtils.history.getNewQuery();
+  query.uri = NetUtil.newURI(uri);
+  options.resultType = options.RESULTS_AS_VISIT;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  Assert.equal(root.childCount, 2);
+
+  let child = root.getChild(0);
+  Assert.equal(child.visitType, TRANSITION_LINK, "Visit type should be TRANSITION_LINK");
+  Assert.equal(child.visitId, 1, "Visit ID should be 1");
+  Assert.equal(child.fromVisitId, -1, "Should have no referrer visit ID");
+  Assert.equal(child.title, "test2", "Should have the correct title");
+
+  child = root.getChild(1);
+  Assert.equal(child.visitType, TRANSITION_LINK, "Visit type should be TRANSITION_LINK");
+  Assert.equal(child.visitId, 2, "Visit ID should be 2");
+  Assert.equal(child.fromVisitId, 1, "First visit should be the referring visit");
+  Assert.equal(child.title, "test2", "Should have the correct title");
+
+  root.containerOpen = false;
+
+  yield promiseTitleChangedNotifications;
+});
diff --git a/toolkit/components/places/tests/history/xpcshell.ini b/toolkit/components/places/tests/history/xpcshell.ini
new file mode 100644
index 000000000..ee182e090
--- /dev/null
+++ b/toolkit/components/places/tests/history/xpcshell.ini
@@ -0,0 +1,9 @@
+[DEFAULT]
+head = head_history.js
+tail =
+
+[test_insert.js]
+[test_remove.js]
+[test_removeVisits.js]
+[test_removeVisitsByFilter.js]
+[test_updatePlaces_sameUri_titleChanged.js]
diff --git a/toolkit/components/places/tests/migration/.eslintrc.js b/toolkit/components/places/tests/migration/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/places/tests/migration/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/migration/head_migration.js b/toolkit/components/places/tests/migration/head_migration.js
new file mode 100644
index 000000000..1ebecd4c0
--- /dev/null
+++ b/toolkit/components/places/tests/migration/head_migration.js
@@ -0,0 +1,46 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict"
+
+var { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components;
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+// Import common head.
+{
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
+
+// Put any other stuff relative to this test folder below.
+
+const DB_FILENAME = "places.sqlite";
+
+/**
+ * Sets the database to use for the given test.  This should be the very first
+ * thing in the test, otherwise this database will not be used!
+ *
+ * @param aFileName
+ *        The filename of the database to use.  This database must exist in
+ *        toolkit/components/places/tests/migration!
+ * @return {Promise}
+ */
+var setupPlacesDatabase = Task.async(function* (aFileName) {
+  let currentDir = yield OS.File.getCurrentDirectory();
+
+  let src = OS.Path.join(currentDir, aFileName);
+  Assert.ok((yield OS.File.exists(src)), "Database file found");
+
+  // Ensure that our database doesn't already exist.
+  let dest = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  Assert.ok(!(yield OS.File.exists(dest)), "Database file should not exist yet");
+
+  yield OS.File.copy(src, dest);
+});
+
+// This works provided all tests in this folder use add_task.
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/migration/places_v10.sqlite b/toolkit/components/places/tests/migration/places_v10.sqlite
new file mode 100644
index 000000000..80a8ecd6a
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v10.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v11.sqlite b/toolkit/components/places/tests/migration/places_v11.sqlite
new file mode 100644
index 000000000..bef27d5f5
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v11.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v17.sqlite b/toolkit/components/places/tests/migration/places_v17.sqlite
new file mode 100644
index 000000000..5183cde83
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v17.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v19.sqlite b/toolkit/components/places/tests/migration/places_v19.sqlite
new file mode 100644
index 000000000..11e2e6247
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v19.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v21.sqlite b/toolkit/components/places/tests/migration/places_v21.sqlite
new file mode 100644
index 000000000..f72930826
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v21.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v22.sqlite b/toolkit/components/places/tests/migration/places_v22.sqlite
new file mode 100644
index 000000000..30bf840b0
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v22.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v23.sqlite b/toolkit/components/places/tests/migration/places_v23.sqlite
new file mode 100644
index 000000000..b519b97d2
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v23.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v24.sqlite b/toolkit/components/places/tests/migration/places_v24.sqlite
new file mode 100644
index 000000000..b35f958a6
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v24.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v25.sqlite b/toolkit/components/places/tests/migration/places_v25.sqlite
new file mode 100644
index 000000000..2afd1da1f
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v25.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v26.sqlite b/toolkit/components/places/tests/migration/places_v26.sqlite
new file mode 100644
index 000000000..b4b238179
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v26.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v27.sqlite b/toolkit/components/places/tests/migration/places_v27.sqlite
new file mode 100644
index 000000000..57dfb7562
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v27.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v28.sqlite b/toolkit/components/places/tests/migration/places_v28.sqlite
new file mode 100644
index 000000000..9a27db324
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v28.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v29.sqlite b/toolkit/components/places/tests/migration/places_v29.sqlite
new file mode 100644
index 000000000..f6de0fe8a
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v29.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v30.sqlite b/toolkit/components/places/tests/migration/places_v30.sqlite
new file mode 100644
index 000000000..9cbabe005
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v30.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v31.sqlite b/toolkit/components/places/tests/migration/places_v31.sqlite
new file mode 100644
index 000000000..9d33b9eff
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v31.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v32.sqlite b/toolkit/components/places/tests/migration/places_v32.sqlite
new file mode 100644
index 000000000..239f6c5fe
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v32.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v33.sqlite b/toolkit/components/places/tests/migration/places_v33.sqlite
new file mode 100644
index 000000000..6071dc6a6
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v33.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v34.sqlite b/toolkit/components/places/tests/migration/places_v34.sqlite
new file mode 100644
index 000000000..474628996
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v34.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v35.sqlite b/toolkit/components/places/tests/migration/places_v35.sqlite
new file mode 100644
index 000000000..5e157d778
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v35.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v6.sqlite b/toolkit/components/places/tests/migration/places_v6.sqlite
new file mode 100644
index 000000000..2852a4cf9
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v6.sqlite
diff --git a/toolkit/components/places/tests/migration/test_current_from_downgraded.js b/toolkit/components/places/tests/migration/test_current_from_downgraded.js
new file mode 100644
index 000000000..6d36cab14
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_downgraded.js
@@ -0,0 +1,19 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* setup() {
+  yield setupPlacesDatabase(`places_v${CURRENT_SCHEMA_VERSION}.sqlite`);
+  // Downgrade the schema version to the first supported one.
+  let path = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  let db = yield Sqlite.openConnection({ path: path });
+  yield db.setSchemaVersion(FIRST_UPGRADABLE_SCHEMA_VERSION);
+  yield db.close();
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v11.js b/toolkit/components/places/tests/migration/test_current_from_v11.js
new file mode 100644
index 000000000..43b8fb1f6
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v11.js
@@ -0,0 +1,48 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v11.sqlite");
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_moz_hosts() {
+  let db = yield PlacesUtils.promiseDBConnection();
+
+  // This will throw if the column does not exist.
+  yield db.execute("SELECT host, frecency, typed, prefix FROM moz_hosts");
+
+  // moz_hosts is populated asynchronously, so we need to wait.
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  // check the number of entries in moz_hosts equals the number of
+  // unique rev_host in moz_places
+  let rows = yield db.execute(
+    `SELECT (SELECT COUNT(host) FROM moz_hosts),
+            (SELECT COUNT(DISTINCT rev_host)
+             FROM moz_places
+             WHERE LENGTH(rev_host) > 1)
+    `);
+
+  Assert.equal(rows.length, 1);
+  let mozHostsCount = rows[0].getResultByIndex(0);
+  let mozPlacesCount = rows[0].getResultByIndex(1);
+
+  Assert.ok(mozPlacesCount > 0, "There is some url in the database");
+  Assert.equal(mozPlacesCount, mozHostsCount, "moz_hosts has the expected number of entries");
+});
+
+add_task(function* test_journal() {
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.execute("PRAGMA journal_mode");
+  Assert.equal(rows.length, 1);
+  // WAL journal mode should be set on this database.
+  Assert.equal(rows[0].getResultByIndex(0), "wal");
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v19.js b/toolkit/components/places/tests/migration/test_current_from_v19.js
new file mode 100644
index 000000000..b8d837e68
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v19.js
@@ -0,0 +1,42 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const ANNO_LEGACYGUID = "placesInternal/GUID";
+
+var getTotalGuidAnnotationsCount = Task.async(function* (db) {
+  let rows = yield db.execute(
+    `SELECT count(*)
+     FROM moz_items_annos a
+     JOIN moz_anno_attributes b ON a.anno_attribute_id = b.id
+     WHERE b.name = :attr_name
+    `, { attr_name: ANNO_LEGACYGUID });
+  return rows[0].getResultByIndex(0);
+});
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v19.sqlite");
+});
+
+add_task(function* initial_state() {
+  let path = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  let db = yield Sqlite.openConnection({ path: path });
+
+  Assert.equal((yield getTotalGuidAnnotationsCount(db)), 1,
+               "There should be 1 obsolete guid annotation");
+  yield db.close();
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_bookmark_guid_annotation_removed()
+{
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield getTotalGuidAnnotationsCount(db)), 0,
+               "There should be no more obsolete GUID annotations.");
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v24.js b/toolkit/components/places/tests/migration/test_current_from_v24.js
new file mode 100644
index 000000000..0561b4922
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v24.js
@@ -0,0 +1,36 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v24.sqlite");
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_bookmark_guid_annotation_removed()
+{
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  let m = new Map([
+    [PlacesUtils.placesRootId, PlacesUtils.bookmarks.rootGuid],
+    [PlacesUtils.bookmarksMenuFolderId, PlacesUtils.bookmarks.menuGuid],
+    [PlacesUtils.toolbarFolderId, PlacesUtils.bookmarks.toolbarGuid],
+    [PlacesUtils.unfiledBookmarksFolderId, PlacesUtils.bookmarks.unfiledGuid],
+    [PlacesUtils.tagsFolderId, PlacesUtils.bookmarks.tagsGuid],
+    [PlacesUtils.mobileFolderId, PlacesUtils.bookmarks.mobileGuid],
+  ]);
+
+  let rows = yield db.execute(`SELECT id, guid FROM moz_bookmarks`);
+  for (let row of rows) {
+    let id = row.getResultByName("id");
+    let guid = row.getResultByName("guid");
+    Assert.equal(m.get(id), guid, "The root folder has the correct GUID");
+  }
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v25.js b/toolkit/components/places/tests/migration/test_current_from_v25.js
new file mode 100644
index 000000000..b066975fc
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v25.js
@@ -0,0 +1,30 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v25.sqlite");
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_dates_rounded() {
+  let root = yield PlacesUtils.promiseBookmarksTree();
+  function ensureDates(node) {
+    // When/if promiseBookmarksTree returns these as Date objects, switch this
+    // test to use getItemDateAdded and getItemLastModified.  And when these
+    // methods are removed, this test can be eliminated altogether.
+    Assert.strictEqual(typeof(node.dateAdded), "number");
+    Assert.strictEqual(typeof(node.lastModified), "number");
+    Assert.strictEqual(node.dateAdded % 1000, 0);
+    Assert.strictEqual(node.lastModified % 1000, 0);
+    if ("children" in node)
+      node.children.forEach(ensureDates);
+  }
+  ensureDates(root);
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v26.js b/toolkit/components/places/tests/migration/test_current_from_v26.js
new file mode 100644
index 000000000..7ff4bc352
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v26.js
@@ -0,0 +1,98 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v26.sqlite");
+  // Setup database contents to be migrated.
+  let path = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  let db = yield Sqlite.openConnection({ path });
+  // Add pages.
+  yield db.execute(`INSERT INTO moz_places (url, guid)
+                    VALUES ("http://test1.com/", "test1_______")
+                         , ("http://test2.com/", "test2_______")
+                         , ("http://test3.com/", "test3_______")
+                   `);
+  // Add keywords.
+  yield db.execute(`INSERT INTO moz_keywords (keyword)
+                    VALUES ("kw1")
+                         , ("kw2")
+                         , ("kw3")
+                         , ("kw4")
+                         , ("kw5")
+                   `);
+  // Add bookmarks.
+  let now = Date.now() * 1000;
+  let index = 0;
+  yield db.execute(`INSERT INTO moz_bookmarks (type, fk, parent, position, dateAdded, lastModified, keyword_id, guid)
+                    VALUES (1, (SELECT id FROM moz_places WHERE guid = 'test1_______'), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = 'kw1'), "bookmark1___")
+                            /* same uri, different keyword */
+                         , (1, (SELECT id FROM moz_places WHERE guid = 'test1_______'), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = 'kw2'), "bookmark2___")
+                           /* different uri, same keyword as 1 */
+                         , (1, (SELECT id FROM moz_places WHERE guid = 'test2_______'), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = 'kw1'), "bookmark3___")
+                           /* same uri, same keyword as 1 */
+                         , (1, (SELECT id FROM moz_places WHERE guid = 'test1_______'), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = 'kw1'), "bookmark4___")
+                           /* same uri, same keyword as 2 */
+                         , (1, (SELECT id FROM moz_places WHERE guid = 'test2_______'), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = 'kw2'), "bookmark5___")
+                           /* different uri, same keyword as 1 */
+                         , (1, (SELECT id FROM moz_places WHERE guid = 'test1_______'), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = 'kw3'), "bookmark6___")
+                         , (1, (SELECT id FROM moz_places WHERE guid = 'test3_______'), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = 'kw4'), "bookmark7___")
+                         /* same uri and post_data as bookmark7, different keyword */
+                         , (1, (SELECT id FROM moz_places WHERE guid = 'test3_______'), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = 'kw5'), "bookmark8___")
+                   `);
+  // Add postData.
+  yield db.execute(`INSERT INTO moz_anno_attributes (name)
+                    VALUES ("bookmarkProperties/POSTData")
+                         , ("someOtherAnno")`);
+  yield db.execute(`INSERT INTO moz_items_annos(anno_attribute_id, item_id, content)
+                    VALUES ((SELECT id FROM moz_anno_attributes where name = "bookmarkProperties/POSTData"),
+                            (SELECT id FROM moz_bookmarks WHERE guid = "bookmark3___"), "postData1")
+                         , ((SELECT id FROM moz_anno_attributes where name = "bookmarkProperties/POSTData"),
+                            (SELECT id FROM moz_bookmarks WHERE guid = "bookmark5___"), "postData2")
+                         , ((SELECT id FROM moz_anno_attributes where name = "someOtherAnno"),
+                            (SELECT id FROM moz_bookmarks WHERE guid = "bookmark5___"), "zzzzzzzzzz")
+                         , ((SELECT id FROM moz_anno_attributes where name = "bookmarkProperties/POSTData"),
+                            (SELECT id FROM moz_bookmarks WHERE guid = "bookmark7___"), "postData3")
+                         , ((SELECT id FROM moz_anno_attributes where name = "bookmarkProperties/POSTData"),
+                            (SELECT id FROM moz_bookmarks WHERE guid = "bookmark8___"), "postData3")
+                    `);
+  yield db.close();
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_keywords() {
+  // When 2 urls have the same keyword, if one has postData it will be
+  // preferred.
+  let entry1 = yield PlacesUtils.keywords.fetch("kw1");
+  Assert.equal(entry1.url.href, "http://test2.com/");
+  Assert.equal(entry1.postData, "postData1");
+  let entry2 = yield PlacesUtils.keywords.fetch("kw2");
+  Assert.equal(entry2.url.href, "http://test2.com/");
+  Assert.equal(entry2.postData, "postData2");
+  let entry3 = yield PlacesUtils.keywords.fetch("kw3");
+  Assert.equal(entry3.url.href, "http://test1.com/");
+  Assert.equal(entry3.postData, null);
+  let entry4 = yield PlacesUtils.keywords.fetch("kw4");
+  Assert.equal(entry4, null);
+  let entry5 = yield PlacesUtils.keywords.fetch("kw5");
+  Assert.equal(entry5.url.href, "http://test3.com/");
+  Assert.equal(entry5.postData, "postData3");
+
+  Assert.equal((yield foreign_count("http://test1.com/")), 5); // 4 bookmark2 + 1 keywords
+  Assert.equal((yield foreign_count("http://test2.com/")), 4); // 2 bookmark2 + 2 keywords
+  Assert.equal((yield foreign_count("http://test3.com/")), 3); // 2 bookmark2 + 1 keywords
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v27.js b/toolkit/components/places/tests/migration/test_current_from_v27.js
new file mode 100644
index 000000000..1675901eb
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v27.js
@@ -0,0 +1,77 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v27.sqlite");
+  // Setup database contents to be migrated.
+  let path = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  let db = yield Sqlite.openConnection({ path });
+  // Add pages.
+  yield db.execute(`INSERT INTO moz_places (url, guid)
+                    VALUES ("http://test1.com/", "test1_______")
+                         , ("http://test2.com/", "test2_______")
+                   `);
+  // Add keywords.
+  yield db.execute(`INSERT INTO moz_keywords (keyword, place_id, post_data)
+                    VALUES ("kw1", (SELECT id FROM moz_places WHERE guid = "test2_______"), "broken data")
+                         , ("kw2", (SELECT id FROM moz_places WHERE guid = "test2_______"), NULL)
+                         , ("kw3", (SELECT id FROM moz_places WHERE guid = "test1_______"), "zzzzzzzzzz")
+                   `);
+  // Add bookmarks.
+  let now = Date.now() * 1000;
+  let index = 0;
+  yield db.execute(`INSERT INTO moz_bookmarks (type, fk, parent, position, dateAdded, lastModified, keyword_id, guid)
+                    VALUES (1, (SELECT id FROM moz_places WHERE guid = "test1_______"), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = "kw1"), "bookmark1___")
+                            /* same uri, different keyword */
+                         , (1, (SELECT id FROM moz_places WHERE guid = "test1_______"), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = "kw2"), "bookmark2___")
+                           /* different uri, same keyword as 1 */
+                         , (1, (SELECT id FROM moz_places WHERE guid = "test2_______"), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = "kw1"), "bookmark3___")
+                           /* same uri, same keyword as 1 */
+                         , (1, (SELECT id FROM moz_places WHERE guid = "test1_______"), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = "kw1"), "bookmark4___")
+                           /* same uri, same keyword as 2 */
+                         , (1, (SELECT id FROM moz_places WHERE guid = "test2_______"), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = "kw2"), "bookmark5___")
+                           /* different uri, same keyword as 1 */
+                         , (1, (SELECT id FROM moz_places WHERE guid = "test1_______"), 3, ${index++}, ${now}, ${now},
+                             (SELECT id FROM moz_keywords WHERE keyword = "kw3"), "bookmark6___")
+                   `);
+  // Add postData.
+  yield db.execute(`INSERT INTO moz_anno_attributes (name)
+                    VALUES ("bookmarkProperties/POSTData")
+                         , ("someOtherAnno")`);
+  yield db.execute(`INSERT INTO moz_items_annos(anno_attribute_id, item_id, content)
+                    VALUES ((SELECT id FROM moz_anno_attributes where name = "bookmarkProperties/POSTData"),
+                            (SELECT id FROM moz_bookmarks WHERE guid = "bookmark3___"), "postData1")
+                         , ((SELECT id FROM moz_anno_attributes where name = "bookmarkProperties/POSTData"),
+                            (SELECT id FROM moz_bookmarks WHERE guid = "bookmark5___"), "postData2")
+                         , ((SELECT id FROM moz_anno_attributes where name = "someOtherAnno"),
+                            (SELECT id FROM moz_bookmarks WHERE guid = "bookmark5___"), "zzzzzzzzzz")
+                    `);
+  yield db.close();
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_keywords() {
+  // When 2 urls have the same keyword, if one has postData it will be
+  // preferred.
+  let entry1 = yield PlacesUtils.keywords.fetch("kw1");
+  Assert.equal(entry1.url.href, "http://test2.com/");
+  Assert.equal(entry1.postData, "postData1");
+  let entry2 = yield PlacesUtils.keywords.fetch("kw2");
+  Assert.equal(entry2.url.href, "http://test2.com/");
+  Assert.equal(entry2.postData, "postData2");
+  let entry3 = yield PlacesUtils.keywords.fetch("kw3");
+  Assert.equal(entry3.url.href, "http://test1.com/");
+  Assert.equal(entry3.postData, null);
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v31.js b/toolkit/components/places/tests/migration/test_current_from_v31.js
new file mode 100644
index 000000000..6b9131daa
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v31.js
@@ -0,0 +1,46 @@
+// Add pages.
+let shorturl = "http://example.com/" + "a".repeat(1981);
+let longurl = "http://example.com/" + "a".repeat(1982);
+let bmurl = "http://example.com/" + "a".repeat(1983);
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v31.sqlite");
+  // Setup database contents to be migrated.
+  let path = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  let db = yield Sqlite.openConnection({ path });
+
+  yield db.execute(`INSERT INTO moz_places (url, guid, foreign_count)
+                    VALUES (:shorturl, "test1_______", 0)
+                         , (:longurl, "test2_______", 0)
+                         , (:bmurl, "test3_______", 1)
+                   `, { shorturl, longurl, bmurl });
+  // Add visits.
+  yield db.execute(`INSERT INTO moz_historyvisits (place_id)
+                    VALUES ((SELECT id FROM moz_places WHERE url = :shorturl))
+                         , ((SELECT id FROM moz_places WHERE url = :longurl))
+                   `, { shorturl, longurl });
+  yield db.close();
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_longurls() {
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.execute(`SELECT 1 FROM moz_places where url = :longurl`,
+                              { longurl });
+  Assert.equal(rows.length, 0, "Long url should have been removed");
+  rows = yield db.execute(`SELECT 1 FROM moz_places where url = :shorturl`,
+                          { shorturl });
+  Assert.equal(rows.length, 1, "Short url should have been retained");
+  rows = yield db.execute(`SELECT 1 FROM moz_places where url = :bmurl`,
+                          { bmurl });
+  Assert.equal(rows.length, 1, "Bookmarked url should have been retained");
+  rows = yield db.execute(`SELECT count(*) FROM moz_historyvisits`);
+  Assert.equal(rows.length, 1, "Orphan visists should have been removed");
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v34.js b/toolkit/components/places/tests/migration/test_current_from_v34.js
new file mode 100644
index 000000000..115bcec67
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v34.js
@@ -0,0 +1,141 @@
+Cu.importGlobalProperties(["URL", "crypto"]);
+
+const { TYPE_BOOKMARK, TYPE_FOLDER } = Ci.nsINavBookmarksService;
+const { EXPIRE_NEVER, TYPE_INT32 } = Ci.nsIAnnotationService;
+
+function makeGuid() {
+  return ChromeUtils.base64URLEncode(crypto.getRandomValues(new Uint8Array(9)), {
+    pad: false,
+  });
+}
+
+// These queries are more or less copied directly from Bookmarks.jsm, but
+// operate on the old, pre-migration DB. We can't use any of the Places SQL
+// functions yet, because those are only registered for the main connection.
+function* insertItem(db, info) {
+  let [parentInfo] = yield db.execute(`
+    SELECT b.id, (SELECT count(*) FROM moz_bookmarks
+                  WHERE parent = b.id) AS childCount
+    FROM moz_bookmarks b
+    WHERE b.guid = :parentGuid`,
+    { parentGuid: info.parentGuid });
+
+  let guid = makeGuid();
+  yield db.execute(`
+    INSERT INTO moz_bookmarks (fk, type, parent, position, guid)
+    VALUES ((SELECT id FROM moz_places WHERE url = :url),
+            :type, :parent, :position, :guid)`,
+    { url: info.url || "nonexistent", type: info.type, guid,
+      // Just append items.
+      position: parentInfo.getResultByName("childCount"),
+      parent: parentInfo.getResultByName("id") });
+
+  let id = (yield db.execute(`
+    SELECT id FROM moz_bookmarks WHERE guid = :guid LIMIT 1`,
+    { guid }))[0].getResultByName("id");
+
+  return { id, guid };
+}
+
+function insertBookmark(db, info) {
+  return db.executeTransaction(function* () {
+    if (info.type == TYPE_BOOKMARK) {
+      // We don't have access to the hash function here, so we omit the
+      // `url_hash` column. These will be fixed up automatically during
+      // migration.
+      let url = new URL(info.url);
+      let placeGuid = makeGuid();
+      yield db.execute(`
+        INSERT INTO moz_places (url, rev_host, hidden, frecency, guid)
+        VALUES (:url, :rev_host, 0, -1, :guid)`,
+        { url: url.href, guid: placeGuid,
+          rev_host: PlacesUtils.getReversedHost(url) });
+    }
+    return yield* insertItem(db, info);
+  });
+}
+
+function* insertAnno(db, itemId, name, value) {
+  yield db.execute(`INSERT OR IGNORE INTO moz_anno_attributes (name)
+                    VALUES (:name)`, { name });
+  yield db.execute(`
+    INSERT INTO moz_items_annos
+           (item_id, anno_attribute_id, content, flags,
+            expiration, type, dateAdded, lastModified)
+    VALUES (:itemId,
+      (SELECT id FROM moz_anno_attributes
+       WHERE name = :name),
+      1, 0, :expiration, :type, 0, 0)
+    `, { itemId, name, expiration: EXPIRE_NEVER, type: TYPE_INT32 });
+}
+
+function insertMobileFolder(db) {
+  return db.executeTransaction(function* () {
+    let item = yield* insertItem(db, {
+      type: TYPE_FOLDER,
+      parentGuid: "root________",
+    });
+    yield* insertAnno(db, item.id, "mobile/bookmarksRoot", 1);
+    return item;
+  });
+}
+
+var mobileId, mobileGuid, fxGuid;
+var dupeMobileId, dupeMobileGuid, tbGuid;
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v34.sqlite");
+  // Setup database contents to be migrated.
+  let path = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  let db = yield Sqlite.openConnection({ path });
+
+  do_print("Create mobile folder with bookmarks");
+  ({ id: mobileId, guid: mobileGuid } = yield insertMobileFolder(db));
+  ({ guid: fxGuid } = yield insertBookmark(db, {
+    type: TYPE_BOOKMARK,
+    url: "http://getfirefox.com",
+    parentGuid: mobileGuid,
+  }));
+
+  // We should only have one mobile folder, but, in case an old version of Sync
+  // did the wrong thing and created multiple mobile folders, we should merge
+  // their contents into the new mobile root.
+  do_print("Create second mobile folder with different bookmarks");
+  ({ id: dupeMobileId, guid: dupeMobileGuid } = yield insertMobileFolder(db));
+  ({ guid: tbGuid } = yield insertBookmark(db, {
+    type: TYPE_BOOKMARK,
+    url: "http://getthunderbird.com",
+    parentGuid: dupeMobileGuid,
+  }));
+
+  yield db.close();
+});
+
+add_task(function* database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_mobile_root() {
+  let fxBmk = yield PlacesUtils.bookmarks.fetch(fxGuid);
+  equal(fxBmk.parentGuid, PlacesUtils.bookmarks.mobileGuid,
+    "Firefox bookmark should be moved to new mobile root");
+  equal(fxBmk.index, 0, "Firefox bookmark should be first child of new root");
+
+  let tbBmk = yield PlacesUtils.bookmarks.fetch(tbGuid);
+  equal(tbBmk.parentGuid, PlacesUtils.bookmarks.mobileGuid,
+    "Thunderbird bookmark should be moved to new mobile root");
+  equal(tbBmk.index, 1,
+    "Thunderbird bookmark should be second child of new root");
+
+  let mobileRootId = PlacesUtils.promiseItemId(
+    PlacesUtils.bookmarks.mobileGuid);
+  let annoItemIds = PlacesUtils.annotations.getItemsWithAnnotation(
+    PlacesUtils.MOBILE_ROOT_ANNO, {});
+  deepEqual(annoItemIds, [mobileRootId],
+    "Only mobile root should have mobile anno");
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v34_no_roots.js b/toolkit/components/places/tests/migration/test_current_from_v34_no_roots.js
new file mode 100644
index 000000000..871fe8993
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v34_no_roots.js
@@ -0,0 +1,21 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v34.sqlite");
+  // Setup database contents to be migrated.
+  let path = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  let db = yield Sqlite.openConnection({ path });
+  // Remove all the roots.
+  yield db.execute("DELETE FROM moz_bookmarks");
+  yield db.close();
+});
+
+add_task(function* database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v6.js b/toolkit/components/places/tests/migration/test_current_from_v6.js
new file mode 100644
index 000000000..a3f9dc229
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v6.js
@@ -0,0 +1,38 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests migration from a preliminary schema version 6 that
+ * lacks frecency column and moz_inputhistory table.
+ */
+
+add_task(function* setup() {
+  yield setupPlacesDatabase("places_v6.sqlite");
+});
+
+add_task(function* corrupt_database_not_exists() {
+  let corruptPath = OS.Path.join(OS.Constants.Path.profileDir,
+                                 "places.sqlite.corrupt");
+  Assert.ok(!(yield OS.File.exists(corruptPath)), "Corrupt file should not exist");
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_CORRUPT);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* check_columns() {
+  // Check the database has been replaced, these would throw otherwise.
+  let db = yield PlacesUtils.promiseDBConnection();
+  yield db.execute("SELECT frecency from moz_places");
+  yield db.execute("SELECT 1 from moz_inputhistory");
+});
+
+add_task(function* corrupt_database_exists() {
+  let corruptPath = OS.Path.join(OS.Constants.Path.profileDir,
+                                 "places.sqlite.corrupt");
+  Assert.ok((yield OS.File.exists(corruptPath)), "Corrupt file should exist");
+});
diff --git a/toolkit/components/places/tests/migration/xpcshell.ini b/toolkit/components/places/tests/migration/xpcshell.ini
new file mode 100644
index 000000000..aae0f75ee
--- /dev/null
+++ b/toolkit/components/places/tests/migration/xpcshell.ini
@@ -0,0 +1,36 @@
+[DEFAULT]
+head = head_migration.js
+tail =
+
+support-files =
+  places_v6.sqlite
+  places_v10.sqlite
+  places_v11.sqlite
+  places_v17.sqlite
+  places_v19.sqlite
+  places_v21.sqlite
+  places_v22.sqlite
+  places_v23.sqlite
+  places_v24.sqlite
+  places_v25.sqlite
+  places_v26.sqlite
+  places_v27.sqlite
+  places_v28.sqlite
+  places_v30.sqlite
+  places_v31.sqlite
+  places_v32.sqlite
+  places_v33.sqlite
+  places_v34.sqlite
+  places_v35.sqlite
+
+[test_current_from_downgraded.js]
+[test_current_from_v6.js]
+[test_current_from_v11.js]
+[test_current_from_v19.js]
+[test_current_from_v24.js]
+[test_current_from_v25.js]
+[test_current_from_v26.js]
+[test_current_from_v27.js]
+[test_current_from_v31.js]
+[test_current_from_v34.js]
+[test_current_from_v34_no_roots.js]
diff --git a/toolkit/components/places/tests/moz.build b/toolkit/components/places/tests/moz.build
new file mode 100644
index 000000000..a40c0e93a
--- /dev/null
+++ b/toolkit/components/places/tests/moz.build
@@ -0,0 +1,67 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+TEST_DIRS += ['cpp']
+
+TESTING_JS_MODULES += [
+    'PlacesTestUtils.jsm',
+]
+
+XPCSHELL_TESTS_MANIFESTS += [
+    'bookmarks/xpcshell.ini',
+    'expiration/xpcshell.ini',
+    'favicons/xpcshell.ini',
+    'history/xpcshell.ini',
+    'migration/xpcshell.ini',
+    'queries/xpcshell.ini',
+    'unifiedcomplete/xpcshell.ini',
+    'unit/xpcshell.ini',
+]
+
+BROWSER_CHROME_MANIFESTS += ['browser/browser.ini']
+MOCHITEST_CHROME_MANIFESTS += [
+    'chrome/chrome.ini',
+]
+
+TEST_HARNESS_FILES.xpcshell.toolkit.components.places.tests += [
+    'head_common.js',
+]
+
+TEST_HARNESS_FILES.testing.mochitest.tests.toolkit.components.places.tests.browser += [
+    'browser/399606-history.go-0.html',
+    'browser/399606-httprefresh.html',
+    'browser/399606-location.reload.html',
+    'browser/399606-location.replace.html',
+    'browser/399606-window.location.href.html',
+    'browser/399606-window.location.html',
+    'browser/461710_iframe.html',
+    'browser/461710_link_page-2.html',
+    'browser/461710_link_page-3.html',
+    'browser/461710_link_page.html',
+    'browser/461710_visited_page.html',
+    'browser/begin.html',
+    'browser/favicon-normal16.png',
+    'browser/favicon-normal32.png',
+    'browser/favicon.html',
+    'browser/final.html',
+    'browser/history_post.html',
+    'browser/history_post.sjs',
+    'browser/redirect-target.html',
+    'browser/redirect.sjs',
+    'browser/redirect_once.sjs',
+    'browser/redirect_twice.sjs',
+    'browser/title1.html',
+    'browser/title2.html',
+]
+
+TEST_HARNESS_FILES.testing.mochitest.tests.toolkit.components.places.tests.chrome += [
+    'chrome/bad_links.atom',
+    'chrome/link-less-items-no-site-uri.rss',
+    'chrome/link-less-items.rss',
+    'chrome/rss_as_html.rss',
+    'chrome/rss_as_html.rss^headers^',
+    'chrome/sample_feed.atom',
+]
diff --git a/toolkit/components/places/tests/queries/.eslintrc.js b/toolkit/components/places/tests/queries/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/places/tests/queries/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/queries/head_queries.js b/toolkit/components/places/tests/queries/head_queries.js
new file mode 100644
index 000000000..d37b3365f
--- /dev/null
+++ b/toolkit/components/places/tests/queries/head_queries.js
@@ -0,0 +1,370 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+// Import common head.
+{
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
+
+// Put any other stuff relative to this test folder below.
+
+
+// Some Useful Date constants - PRTime uses microseconds, so convert
+const DAY_MICROSEC = 86400000000;
+const today = PlacesUtils.toPRTime(Date.now());
+const yesterday = today - DAY_MICROSEC;
+const lastweek = today - (DAY_MICROSEC * 7);
+const daybefore = today - (DAY_MICROSEC * 2);
+const old = today - (DAY_MICROSEC * 3);
+const futureday = today + (DAY_MICROSEC * 3);
+const olderthansixmonths = today - (DAY_MICROSEC * 31 * 7);
+
+
+/**
+ * Generalized function to pull in an array of objects of data and push it into
+ * the database.  It does NOT do any checking to see that the input is
+ * appropriate.  This function is an asynchronous task, it can be called using
+ * "Task.spawn" or using the "yield" function inside another task.
+ */
+function* task_populateDB(aArray)
+{
+  // Iterate over aArray and execute all instructions.
+  for (let arrayItem of aArray) {
+    try {
+      // make the data object into a query data object in order to create proper
+      // default values for anything left unspecified
+      var qdata = new queryData(arrayItem);
+      if (qdata.isVisit) {
+        // Then we should add a visit for this node
+        yield PlacesTestUtils.addVisits({
+          uri: uri(qdata.uri),
+          transition: qdata.transType,
+          visitDate: qdata.lastVisit,
+          referrer: qdata.referrer ? uri(qdata.referrer) : null,
+          title: qdata.title
+        });
+        if (qdata.visitCount && !qdata.isDetails) {
+          // Set a fake visit_count, this is not a real count but can be used
+          // to test sorting by visit_count.
+          let stmt = DBConn().createAsyncStatement(
+            "UPDATE moz_places SET visit_count = :vc WHERE url_hash = hash(:url) AND url = :url");
+          stmt.params.vc = qdata.visitCount;
+          stmt.params.url = qdata.uri;
+          try {
+            stmt.executeAsync();
+          }
+          catch (ex) {
+            print("Error while setting visit_count.");
+          }
+          finally {
+            stmt.finalize();
+          }
+        }
+      }
+
+      if (qdata.isRedirect) {
+        // This must be async to properly enqueue after the updateFrecency call
+        // done by the visit addition.
+        let stmt = DBConn().createAsyncStatement(
+          "UPDATE moz_places SET hidden = 1 WHERE url_hash = hash(:url) AND url = :url");
+        stmt.params.url = qdata.uri;
+        try {
+          stmt.executeAsync();
+        }
+        catch (ex) {
+          print("Error while setting hidden.");
+        }
+        finally {
+          stmt.finalize();
+        }
+      }
+
+      if (qdata.isDetails) {
+        // Then we add extraneous page details for testing
+        yield PlacesTestUtils.addVisits({
+          uri: uri(qdata.uri),
+          visitDate: qdata.lastVisit,
+          title: qdata.title
+        });
+      }
+
+      if (qdata.markPageAsTyped) {
+        PlacesUtils.history.markPageAsTyped(uri(qdata.uri));
+      }
+
+      if (qdata.isPageAnnotation) {
+        if (qdata.removeAnnotation)
+          PlacesUtils.annotations.removePageAnnotation(uri(qdata.uri),
+                                                       qdata.annoName);
+        else {
+          PlacesUtils.annotations.setPageAnnotation(uri(qdata.uri),
+                                                    qdata.annoName,
+                                                    qdata.annoVal,
+                                                    qdata.annoFlags,
+                                                    qdata.annoExpiration);
+        }
+      }
+
+      if (qdata.isItemAnnotation) {
+        if (qdata.removeAnnotation)
+          PlacesUtils.annotations.removeItemAnnotation(qdata.itemId,
+                                                       qdata.annoName);
+        else {
+          PlacesUtils.annotations.setItemAnnotation(qdata.itemId,
+                                                    qdata.annoName,
+                                                    qdata.annoVal,
+                                                    qdata.annoFlags,
+                                                    qdata.annoExpiration);
+        }
+      }
+
+      if (qdata.isFolder) {
+        yield PlacesUtils.bookmarks.insert({
+          parentGuid: qdata.parentGuid,
+          type: PlacesUtils.bookmarks.TYPE_FOLDER,
+          title: qdata.title,
+          index: qdata.index
+        });
+      }
+
+      if (qdata.isLivemark) {
+        yield PlacesUtils.livemarks.addLivemark({ title: qdata.title
+                                                , parentId: (yield PlacesUtils.promiseItemId(qdata.parentGuid))
+                                                , index: qdata.index
+                                                , feedURI: uri(qdata.feedURI)
+                                                , siteURI: uri(qdata.uri)
+                                                });
+      }
+
+      if (qdata.isBookmark) {
+        let data = {
+          parentGuid: qdata.parentGuid,
+          index: qdata.index,
+          title: qdata.title,
+          url: qdata.uri
+        };
+
+        if (qdata.dateAdded) {
+          data.dateAdded = new Date(qdata.dateAdded / 1000);
+        }
+
+        if (qdata.lastModified) {
+          data.lastModified = new Date(qdata.lastModified / 1000);
+        }
+
+        yield PlacesUtils.bookmarks.insert(data);
+
+        if (qdata.keyword) {
+          yield PlacesUtils.keywords.insert({ url: qdata.uri,
+                                              keyword: qdata.keyword });
+        }
+      }
+
+      if (qdata.isTag) {
+        PlacesUtils.tagging.tagURI(uri(qdata.uri), qdata.tagArray);
+      }
+
+      if (qdata.isSeparator) {
+        yield PlacesUtils.bookmarks.insert({
+          parentGuid: qdata.parentGuid,
+          type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+          index: qdata.index
+        });
+      }
+    } catch (ex) {
+      // use the arrayItem object here in case instantiation of qdata failed
+      do_print("Problem with this URI: " + arrayItem.uri);
+      do_throw("Error creating database: " + ex + "\n");
+    }
+  }
+}
+
+
+/**
+ * The Query Data Object - this object encapsulates data for our queries and is
+ * used to parameterize our calls to the Places APIs to put data into the
+ * database. It also has some interesting meta functions to determine which APIs
+ * should be called, and to determine if this object should show up in the
+ * resulting query.
+ * Its parameter is an object specifying which attributes you want to set.
+ * For ex:
+ * var myobj = new queryData({isVisit: true, uri:"http://mozilla.com", title="foo"});
+ * Note that it doesn't do any input checking on that object.
+ */
+function queryData(obj) {
+  this.isVisit = obj.isVisit ? obj.isVisit : false;
+  this.isBookmark = obj.isBookmark ? obj.isBookmark: false;
+  this.uri = obj.uri ? obj.uri : "";
+  this.lastVisit = obj.lastVisit ? obj.lastVisit : today;
+  this.referrer = obj.referrer ? obj.referrer : null;
+  this.transType = obj.transType ? obj.transType : Ci.nsINavHistoryService.TRANSITION_TYPED;
+  this.isRedirect = obj.isRedirect ? obj.isRedirect : false;
+  this.isDetails = obj.isDetails ? obj.isDetails : false;
+  this.title = obj.title ? obj.title : "";
+  this.markPageAsTyped = obj.markPageAsTyped ? obj.markPageAsTyped : false;
+  this.isPageAnnotation = obj.isPageAnnotation ? obj.isPageAnnotation : false;
+  this.removeAnnotation= obj.removeAnnotation ? true : false;
+  this.annoName = obj.annoName ? obj.annoName : "";
+  this.annoVal = obj.annoVal ? obj.annoVal : "";
+  this.annoFlags = obj.annoFlags ? obj.annoFlags : 0;
+  this.annoExpiration = obj.annoExpiration ? obj.annoExpiration : 0;
+  this.isItemAnnotation = obj.isItemAnnotation ? obj.isItemAnnotation : false;
+  this.itemId = obj.itemId ? obj.itemId : 0;
+  this.annoMimeType = obj.annoMimeType ? obj.annoMimeType : "";
+  this.isTag = obj.isTag ? obj.isTag : false;
+  this.tagArray = obj.tagArray ? obj.tagArray : null;
+  this.isLivemark = obj.isLivemark ? obj.isLivemark : false;
+  this.parentGuid = obj.parentGuid || PlacesUtils.bookmarks.rootGuid;
+  this.feedURI = obj.feedURI ? obj.feedURI : "";
+  this.index = obj.index ? obj.index : PlacesUtils.bookmarks.DEFAULT_INDEX;
+  this.isFolder = obj.isFolder ? obj.isFolder : false;
+  this.contractId = obj.contractId ? obj.contractId : "";
+  this.lastModified = obj.lastModified ? obj.lastModified : null;
+  this.dateAdded = obj.dateAdded ? obj.dateAdded : null;
+  this.keyword = obj.keyword ? obj.keyword : "";
+  this.visitCount = obj.visitCount ? obj.visitCount : 0;
+  this.isSeparator = obj.hasOwnProperty("isSeparator") && obj.isSeparator;
+
+  // And now, the attribute for whether or not this object should appear in the
+  // resulting query
+  this.isInQuery = obj.isInQuery ? obj.isInQuery : false;
+}
+
+// All attributes are set in the constructor above
+queryData.prototype = { }
+
+
+/**
+ * Helper function to compare an array of query objects with a result set.
+ * It assumes the array of query objects contains the SAME SORT as the result
+ * set.  It checks the the uri, title, time, and bookmarkIndex properties of
+ * the results, where appropriate.
+ */
+function compareArrayToResult(aArray, aRoot) {
+  do_print("Comparing Array to Results");
+
+  var wasOpen = aRoot.containerOpen;
+  if (!wasOpen)
+    aRoot.containerOpen = true;
+
+  // check expected number of results against actual
+  var expectedResultCount = aArray.filter(function(aEl) { return aEl.isInQuery; }).length;
+  if (expectedResultCount != aRoot.childCount) {
+    // Debugging code for failures.
+    dump_table("moz_places");
+    dump_table("moz_historyvisits");
+    do_print("Found children:");
+    for (let i = 0; i < aRoot.childCount; i++) {
+      do_print(aRoot.getChild(i).uri);
+    }
+    do_print("Expected:");
+    for (let i = 0; i < aArray.length; i++) {
+      if (aArray[i].isInQuery)
+        do_print(aArray[i].uri);
+    }
+  }
+  do_check_eq(expectedResultCount, aRoot.childCount);
+
+  var inQueryIndex = 0;
+  for (var i = 0; i < aArray.length; i++) {
+    if (aArray[i].isInQuery) {
+      var child = aRoot.getChild(inQueryIndex);
+      // do_print("testing testData[" + i + "] vs result[" + inQueryIndex + "]");
+      if (!aArray[i].isFolder && !aArray[i].isSeparator) {
+        do_print("testing testData[" + aArray[i].uri + "] vs result[" + child.uri + "]");
+        if (aArray[i].uri != child.uri) {
+          dump_table("moz_places");
+          do_throw("Expected " + aArray[i].uri + " found " + child.uri);
+        }
+      }
+      if (!aArray[i].isSeparator && aArray[i].title != child.title)
+        do_throw("Expected " + aArray[i].title + " found " + child.title);
+      if (aArray[i].hasOwnProperty("lastVisit") &&
+          aArray[i].lastVisit != child.time)
+        do_throw("Expected " + aArray[i].lastVisit + " found " + child.time);
+      if (aArray[i].hasOwnProperty("index") &&
+          aArray[i].index != PlacesUtils.bookmarks.DEFAULT_INDEX &&
+          aArray[i].index != child.bookmarkIndex)
+        do_throw("Expected " + aArray[i].index + " found " + child.bookmarkIndex);
+
+      inQueryIndex++;
+    }
+  }
+
+  if (!wasOpen)
+    aRoot.containerOpen = false;
+  do_print("Comparing Array to Results passes");
+}
+
+
+/**
+ * Helper function to check to see if one object either is or is not in the
+ * result set.  It can accept either a queryData object or an array of queryData
+ * objects.  If it gets an array, it only compares the first object in the array
+ * to see if it is in the result set.
+ * Returns: True if item is in query set, and false if item is not in query set
+ *          If input is an array, returns True if FIRST object in array is in
+ *          query set.  To compare entire array, use the function above.
+ */
+function isInResult(aQueryData, aRoot) {
+  var rv = false;
+  var uri;
+  var wasOpen = aRoot.containerOpen;
+  if (!wasOpen)
+    aRoot.containerOpen = true;
+
+  // If we have an array, pluck out the first item. If an object, pluc out the
+  // URI, we just compare URI's here.
+  if ("uri" in aQueryData) {
+    uri = aQueryData.uri;
+  } else {
+    uri = aQueryData[0].uri;
+  }
+
+  for (var i=0; i < aRoot.childCount; i++) {
+    if (uri == aRoot.getChild(i).uri) {
+      rv = true;
+      break;
+    }
+  }
+  if (!wasOpen)
+    aRoot.containerOpen = false;
+  return rv;
+}
+
+
+/**
+ * A nice helper function for debugging things. It prints the contents of a
+ * result set.
+ */
+function displayResultSet(aRoot) {
+
+  var wasOpen = aRoot.containerOpen;
+  if (!wasOpen)
+    aRoot.containerOpen = true;
+
+  if (!aRoot.hasChildren) {
+    // Something wrong? Empty result set?
+    do_print("Result Set Empty");
+    return;
+  }
+
+  for (var i=0; i < aRoot.childCount; ++i) {
+    do_print("Result Set URI: " + aRoot.getChild(i).uri + "   Title: " +
+        aRoot.getChild(i).title + "   Visit Time: " + aRoot.getChild(i).time);
+  }
+  if (!wasOpen)
+    aRoot.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/queries/readme.txt b/toolkit/components/places/tests/queries/readme.txt
new file mode 100644
index 000000000..19414f96e
--- /dev/null
+++ b/toolkit/components/places/tests/queries/readme.txt
@@ -0,0 +1,16 @@
+These are tests specific to the Places Query API.
+
+We are tracking the coverage of these tests here:
+http://wiki.mozilla.org/QA/TDAI/Projects/Places_Tests
+
+When creating one of these tests, you need to update those tables so that we
+know how well our test coverage is of this area.  Furthermore, when adding tests
+ensure to cover live update (changing the query set) by performing the following
+operations on the query set you get after running the query:
+* Adding a new item to the query set
+* Updating an existing item so that it matches the query set
+* Change an existing item so that it does not match the query set
+* Do multiple of the above inside an Update Batch transaction.
+* Try these transactions in different orders.
+
+Use the stub test to help you create a test with the proper structure.
diff --git a/toolkit/components/places/tests/queries/test_415716.js b/toolkit/components/places/tests/queries/test_415716.js
new file mode 100644
index 000000000..754a73e7c
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_415716.js
@@ -0,0 +1,108 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function modHistoryTypes(val) {
+  switch (val % 8) {
+    case 0:
+    case 1:
+      return TRANSITION_LINK;
+    case 2:
+      return TRANSITION_TYPED;
+    case 3:
+      return TRANSITION_BOOKMARK;
+    case 4:
+      return TRANSITION_EMBED;
+    case 5:
+      return TRANSITION_REDIRECT_PERMANENT;
+    case 6:
+      return TRANSITION_REDIRECT_TEMPORARY;
+    case 7:
+      return TRANSITION_DOWNLOAD;
+    case 8:
+      return TRANSITION_FRAMED_LINK;
+  }
+  return TRANSITION_TYPED;
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+/**
+ * Builds a test database by hand using various times, annotations and
+ * visit numbers for this test
+ */
+add_task(function* test_buildTestDatabase()
+{
+  // This is the set of visits that we will match - our min visit is 2 so that's
+  // why we add more visits to the same URIs.
+  let testURI = uri("http://www.foo.com");
+  let places = [];
+
+  for (let i = 0; i < 12; ++i) {
+    places.push({
+      uri: testURI,
+      transition: modHistoryTypes(i),
+      visitDate: today
+    });
+  }
+
+  testURI = uri("http://foo.com/youdontseeme.html");
+  let testAnnoName = "moz-test-places/testing123";
+  let testAnnoVal = "test";
+  for (let i = 0; i < 12; ++i) {
+    places.push({
+      uri: testURI,
+      transition: modHistoryTypes(i),
+      visitDate: today
+    });
+  }
+
+  yield PlacesTestUtils.addVisits(places);
+
+  PlacesUtils.annotations.setPageAnnotation(testURI, testAnnoName,
+                                            testAnnoVal, 0, 0);
+});
+
+/**
+ * This test will test Queries that use relative Time Range, minVists, maxVisits,
+ * annotation.
+ * The Query:
+ * Annotation == "moz-test-places/testing123" &&
+ * TimeRange == "now() - 2d" &&
+ * minVisits == 2 &&
+ * maxVisits == 10
+ */
+add_task(function test_execute()
+{
+  let query = PlacesUtils.history.getNewQuery();
+  query.annotation = "moz-test-places/testing123";
+  query.beginTime = daybefore * 1000;
+  query.beginTimeReference = PlacesUtils.history.TIME_RELATIVE_NOW;
+  query.endTime = today * 1000;
+  query.endTimeReference = PlacesUtils.history.TIME_RELATIVE_NOW;
+  query.minVisits = 2;
+  query.maxVisits = 10;
+
+  // Options
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  options.resultType = options.RESULTS_AS_VISIT;
+
+  // Results
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  let cc = root.childCount;
+  dump("----> cc is: " + cc + "\n");
+  for (let i = 0; i < root.childCount; ++i) {
+    let resultNode = root.getChild(i);
+    let accesstime = Date(resultNode.time / 1000);
+    dump("----> result: " + resultNode.uri + "   Date: " + accesstime.toLocaleString() + "\n");
+  }
+  do_check_eq(cc, 0);
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_abstime-annotation-domain.js b/toolkit/components/places/tests/queries/test_abstime-annotation-domain.js
new file mode 100644
index 000000000..199fc0865
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_abstime-annotation-domain.js
@@ -0,0 +1,210 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const DAY_MSEC = 86400000;
+const MIN_MSEC = 60000;
+const HOUR_MSEC = 3600000;
+// Jan 6 2008 at 8am is our begin edge of the query
+var beginTimeDate = new Date(2008, 0, 6, 8, 0, 0, 0);
+// Jan 15 2008 at 9:30pm is our ending edge of the query
+var endTimeDate = new Date(2008, 0, 15, 21, 30, 0, 0);
+
+// These as millisecond values
+var beginTime = beginTimeDate.getTime();
+var endTime = endTimeDate.getTime();
+
+// Some range dates inside our query - mult by 1000 to convert to PRTIME
+var jan7_800 = (beginTime + DAY_MSEC) * 1000;
+var jan6_815 = (beginTime + (MIN_MSEC * 15)) * 1000;
+var jan11_800 = (beginTime + (DAY_MSEC * 5)) * 1000;
+var jan14_2130 = (endTime - DAY_MSEC) * 1000;
+var jan15_2045 = (endTime - (MIN_MSEC * 45)) * 1000;
+var jan12_1730 = (endTime - (DAY_MSEC * 3) - (HOUR_MSEC*4)) * 1000;
+
+// Dates outside our query - mult by 1000 to convert to PRTIME
+var jan6_700 = (beginTime - HOUR_MSEC) * 1000;
+var jan5_800 = (beginTime - DAY_MSEC) * 1000;
+var dec27_800 = (beginTime - (DAY_MSEC * 10)) * 1000;
+var jan15_2145 = (endTime + (MIN_MSEC * 15)) * 1000;
+var jan16_2130 = (endTime + (DAY_MSEC)) * 1000;
+var jan25_2130 = (endTime + (DAY_MSEC * 10)) * 1000;
+
+// So that we can easily use these too, convert them to PRTIME
+beginTime *= 1000;
+endTime *= 1000;
+
+/**
+ * Array of objects to build our test database
+ */
+var goodAnnoName = "moz-test-places/testing123";
+var val = "test";
+var badAnnoName = "text/foo";
+
+// The test data for our database, note that the ordering of the results that
+// will be returned by the query (the isInQuery: true objects) is IMPORTANT.
+// see compareArrayToResult in head_queries.js for more info.
+var testData = [
+  // Test ftp protocol - vary the title length
+  {isInQuery: true, isVisit: true, isDetails: true,
+   uri: "ftp://foo.com/ftp", lastVisit: jan12_1730,
+   title: "hugelongconfmozlagurationofwordswithasearchtermsinit whoo-hoo"},
+
+  // Test flat domain with annotation
+  {isInQuery: true, isVisit: true, isDetails: true, isPageAnnotation: true,
+   uri: "http://foo.com/", annoName: goodAnnoName, annoVal: val,
+   lastVisit: jan14_2130, title: "moz"},
+
+  // Test subdomain included with isRedirect=true, different transtype
+  {isInQuery: true, isVisit: true, isDetails: true, title: "moz",
+   isRedirect: true, uri: "http://mail.foo.com/redirect", lastVisit: jan11_800,
+   transType: PlacesUtils.history.TRANSITION_LINK},
+
+  // Test subdomain inclued at the leading time edge
+  {isInQuery: true, isVisit: true, isDetails: true,
+   uri: "http://mail.foo.com/yiihah", title: "moz", lastVisit: jan6_815},
+
+  // Test www. style URI is included, with an annotation
+  {isInQuery: true, isVisit: true, isDetails: true, isPageAnnotation: true,
+   uri: "http://www.foo.com/yiihah", annoName: goodAnnoName, annoVal: val,
+   lastVisit: jan7_800, title: "moz"},
+
+  // Test https protocol
+  {isInQuery: true, isVisit: true, isDetails: true, title: "moz",
+   uri: "https://foo.com/", lastVisit: jan15_2045},
+
+  // Test begin edge of time
+  {isInQuery: true, isVisit: true, isDetails: true, title: "moz mozilla",
+   uri: "https://foo.com/begin.html", lastVisit: beginTime},
+
+  // Test end edge of time
+  {isInQuery: true, isVisit: true, isDetails: true, title: "moz mozilla",
+   uri: "https://foo.com/end.html", lastVisit: endTime},
+
+  // Test an image link, with annotations
+  {isInQuery: true, isVisit: true, isDetails: true, isPageAnnotation: true,
+   title: "mozzie the dino", uri: "https://foo.com/mozzie.png",
+   annoName: goodAnnoName, annoVal: val, lastVisit: jan14_2130},
+
+  // Begin the invalid queries: Test too early
+  {isInQuery: false, isVisit:true, isDetails: true, title: "moz",
+   uri: "http://foo.com/tooearly.php", lastVisit: jan6_700},
+
+  // Test Bad Annotation
+  {isInQuery: false, isVisit:true, isDetails: true, isPageAnnotation: true,
+   title: "moz", uri: "http://foo.com/badanno.htm", lastVisit: jan12_1730,
+   annoName: badAnnoName, annoVal: val},
+
+  // Test bad URI
+  {isInQuery: false, isVisit:true, isDetails: true, title: "moz",
+   uri: "http://somefoo.com/justwrong.htm", lastVisit: jan11_800},
+
+  // Test afterward, one to update
+  {isInQuery: false, isVisit:true, isDetails: true, title: "changeme",
+   uri: "http://foo.com/changeme1.htm", lastVisit: jan12_1730},
+
+  // Test invalid title
+  {isInQuery: false, isVisit:true, isDetails: true, title: "changeme2",
+   uri: "http://foo.com/changeme2.htm", lastVisit: jan7_800},
+
+  // Test changing the lastVisit
+  {isInQuery: false, isVisit:true, isDetails: true, title: "moz",
+   uri: "http://foo.com/changeme3.htm", lastVisit: dec27_800}];
+
+/**
+ * This test will test a Query using several terms and do a bit of negative
+ * testing for items that should be ignored while querying over history.
+ * The Query:WHERE absoluteTime(matches) AND searchTerms AND URI
+ *                 AND annotationIsNot(match) GROUP BY Domain, Day SORT BY uri,ascending
+ *                 excludeITems(should be ignored)
+ */
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_abstime_annotation_domain()
+{
+  // Initialize database
+  yield task_populateDB(testData);
+
+  // Query
+  var query = PlacesUtils.history.getNewQuery();
+  query.beginTime = beginTime;
+  query.endTime = endTime;
+  query.beginTimeReference = PlacesUtils.history.TIME_RELATIVE_EPOCH;
+  query.endTimeReference = PlacesUtils.history.TIME_RELATIVE_EPOCH;
+  query.searchTerms = "moz";
+  query.domain = "foo.com";
+  query.domainIsHost = false;
+  query.annotation = "text/foo";
+  query.annotationIsNot = true;
+
+  // Options
+  var options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_URI_ASCENDING;
+  options.resultType = options.RESULTS_AS_URI;
+  // The next two options should be ignored
+  // can't use this one, breaks test - bug 419779
+  // options.excludeItems = true;
+
+  // Results
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  // Ensure the result set is correct
+  compareArrayToResult(testData, root);
+
+  // Make some changes to the result set
+  // Let's add something first
+  var addItem = [{isInQuery: true, isVisit: true, isDetails: true, title: "moz",
+                 uri: "http://www.foo.com/i-am-added.html", lastVisit: jan11_800}];
+  yield task_populateDB(addItem);
+  do_print("Adding item foo.com/i-am-added.html");
+  do_check_eq(isInResult(addItem, root), true);
+
+  // Let's update something by title
+  var change1 = [{isDetails: true, uri: "http://foo.com/changeme1",
+                  lastVisit: jan12_1730, title: "moz moz mozzie"}];
+  yield task_populateDB(change1);
+  do_print("LiveUpdate by changing title");
+  do_check_eq(isInResult(change1, root), true);
+
+  // Let's update something by annotation
+  // Updating a page by removing an annotation does not cause it to join this
+  // query set.  I tend to think that it should cause that page to join this
+  // query set, because this visit fits all theother specified criteria once the
+  // annotation is removed. Uncommenting this will fail the test.
+  // Bug 424050
+  /* var change2 = [{isPageAnnotation: true, uri: "http://foo.com/badannotaion.html",
+                  annoName: "text/mozilla", annoVal: "test"}];
+  yield task_populateDB(change2);
+  do_print("LiveUpdate by removing annotation");
+  do_check_eq(isInResult(change2, root), true);*/
+
+  // Let's update by adding a visit in the time range for an existing URI
+  var change3 = [{isDetails: true, uri: "http://foo.com/changeme3.htm",
+                  title: "moz", lastVisit: jan15_2045}];
+  yield task_populateDB(change3);
+  do_print("LiveUpdate by adding visit within timerange");
+  do_check_eq(isInResult(change3, root), true);
+
+  // And delete something from the result set - using annotation
+  // Once again, bug 424050 prevents this from passing
+  /* var change4 = [{isPageAnnotation: true, uri: "ftp://foo.com/ftp",
+                  annoVal: "test", annoName: badAnnoName}];
+  yield task_populateDB(change4);
+  do_print("LiveUpdate by deleting item from set by adding annotation");
+  do_check_eq(isInResult(change4, root), false);*/
+
+  // Delete something by changing the title
+  var change5 = [{isDetails: true, uri: "http://foo.com/end.html", title: "deleted"}];
+  yield task_populateDB(change5);
+  do_print("LiveUpdate by deleting item by changing title");
+  do_check_eq(isInResult(change5, root), false);
+
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_abstime-annotation-uri.js b/toolkit/components/places/tests/queries/test_abstime-annotation-uri.js
new file mode 100644
index 000000000..145d2cb59
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_abstime-annotation-uri.js
@@ -0,0 +1,162 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const DAY_MSEC = 86400000;
+const MIN_MSEC = 60000;
+const HOUR_MSEC = 3600000;
+// Jan 6 2008 at 8am is our begin edge of the query
+var beginTimeDate = new Date(2008, 0, 6, 8, 0, 0, 0);
+// Jan 15 2008 at 9:30pm is our ending edge of the query
+var endTimeDate = new Date(2008, 0, 15, 21, 30, 0, 0);
+
+// These as millisecond values
+var beginTime = beginTimeDate.getTime();
+var endTime = endTimeDate.getTime();
+
+// Some range dates inside our query - mult by 1000 to convert to PRTIME
+var jan7_800 = (beginTime + DAY_MSEC) * 1000;
+var jan6_815 = (beginTime + (MIN_MSEC * 15)) * 1000;
+var jan11_800 = (beginTime + (DAY_MSEC * 5)) * 1000;
+var jan14_2130 = (endTime - DAY_MSEC) * 1000;
+var jan15_2045 = (endTime - (MIN_MSEC * 45)) * 1000;
+var jan12_1730 = (endTime - (DAY_MSEC * 3) - (HOUR_MSEC*4)) * 1000;
+
+// Dates outside our query - mult by 1000 to convert to PRTIME
+var jan6_700 = (beginTime - HOUR_MSEC) * 1000;
+var jan5_800 = (beginTime - DAY_MSEC) * 1000;
+var dec27_800 = (beginTime - (DAY_MSEC * 10)) * 1000;
+var jan15_2145 = (endTime + (MIN_MSEC * 15)) * 1000;
+var jan16_2130 = (endTime + (DAY_MSEC)) * 1000;
+var jan25_2130 = (endTime + (DAY_MSEC * 10)) * 1000;
+
+// So that we can easily use these too, convert them to PRTIME
+beginTime *= 1000;
+endTime *= 1000;
+
+/**
+ * Array of objects to build our test database
+ */
+var goodAnnoName = "moz-test-places/testing123";
+var val = "test";
+var badAnnoName = "text/foo";
+
+// The test data for our database, note that the ordering of the results that
+// will be returned by the query (the isInQuery: true objects) is IMPORTANT.
+// see compareArrayToResult in head_queries.js for more info.
+var testData = [
+
+  // Test flat domain with annotation
+  {isInQuery: true, isVisit: true, isDetails: true, isPageAnnotation: true,
+   uri: "http://foo.com/", annoName: goodAnnoName, annoVal: val,
+   lastVisit: jan14_2130, title: "moz"},
+
+  // Begin the invalid queries:
+  // Test www. style URI is not included, with an annotation
+  {isInQuery: false, isVisit: true, isDetails: true, isPageAnnotation: true,
+   uri: "http://www.foo.com/yiihah", annoName: goodAnnoName, annoVal: val,
+   lastVisit: jan7_800, title: "moz"},
+
+   // Test subdomain not inclued at the leading time edge
+   {isInQuery: false, isVisit: true, isDetails: true,
+    uri: "http://mail.foo.com/yiihah", title: "moz", lastVisit: jan6_815},
+
+  // Test https protocol
+  {isInQuery: false, isVisit: true, isDetails: true, title: "moz",
+   uri: "https://foo.com/", lastVisit: jan15_2045},
+
+   // Test ftp protocol
+   {isInQuery: false, isVisit: true, isDetails: true,
+    uri: "ftp://foo.com/ftp", lastVisit: jan12_1730,
+    title: "hugelongconfmozlagurationofwordswithasearchtermsinit whoo-hoo"},
+
+  // Test too early
+  {isInQuery: false, isVisit:true, isDetails: true, title: "moz",
+   uri: "http://foo.com/tooearly.php", lastVisit: jan6_700},
+
+  // Test Bad Annotation
+  {isInQuery: false, isVisit:true, isDetails: true, isPageAnnotation: true,
+   title: "moz", uri: "http://foo.com/badanno.htm", lastVisit: jan12_1730,
+   annoName: badAnnoName, annoVal: val},
+
+  // Test afterward, one to update
+  {isInQuery: false, isVisit:true, isDetails: true, title: "changeme",
+   uri: "http://foo.com/changeme1.htm", lastVisit: jan12_1730},
+
+  // Test invalid title
+  {isInQuery: false, isVisit:true, isDetails: true, title: "changeme2",
+   uri: "http://foo.com/changeme2.htm", lastVisit: jan7_800},
+
+  // Test changing the lastVisit
+  {isInQuery: false, isVisit:true, isDetails: true, title: "moz",
+   uri: "http://foo.com/changeme3.htm", lastVisit: dec27_800}];
+
+/**
+ * This test will test a Query using several terms and do a bit of negative
+ * testing for items that should be ignored while querying over history.
+ * The Query:WHERE absoluteTime(matches) AND searchTerms AND URI
+ *                 AND annotationIsNot(match) GROUP BY Domain, Day SORT BY uri,ascending
+ *                 excludeITems(should be ignored)
+ */
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_abstime_annotation_uri()
+{
+  // Initialize database
+  yield task_populateDB(testData);
+
+  // Query
+  var query = PlacesUtils.history.getNewQuery();
+  query.beginTime = beginTime;
+  query.endTime = endTime;
+  query.beginTimeReference = PlacesUtils.history.TIME_RELATIVE_EPOCH;
+  query.endTimeReference = PlacesUtils.history.TIME_RELATIVE_EPOCH;
+  query.searchTerms = "moz";
+  query.uri = uri("http://foo.com");
+  query.annotation = "text/foo";
+  query.annotationIsNot = true;
+
+  // Options
+  var options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_URI_ASCENDING;
+  options.resultType = options.RESULTS_AS_URI;
+  // The next two options should be ignored
+  // can't use this one, breaks test - bug 419779
+  // options.excludeItems = true;
+
+  // Results
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  // Ensure the result set is correct
+  compareArrayToResult(testData, root);
+
+  // live update.
+  do_print("change title");
+  var change1 = [{isDetails: true, uri:"http://foo.com/",
+                  title: "mo"}, ];
+  yield task_populateDB(change1);
+  do_check_false(isInResult({uri: "http://foo.com/"}, root));
+
+  var change2 = [{isDetails: true, uri:"http://foo.com/",
+                  title: "moz", lastvisit: endTime}, ];
+  yield task_populateDB(change2);
+  dump_table("moz_places");
+  do_check_false(isInResult({uri: "http://foo.com/"}, root));
+
+  // Let's delete something from the result set - using annotation
+  var change3 = [{isPageAnnotation: true,
+                  uri: "http://foo.com/",
+                  annoName: badAnnoName, annoVal: "test"}];
+  yield task_populateDB(change3);
+  do_print("LiveUpdate by removing annotation");
+  do_check_false(isInResult({uri: "http://foo.com/"}, root));
+
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_async.js b/toolkit/components/places/tests/queries/test_async.js
new file mode 100644
index 000000000..0ec99f8fc
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_async.js
@@ -0,0 +1,371 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var tests = [
+  {
+    desc: "nsNavHistoryFolderResultNode: Basic test, asynchronously open and " +
+          "close container with a single child",
+
+    loading: function (node, newState, oldState) {
+      this.checkStateChanged("loading", 1);
+      this.checkArgs("loading", node, oldState, node.STATE_CLOSED);
+    },
+
+    opened: function (node, newState, oldState) {
+      this.checkStateChanged("opened", 1);
+      this.checkState("loading", 1);
+      this.checkArgs("opened", node, oldState, node.STATE_LOADING);
+
+      print("Checking node children");
+      compareArrayToResult(this.data, node);
+
+      print("Closing container");
+      node.containerOpen = false;
+    },
+
+    closed: function (node, newState, oldState) {
+      this.checkStateChanged("closed", 1);
+      this.checkState("opened", 1);
+      this.checkArgs("closed", node, oldState, node.STATE_OPENED);
+      this.success();
+    }
+  },
+
+  {
+    desc: "nsNavHistoryFolderResultNode: After async open and no changes, " +
+          "second open should be synchronous",
+
+    loading: function (node, newState, oldState) {
+      this.checkStateChanged("loading", 1);
+      this.checkState("closed", 0);
+      this.checkArgs("loading", node, oldState, node.STATE_CLOSED);
+    },
+
+    opened: function (node, newState, oldState) {
+      let cnt = this.checkStateChanged("opened", 1, 2);
+      let expectOldState = cnt === 1 ? node.STATE_LOADING : node.STATE_CLOSED;
+      this.checkArgs("opened", node, oldState, expectOldState);
+
+      print("Checking node children");
+      compareArrayToResult(this.data, node);
+
+      print("Closing container");
+      node.containerOpen = false;
+    },
+
+    closed: function (node, newState, oldState) {
+      let cnt = this.checkStateChanged("closed", 1, 2);
+      this.checkArgs("closed", node, oldState, node.STATE_OPENED);
+
+      switch (cnt) {
+      case 1:
+        node.containerOpen = true;
+        break;
+      case 2:
+        this.success();
+        break;
+      }
+    }
+  },
+
+  {
+    desc: "nsNavHistoryFolderResultNode: After closing container in " +
+          "loading(), opened() should not be called",
+
+    loading: function (node, newState, oldState) {
+      this.checkStateChanged("loading", 1);
+      this.checkArgs("loading", node, oldState, node.STATE_CLOSED);
+      print("Closing container");
+      node.containerOpen = false;
+    },
+
+    opened: function (node, newState, oldState) {
+      do_throw("opened should not be called");
+    },
+
+    closed: function (node, newState, oldState) {
+      this.checkStateChanged("closed", 1);
+      this.checkState("loading", 1);
+      this.checkArgs("closed", node, oldState, node.STATE_LOADING);
+      this.success();
+    }
+  }
+];
+
+
+/**
+ * Instances of this class become the prototypes of the test objects above.
+ * Each test can therefore use the methods of this class, or they can override
+ * them if they want.  To run a test, call setup() and then run().
+ */
+function Test() {
+  // This maps a state name to the number of times it's been observed.
+  this.stateCounts = {};
+  // Promise object resolved when the next test can be run.
+  this.deferNextTest = Promise.defer();
+}
+
+Test.prototype = {
+  /**
+   * Call this when an observer observes a container state change to sanity
+   * check the arguments.
+   *
+   * @param aNewState
+   *        The name of the new state.  Used only for printing out helpful info.
+   * @param aNode
+   *        The node argument passed to containerStateChanged.
+   * @param aOldState
+   *        The old state argument passed to containerStateChanged.
+   * @param aExpectOldState
+   *        The expected old state.
+   */
+  checkArgs: function (aNewState, aNode, aOldState, aExpectOldState) {
+    print("Node passed on " + aNewState + " should be result.root");
+    do_check_eq(this.result.root, aNode);
+    print("Old state passed on " + aNewState + " should be " + aExpectOldState);
+
+    // aOldState comes from xpconnect and will therefore be defined.  It may be
+    // zero, though, so use strict equality just to make sure aExpectOldState is
+    // also defined.
+    do_check_true(aOldState === aExpectOldState);
+  },
+
+  /**
+   * Call this when an observer observes a container state change.  It registers
+   * the state change and ensures that it has been observed the given number
+   * of times.  See checkState for parameter explanations.
+   *
+   * @return The number of times aState has been observed, including the new
+   *         observation.
+   */
+  checkStateChanged: function (aState, aExpectedMin, aExpectedMax) {
+    print(aState + " state change observed");
+    if (!this.stateCounts.hasOwnProperty(aState))
+      this.stateCounts[aState] = 0;
+    this.stateCounts[aState]++;
+    return this.checkState(aState, aExpectedMin, aExpectedMax);
+  },
+
+  /**
+   * Ensures that the state has been observed the given number of times.
+   *
+   * @param  aState
+   *         The name of the state.
+   * @param  aExpectedMin
+   *         The state must have been observed at least this number of times.
+   * @param  aExpectedMax
+   *         The state must have been observed at most this number of times.
+   *         This parameter is optional.  If undefined, it's set to
+   *         aExpectedMin.
+   * @return The number of times aState has been observed, including the new
+   *         observation.
+   */
+  checkState: function (aState, aExpectedMin, aExpectedMax) {
+    let cnt = this.stateCounts[aState] || 0;
+    if (aExpectedMax === undefined)
+      aExpectedMax = aExpectedMin;
+    if (aExpectedMin === aExpectedMax) {
+      print(aState + " should be observed only " + aExpectedMin +
+            " times (actual = " + cnt + ")");
+    }
+    else {
+      print(aState + " should be observed at least " + aExpectedMin +
+            " times and at most " + aExpectedMax + " times (actual = " +
+            cnt + ")");
+    }
+    do_check_true(cnt >= aExpectedMin && cnt <= aExpectedMax);
+    return cnt;
+  },
+
+  /**
+   * Asynchronously opens the root of the test's result.
+   */
+  openContainer: function () {
+    // Set up the result observer.  It delegates to this object's callbacks and
+    // wraps them in a try-catch so that errors don't get eaten.
+    let self = this;
+    this.observer = {
+      containerStateChanged: function (container, oldState, newState) {
+        print("New state passed to containerStateChanged() should equal the " +
+              "container's current state");
+        do_check_eq(newState, container.state);
+
+        try {
+          switch (newState) {
+          case Ci.nsINavHistoryContainerResultNode.STATE_LOADING:
+            self.loading(container, newState, oldState);
+            break;
+          case Ci.nsINavHistoryContainerResultNode.STATE_OPENED:
+            self.opened(container, newState, oldState);
+            break;
+          case Ci.nsINavHistoryContainerResultNode.STATE_CLOSED:
+            self.closed(container, newState, oldState);
+            break;
+          default:
+            do_throw("Unexpected new state! " + newState);
+          }
+        }
+        catch (err) {
+          do_throw(err);
+        }
+      },
+    };
+    this.result.addObserver(this.observer, false);
+
+    print("Opening container");
+    this.result.root.containerOpen = true;
+  },
+
+  /**
+   * Starts the test and returns a promise resolved when the test completes.
+   */
+  run: function () {
+    this.openContainer();
+    return this.deferNextTest.promise;
+  },
+
+  /**
+   * This must be called before run().  It adds a bookmark and sets up the
+   * test's result.  Override if need be.
+   */
+  setup: function*() {
+    // Populate the database with different types of bookmark items.
+    this.data = DataHelper.makeDataArray([
+      { type: "bookmark" },
+      { type: "separator" },
+      { type: "folder" },
+      { type: "bookmark", uri: "place:terms=foo" }
+    ]);
+    yield task_populateDB(this.data);
+
+    // Make a query.
+    this.query = PlacesUtils.history.getNewQuery();
+    this.query.setFolders([DataHelper.defaults.bookmark.parent], 1);
+    this.opts = PlacesUtils.history.getNewQueryOptions();
+    this.opts.asyncEnabled = true;
+    this.result = PlacesUtils.history.executeQuery(this.query, this.opts);
+  },
+
+  /**
+   * Call this when the test has succeeded.  It cleans up resources and starts
+   * the next test.
+   */
+  success: function () {
+    this.result.removeObserver(this.observer);
+
+    // Resolve the promise object that indicates that the next test can be run.
+    this.deferNextTest.resolve();
+  }
+};
+
+/**
+ * This makes it a little bit easier to use the functions of head_queries.js.
+ */
+var DataHelper = {
+  defaults: {
+    bookmark: {
+      parent: PlacesUtils.bookmarks.unfiledBookmarksFolder,
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+      uri: "http://example.com/",
+      title: "test bookmark"
+    },
+
+    folder: {
+      parent: PlacesUtils.bookmarks.unfiledBookmarksFolder,
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+      title: "test folder"
+    },
+
+    separator: {
+      parent: PlacesUtils.bookmarks.unfiledBookmarksFolder,
+      parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    }
+  },
+
+  /**
+   * Converts an array of simple bookmark item descriptions to the more verbose
+   * format required by task_populateDB() in head_queries.js.
+   *
+   * @param  aData
+   *         An array of objects, each of which describes a bookmark item.
+   * @return An array of objects suitable for passing to populateDB().
+   */
+  makeDataArray: function DH_makeDataArray(aData) {
+    let self = this;
+    return aData.map(function (dat) {
+      let type = dat.type;
+      dat = self._makeDataWithDefaults(dat, self.defaults[type]);
+      switch (type) {
+      case "bookmark":
+        return {
+          isBookmark: true,
+          uri: dat.uri,
+          parentGuid: dat.parentGuid,
+          index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+          title: dat.title,
+          isInQuery: true
+        };
+      case "separator":
+        return {
+          isSeparator: true,
+          parentGuid: dat.parentGuid,
+          index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+          isInQuery: true
+        };
+      case "folder":
+        return {
+          isFolder: true,
+          parentGuid: dat.parentGuid,
+          index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+          title: dat.title,
+          isInQuery: true
+        };
+      default:
+        do_throw("Unknown data type when populating DB: " + type);
+        return undefined;
+      }
+    });
+  },
+
+  /**
+   * Returns a copy of aData, except that any properties that are undefined but
+   * defined in aDefaults are set to the corresponding values in aDefaults.
+   *
+   * @param  aData
+   *         An object describing a bookmark item.
+   * @param  aDefaults
+   *         An object describing the default bookmark item.
+   * @return A copy of aData with defaults values set.
+   */
+  _makeDataWithDefaults: function DH__makeDataWithDefaults(aData, aDefaults) {
+    let dat = {};
+    for (let [prop, val] of Object.entries(aDefaults)) {
+      dat[prop] = aData.hasOwnProperty(prop) ? aData[prop] : val;
+    }
+    return dat;
+  }
+};
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_async()
+{
+  for (let test of tests) {
+    yield PlacesUtils.bookmarks.eraseEverything();
+
+    test.__proto__ = new Test();
+    yield test.setup();
+
+    print("------ Running test: " + test.desc);
+    yield test.run();
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  print("All tests done, exiting");
+});
diff --git a/toolkit/components/places/tests/queries/test_containersQueries_sorting.js b/toolkit/components/places/tests/queries/test_containersQueries_sorting.js
new file mode 100644
index 000000000..ab9f2bf90
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_containersQueries_sorting.js
@@ -0,0 +1,411 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Testing behavior of bug 473157
+ * "Want to sort history in container view without sorting the containers"
+ * and regression bug 488783
+ * Tags list no longer sorted (alphabetized).
+ * This test is for global testing sorting containers queries.
+ */
+
+// Globals and Constants
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+var bh = hs.QueryInterface(Ci.nsIBrowserHistory);
+var tagging = Cc["@mozilla.org/browser/tagging-service;1"].
+              getService(Ci.nsITaggingService);
+
+var resultTypes = [
+  {value: Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY, name: "RESULTS_AS_DATE_QUERY"},
+  {value: Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY, name: "RESULTS_AS_SITE_QUERY"},
+  {value: Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY, name: "RESULTS_AS_DATE_SITE_QUERY"},
+  {value: Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAG_QUERY, name: "RESULTS_AS_TAG_QUERY"},
+];
+
+var sortingModes = [
+  {value: Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_ASCENDING, name: "SORT_BY_TITLE_ASCENDING"},
+  {value: Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_DESCENDING, name: "SORT_BY_TITLE_DESCENDING"},
+  {value: Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_ASCENDING, name: "SORT_BY_DATE_ASCENDING"},
+  {value: Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING, name: "SORT_BY_DATE_DESCENDING"},
+  {value: Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_ASCENDING, name: "SORT_BY_DATEADDED_ASCENDING"},
+  {value: Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_DESCENDING, name: "SORT_BY_DATEADDED_DESCENDING"},
+];
+
+// These pages will be added from newest to oldest and from less visited to most
+// visited.
+var pages = [
+  "http://www.mozilla.org/c/",
+  "http://www.mozilla.org/a/",
+  "http://www.mozilla.org/b/",
+  "http://www.mozilla.com/c/",
+  "http://www.mozilla.com/a/",
+  "http://www.mozilla.com/b/",
+];
+
+var tags = [
+  "mozilla",
+  "Development",
+  "test",
+];
+
+// Test Runner
+
+/**
+ * Enumerates all the sequences of the cartesian product of the arrays contained
+ * in aSequences.  Examples:
+ *
+ *   cartProd([[1, 2, 3], ["a", "b"]], callback);
+ *   // callback is called 3 * 2 = 6 times with the following arrays:
+ *   // [1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]
+ *
+ *   cartProd([["a"], [1, 2, 3], ["X", "Y"]], callback);
+ *   // callback is called 1 * 3 * 2 = 6 times with the following arrays:
+ *   // ["a", 1, "X"], ["a", 1, "Y"], ["a", 2, "X"], ["a", 2, "Y"],
+ *   // ["a", 3, "X"], ["a", 3, "Y"]
+ *
+ *   cartProd([[1], [2], [3], [4]], callback);
+ *   // callback is called 1 * 1 * 1 * 1 = 1 time with the following array:
+ *   // [1, 2, 3, 4]
+ *
+ *   cartProd([], callback);
+ *   // callback is 0 times
+ *
+ *   cartProd([[1, 2, 3, 4]], callback);
+ *   // callback is called 4 times with the following arrays:
+ *   // [1], [2], [3], [4]
+ *
+ * @param  aSequences
+ *         an array that contains an arbitrary number of arrays
+ * @param  aCallback
+ *         a function that is passed each sequence of the product as it's
+ *         computed
+ * @return the total number of sequences in the product
+ */
+function cartProd(aSequences, aCallback)
+{
+  if (aSequences.length === 0)
+    return 0;
+
+  // For each sequence in aSequences, we maintain a pointer (an array index,
+  // really) to the element we're currently enumerating in that sequence
+  var seqEltPtrs = aSequences.map(i => 0);
+
+  var numProds = 0;
+  var done = false;
+  while (!done) {
+    numProds++;
+
+    // prod = sequence in product we're currently enumerating
+    var prod = [];
+    for (var i = 0; i < aSequences.length; i++) {
+      prod.push(aSequences[i][seqEltPtrs[i]]);
+    }
+    aCallback(prod);
+
+    // The next sequence in the product differs from the current one by just a
+    // single element.  Determine which element that is.  We advance the
+    // "rightmost" element pointer to the "right" by one.  If we move past the
+    // end of that pointer's sequence, reset the pointer to the first element
+    // in its sequence and then try the sequence to the "left", and so on.
+
+    // seqPtr = index of rightmost input sequence whose element pointer is not
+    // past the end of the sequence
+    var seqPtr = aSequences.length - 1;
+    while (!done) {
+      // Advance the rightmost element pointer.
+      seqEltPtrs[seqPtr]++;
+
+      // The rightmost element pointer is past the end of its sequence.
+      if (seqEltPtrs[seqPtr] >= aSequences[seqPtr].length) {
+        seqEltPtrs[seqPtr] = 0;
+        seqPtr--;
+
+        // All element pointers are past the ends of their sequences.
+        if (seqPtr < 0)
+          done = true;
+      }
+      else break;
+    }
+  }
+  return numProds;
+}
+
+/**
+ * Test a query based on passed-in options.
+ *
+ * @param aSequence
+ *        array of options we will use to query.
+ */
+function test_query_callback(aSequence) {
+  do_check_eq(aSequence.length, 2);
+  var resultType = aSequence[0];
+  var sortingMode = aSequence[1];
+  print("\n\n*** Testing default sorting for resultType (" + resultType.name + ") and sortingMode (" + sortingMode.name + ")");
+
+  // Skip invalid combinations sorting queries by none.
+  if (resultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAG_QUERY &&
+      (sortingMode.value == Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_ASCENDING ||
+       sortingMode.value == Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING)) {
+    // This is a bookmark query, we can't sort by visit date.
+    sortingMode.value = Ci.nsINavHistoryQueryOptions.SORT_BY_NONE;
+  }
+  if (resultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY ||
+      resultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY ||
+      resultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY) {
+    // This is an history query, we can't sort by date added.
+    if (sortingMode.value == Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_ASCENDING ||
+       sortingMode.value == Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_DESCENDING)
+    sortingMode.value = Ci.nsINavHistoryQueryOptions.SORT_BY_NONE;
+  }
+
+  // Create a new query with required options.
+  var query = PlacesUtils.history.getNewQuery();
+  var options = PlacesUtils.history.getNewQueryOptions();
+  options.resultType = resultType.value;
+  options.sortingMode = sortingMode.value;
+
+  // Compare resultset with expectedData.
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  if (resultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY ||
+      resultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY) {
+    // Date containers are always sorted by date descending.
+    check_children_sorting(root,
+                           Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING);
+  }
+  else
+    check_children_sorting(root, sortingMode.value);
+
+  // Now Check sorting of the first child container.
+  var container = root.getChild(0)
+                      .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  container.containerOpen = true;
+
+  if (resultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY) {
+    // Has more than one level of containers, first we check the sorting of
+    // the first level (site containers), those won't inherit sorting...
+    check_children_sorting(container,
+                           Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_ASCENDING);
+    // ...then we check sorting of the contained urls, we can't inherit sorting
+    // since the above level does not inherit it, so they will be sorted by
+    // title ascending.
+    let innerContainer = container.getChild(0)
+                                  .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+    innerContainer.containerOpen = true;
+    check_children_sorting(innerContainer,
+                           Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_ASCENDING);
+    innerContainer.containerOpen = false;
+  }
+  else if (resultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAG_QUERY) {
+    // Sorting mode for tag contents is hardcoded for now, to allow for faster
+    // duplicates filtering.
+    check_children_sorting(container,
+                           Ci.nsINavHistoryQueryOptions.SORT_BY_NONE);
+  }
+  else
+    check_children_sorting(container, sortingMode.value);
+
+  container.containerOpen = false;
+  root.containerOpen = false;
+
+  test_result_sortingMode_change(result, resultType, sortingMode);
+}
+
+/**
+ * Sets sortingMode on aResult and checks for correct sorting of children.
+ * Containers should not change their sorting, while contained uri nodes should.
+ *
+ * @param aResult
+ *        nsINavHistoryResult generated by our query.
+ * @param aResultType
+ *        required result type.
+ * @param aOriginalSortingMode
+ *        the sorting mode from query's options.
+ */
+function test_result_sortingMode_change(aResult, aResultType, aOriginalSortingMode) {
+  var root = aResult.root;
+  // Now we set sortingMode on the result and check that containers are not
+  // sorted while children are.
+  sortingModes.forEach(function sortingModeChecker(aForcedSortingMode) {
+    print("\n* Test setting sortingMode (" + aForcedSortingMode.name + ") " +
+          "on result with resultType (" + aResultType.name + ") " +
+          "currently sorted as (" + aOriginalSortingMode.name + ")");
+
+    aResult.sortingMode = aForcedSortingMode.value;
+    root.containerOpen = true;
+
+    if (aResultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY ||
+        aResultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY) {
+      // Date containers are always sorted by date descending.
+      check_children_sorting(root,
+                             Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING);
+    }
+    else if (aResultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY &&
+             (aOriginalSortingMode.value == Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_ASCENDING ||
+              aOriginalSortingMode.value == Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING)) {
+      // Site containers don't have a good time property to sort by.
+      check_children_sorting(root,
+                             Ci.nsINavHistoryQueryOptions.SORT_BY_NONE);
+    }
+    else
+      check_children_sorting(root, aOriginalSortingMode.value);
+
+    // Now Check sorting of the first child container.
+    var container = root.getChild(0)
+                        .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+    container.containerOpen = true;
+
+    if (aResultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY) {
+      // Has more than one level of containers, first we check the sorting of
+      // the first level (site containers), those won't be sorted...
+      check_children_sorting(container,
+                             Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_ASCENDING);
+      // ...then we check sorting of the second level of containers, result
+      // will sort them through recursiveSort.
+      let innerContainer = container.getChild(0)
+                                    .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+      innerContainer.containerOpen = true;
+      check_children_sorting(innerContainer, aForcedSortingMode.value);
+      innerContainer.containerOpen = false;
+    }
+    else {
+      if (aResultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY ||
+          aResultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY ||
+          aResultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY) {
+        // Date containers are always sorted by date descending.
+        check_children_sorting(root, Ci.nsINavHistoryQueryOptions.SORT_BY_NONE);
+      }
+      else if (aResultType.value == Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY &&
+             (aOriginalSortingMode.value == Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_ASCENDING ||
+              aOriginalSortingMode.value == Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING)) {
+        // Site containers don't have a good time property to sort by.
+        check_children_sorting(root, Ci.nsINavHistoryQueryOptions.SORT_BY_NONE);
+      }
+      else
+        check_children_sorting(root, aOriginalSortingMode.value);
+
+      // Children should always be sorted.
+      check_children_sorting(container, aForcedSortingMode.value);
+    }
+
+    container.containerOpen = false;
+    root.containerOpen = false;
+  });
+}
+
+/**
+ * Test if children of aRootNode are correctly sorted.
+ * @param aRootNode
+ *        already opened root node from our query's result.
+ * @param aExpectedSortingMode
+ *        The sortingMode we expect results to be.
+ */
+function check_children_sorting(aRootNode, aExpectedSortingMode) {
+  var results = [];
+  print("Found children:");
+  for (let i = 0; i < aRootNode.childCount; i++) {
+    results[i] = aRootNode.getChild(i);
+    print(i + " " + results[i].title);
+  }
+
+  // Helper for case insensitive string comparison.
+  function caseInsensitiveStringComparator(a, b) {
+    var aLC = a.toLowerCase();
+    var bLC = b.toLowerCase();
+    if (aLC < bLC)
+      return -1;
+    if (aLC > bLC)
+      return 1;
+    return 0;
+  }
+
+  // Get a comparator based on expected sortingMode.
+  var comparator;
+  switch (aExpectedSortingMode) {
+    case Ci.nsINavHistoryQueryOptions.SORT_BY_NONE:
+      comparator = function (a, b) {
+        return 0;
+      }
+      break;
+    case Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_ASCENDING:
+      comparator = function (a, b) {
+        return caseInsensitiveStringComparator(a.title, b.title);
+      }
+      break;
+    case Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_DESCENDING:
+      comparator = function (a, b) {
+        return -caseInsensitiveStringComparator(a.title, b.title);
+      }
+      break;
+    case Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_ASCENDING:
+      comparator = function (a, b) {
+        return a.time - b.time;
+      }
+      break;
+    case Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING:
+      comparator = function (a, b) {
+        return b.time - a.time;
+      }
+    case Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_ASCENDING:
+      comparator = function (a, b) {
+        return a.dateAdded - b.dateAdded;
+      }
+      break;
+    case Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_DESCENDING:
+      comparator = function (a, b) {
+        return b.dateAdded - a.dateAdded;
+      }
+      break;
+    default:
+      do_throw("Unknown sorting type: " + aExpectedSortingMode);
+  }
+
+  // Make an independent copy of the results array and sort it.
+  var sortedResults = results.slice();
+  sortedResults.sort(comparator);
+  // Actually compare returned children with our sorted array.
+  for (let i = 0; i < sortedResults.length; i++) {
+    if (sortedResults[i].title != results[i].title)
+      print(i + " index wrong, expected " + sortedResults[i].title +
+            " found " + results[i].title);
+    do_check_eq(sortedResults[i].title, results[i].title);
+  }
+}
+
+// Main
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_containersQueries_sorting()
+{
+  // Add visits, bookmarks and tags to our database.
+  var timeInMilliseconds = Date.now();
+  var visitCount = 0;
+  var dayOffset = 0;
+  var visits = [];
+  pages.forEach(aPageUrl => visits.push(
+    { isVisit: true,
+      isBookmark: true,
+      transType: Ci.nsINavHistoryService.TRANSITION_TYPED,
+      uri: aPageUrl,
+      title: aPageUrl,
+      // subtract 5 hours per iteration, to expose more than one day container.
+      lastVisit: (timeInMilliseconds - (18000 * 1000 * dayOffset++)) * 1000,
+      visitCount: visitCount++,
+      isTag: true,
+      tagArray: tags,
+      isInQuery: true }));
+  yield task_populateDB(visits);
+
+  cartProd([resultTypes, sortingModes], test_query_callback);
+});
diff --git a/toolkit/components/places/tests/queries/test_history_queries_tags_liveUpdate.js b/toolkit/components/places/tests/queries/test_history_queries_tags_liveUpdate.js
new file mode 100644
index 000000000..fbbacf6c9
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_history_queries_tags_liveUpdate.js
@@ -0,0 +1,200 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// This test ensures that tags changes are correctly live-updated in a history
+// query.
+
+let timeInMicroseconds = PlacesUtils.toPRTime(Date.now() - 10000);
+
+function newTimeInMicroseconds() {
+  timeInMicroseconds = timeInMicroseconds + 1000;
+  return timeInMicroseconds;
+}
+
+var gTestData = [
+  {
+    isVisit: true,
+    uri: "http://example.com/1/",
+    lastVisit: newTimeInMicroseconds(),
+    isInQuery: true,
+    isBookmark: true,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+    title: "example1",
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/2/",
+    lastVisit: newTimeInMicroseconds(),
+    isInQuery: true,
+    isBookmark: true,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+    title: "example2",
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/3/",
+    lastVisit: newTimeInMicroseconds(),
+    isInQuery: true,
+    isBookmark: true,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+    title: "example3",
+  },
+];
+
+function newQueryWithOptions()
+{
+  return [ PlacesUtils.history.getNewQuery(),
+           PlacesUtils.history.getNewQueryOptions() ];
+}
+
+function testQueryContents(aQuery, aOptions, aCallback)
+{
+  let root = PlacesUtils.history.executeQuery(aQuery, aOptions).root;
+  root.containerOpen = true;
+  aCallback(root);
+  root.containerOpen = false;
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_initialize()
+{
+  yield task_populateDB(gTestData);
+});
+
+add_task(function pages_query()
+{
+  let [query, options] = newQueryWithOptions();
+  testQueryContents(query, options, function (root) {
+    compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+    for (let i = 0; i < root.childCount; i++) {
+      let node = root.getChild(i);
+      let uri = NetUtil.newURI(node.uri);
+      do_check_eq(node.tags, null);
+      PlacesUtils.tagging.tagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, "test-tag");
+      PlacesUtils.tagging.untagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, null);
+    }
+  });
+});
+
+add_task(function visits_query()
+{
+  let [query, options] = newQueryWithOptions();
+  options.resultType = Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT;
+  testQueryContents(query, options, function (root) {
+    compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+    for (let i = 0; i < root.childCount; i++) {
+      let node = root.getChild(i);
+      let uri = NetUtil.newURI(node.uri);
+      do_check_eq(node.tags, null);
+      PlacesUtils.tagging.tagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, "test-tag");
+      PlacesUtils.tagging.untagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, null);
+    }
+  });
+});
+
+add_task(function bookmarks_query()
+{
+  let [query, options] = newQueryWithOptions();
+  query.setFolders([PlacesUtils.unfiledBookmarksFolderId], 1);
+  testQueryContents(query, options, function (root) {
+    compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+    for (let i = 0; i < root.childCount; i++) {
+      let node = root.getChild(i);
+      let uri = NetUtil.newURI(node.uri);
+      do_check_eq(node.tags, null);
+      PlacesUtils.tagging.tagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, "test-tag");
+      PlacesUtils.tagging.untagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, null);
+    }
+  });
+});
+
+add_task(function pages_searchterm_query()
+{
+  let [query, options] = newQueryWithOptions();
+  query.searchTerms = "example";
+  testQueryContents(query, options, function (root) {
+    compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+    for (let i = 0; i < root.childCount; i++) {
+      let node = root.getChild(i);
+      let uri = NetUtil.newURI(node.uri);
+      do_check_eq(node.tags, null);
+      PlacesUtils.tagging.tagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, "test-tag");
+      PlacesUtils.tagging.untagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, null);
+    }
+  });
+});
+
+add_task(function visits_searchterm_query()
+{
+  let [query, options] = newQueryWithOptions();
+  query.searchTerms = "example";
+  options.resultType = Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT;
+  testQueryContents(query, options, function (root) {
+    compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+    for (let i = 0; i < root.childCount; i++) {
+      let node = root.getChild(i);
+      let uri = NetUtil.newURI(node.uri);
+      do_check_eq(node.tags, null);
+      PlacesUtils.tagging.tagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, "test-tag");
+      PlacesUtils.tagging.untagURI(uri, ["test-tag"]);
+      do_check_eq(node.tags, null);
+    }
+  });
+});
+
+add_task(function pages_searchterm_is_tag_query()
+{
+  let [query, options] = newQueryWithOptions();
+  query.searchTerms = "test-tag";
+  testQueryContents(query, options, function (root) {
+    compareArrayToResult([], root);
+    gTestData.forEach(function (data) {
+      let uri = NetUtil.newURI(data.uri);
+      PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                           uri,
+                                           PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                           data.title);
+      PlacesUtils.tagging.tagURI(uri, ["test-tag"]);
+      compareArrayToResult([data], root);
+      PlacesUtils.tagging.untagURI(uri, ["test-tag"]);
+      compareArrayToResult([], root);
+    });
+  });
+});
+
+add_task(function visits_searchterm_is_tag_query()
+{
+  let [query, options] = newQueryWithOptions();
+  query.searchTerms = "test-tag";
+  options.resultType = Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT;
+  testQueryContents(query, options, function (root) {
+    compareArrayToResult([], root);
+    gTestData.forEach(function (data) {
+      let uri = NetUtil.newURI(data.uri);
+      PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                           uri,
+                                           PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                           data.title);
+      PlacesUtils.tagging.tagURI(uri, ["test-tag"]);
+      compareArrayToResult([data], root);
+      PlacesUtils.tagging.untagURI(uri, ["test-tag"]);
+      compareArrayToResult([], root);
+    });
+  });
+});
diff --git a/toolkit/components/places/tests/queries/test_history_queries_titles_liveUpdate.js b/toolkit/components/places/tests/queries/test_history_queries_titles_liveUpdate.js
new file mode 100644
index 000000000..eec87fe0e
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_history_queries_titles_liveUpdate.js
@@ -0,0 +1,210 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// This test ensures that tags changes are correctly live-updated in a history
+// query.
+
+let timeInMicroseconds = PlacesUtils.toPRTime(Date.now() - 10000);
+
+function newTimeInMicroseconds() {
+  timeInMicroseconds = timeInMicroseconds + 1000;
+  return timeInMicroseconds;
+}
+
+var gTestData = [
+  {
+    isVisit: true,
+    uri: "http://example.com/1/",
+    lastVisit: newTimeInMicroseconds(),
+    isInQuery: true,
+    title: "title1",
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/2/",
+    lastVisit: newTimeInMicroseconds(),
+    isInQuery: true,
+    title: "title2",
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/3/",
+    lastVisit: newTimeInMicroseconds(),
+    isInQuery: true,
+    title: "title3",
+  },
+];
+
+function searchNodeHavingUrl(aRoot, aUrl) {
+  for (let i = 0; i < aRoot.childCount; i++) {
+    if (aRoot.getChild(i).uri == aUrl) {
+      return aRoot.getChild(i);
+    }
+  }
+  return undefined;
+}
+
+function newQueryWithOptions()
+{
+  return [ PlacesUtils.history.getNewQuery(),
+           PlacesUtils.history.getNewQueryOptions() ];
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* pages_query()
+{
+  yield task_populateDB(gTestData);
+
+  let [query, options] = newQueryWithOptions();
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+  for (let i = 0; i < root.childCount; i++) {
+    let node = root.getChild(i);
+    do_check_eq(node.title, gTestData[i].title);
+    let uri = NetUtil.newURI(node.uri);
+    yield PlacesTestUtils.addVisits({uri: uri, title: "changedTitle"});
+    do_check_eq(node.title, "changedTitle");
+    yield PlacesTestUtils.addVisits({uri: uri, title: gTestData[i].title});
+    do_check_eq(node.title, gTestData[i].title);
+  }
+
+  root.containerOpen = false;
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* visits_query()
+{
+  yield task_populateDB(gTestData);
+
+  let [query, options] = newQueryWithOptions();
+  options.resultType = Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+
+  for (let testData of gTestData) {
+    let uri = NetUtil.newURI(testData.uri);
+    let node = searchNodeHavingUrl(root, testData.uri);
+    do_check_eq(node.title, testData.title);
+    yield PlacesTestUtils.addVisits({uri: uri, title: "changedTitle"});
+    node = searchNodeHavingUrl(root, testData.uri);
+    do_check_eq(node.title, "changedTitle");
+    yield PlacesTestUtils.addVisits({uri: uri, title: testData.title});
+    node = searchNodeHavingUrl(root, testData.uri);
+    do_check_eq(node.title, testData.title);
+  }
+
+  root.containerOpen = false;
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* pages_searchterm_query()
+{
+  yield task_populateDB(gTestData);
+
+  let [query, options] = newQueryWithOptions();
+  query.searchTerms = "example";
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+  for (let i = 0; i < root.childCount; i++) {
+    let node = root.getChild(i);
+    let uri = NetUtil.newURI(node.uri);
+    do_check_eq(node.title, gTestData[i].title);
+    yield PlacesTestUtils.addVisits({uri: uri, title: "changedTitle"});
+    do_check_eq(node.title, "changedTitle");
+    yield PlacesTestUtils.addVisits({uri: uri, title: gTestData[i].title});
+    do_check_eq(node.title, gTestData[i].title);
+  }
+
+  root.containerOpen = false;
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* visits_searchterm_query()
+{
+  yield task_populateDB(gTestData);
+
+  let [query, options] = newQueryWithOptions();
+  query.searchTerms = "example";
+  options.resultType = Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  compareArrayToResult([gTestData[0], gTestData[1], gTestData[2]], root);
+  for (let testData of gTestData) {
+    let uri = NetUtil.newURI(testData.uri);
+    let node = searchNodeHavingUrl(root, testData.uri);
+    do_check_eq(node.title, testData.title);
+    yield PlacesTestUtils.addVisits({uri: uri, title: "changedTitle"});
+    node = searchNodeHavingUrl(root, testData.uri);
+    do_check_eq(node.title, "changedTitle");
+    yield PlacesTestUtils.addVisits({uri: uri, title: testData.title});
+    node = searchNodeHavingUrl(root, testData.uri);
+    do_check_eq(node.title, testData.title);
+  }
+
+  root.containerOpen = false;
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* pages_searchterm_is_title_query()
+{
+  yield task_populateDB(gTestData);
+
+  let [query, options] = newQueryWithOptions();
+  query.searchTerms = "match";
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  compareArrayToResult([], root);
+  for (let data of gTestData) {
+    let uri = NetUtil.newURI(data.uri);
+    let origTitle = data.title;
+    data.title = "match";
+    yield PlacesTestUtils.addVisits({ uri: uri, title: data.title,
+                                      visitDate: data.lastVisit });
+    compareArrayToResult([data], root);
+    data.title = origTitle;
+    yield PlacesTestUtils.addVisits({ uri: uri, title: data.title,
+                                      visitDate: data.lastVisit });
+    compareArrayToResult([], root);
+  }
+
+  root.containerOpen = false;
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* visits_searchterm_is_title_query()
+{
+  yield task_populateDB(gTestData);
+
+  let [query, options] = newQueryWithOptions();
+  query.searchTerms = "match";
+  options.resultType = Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  compareArrayToResult([], root);
+  for (let data of gTestData) {
+    let uri = NetUtil.newURI(data.uri);
+    let origTitle = data.title;
+    data.title = "match";
+    yield PlacesTestUtils.addVisits({ uri: uri, title: data.title,
+                                      visitDate: data.lastVisit });
+    compareArrayToResult([data], root);
+    data.title = origTitle;
+    yield PlacesTestUtils.addVisits({ uri: uri, title: data.title,
+                                      visitDate: data.lastVisit });
+    compareArrayToResult([], root);
+  }
+
+  root.containerOpen = false;
+  yield PlacesTestUtils.clearHistory();
+});
diff --git a/toolkit/components/places/tests/queries/test_onlyBookmarked.js b/toolkit/components/places/tests/queries/test_onlyBookmarked.js
new file mode 100644
index 000000000..45704c109
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_onlyBookmarked.js
@@ -0,0 +1,128 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * The next thing we do is create a test database for us.  Each test runs with
+ * its own database (tail_queries.js will clear it after the run).  Take a look
+ * at the queryData object in head_queries.js, and you'll see how this object
+ * works.  You can call it anything you like, but I usually use "testData".
+ * I'll include a couple of example entries in the database.
+ *
+ * Note that to use the compareArrayToResult API, you need to put all the
+ * results that are in the query set at the top of the testData list, and those
+ * results MUST be in the same sort order as the items in the resulting query.
+ */
+
+var testData = [
+  // Add a bookmark that should be in the results
+  { isBookmark: true,
+    uri: "http://bookmarked.com/",
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+    isInQuery: true },
+
+  // Add a bookmark that should not be in the results
+  { isBookmark: true,
+    uri: "http://bookmarked-elsewhere.com/",
+    parentGuid: PlacesUtils.bookmarks.menuGuid,
+    index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+    isInQuery: false },
+
+  // Add an un-bookmarked visit
+  { isVisit: true,
+    uri: "http://notbookmarked.com/",
+    isInQuery: false }
+];
+
+
+/**
+ * run_test is where the magic happens.  This is automatically run by the test
+ * harness.  It is where you do the work of creating the query, running it, and
+ * playing with the result set.
+ */
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_onlyBookmarked()
+{
+  // This function in head_queries.js creates our database with the above data
+  yield task_populateDB(testData);
+
+  // Query
+  var query = PlacesUtils.history.getNewQuery();
+  query.setFolders([PlacesUtils.toolbarFolderId], 1);
+  query.onlyBookmarked = true;
+
+  // query options
+  var options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = options.QUERY_TYPE_HISTORY;
+
+  // Results - this gets the result set and opens it for reading and modification.
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  // You can use this to compare the data in the array with the result set,
+  // if the array's isInQuery: true items are sorted the same way as the result
+  // set.
+  do_print("begin first test");
+  compareArrayToResult(testData, root);
+  do_print("end first test");
+
+  // Test live-update
+  var liveUpdateTestData = [
+    // Add a bookmark that should show up
+    { isBookmark: true,
+      uri: "http://bookmarked2.com/",
+      parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+      index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+      isInQuery: true },
+
+    // Add a bookmark that should not show up
+    { isBookmark: true,
+      uri: "http://bookmarked-elsewhere2.com/",
+      parentGuid: PlacesUtils.bookmarks.menuGuid,
+      index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+      isInQuery: false }
+  ];
+
+  yield task_populateDB(liveUpdateTestData); // add to the db
+
+  // add to the test data
+  testData.push(liveUpdateTestData[0]);
+  testData.push(liveUpdateTestData[1]);
+
+  // re-query and test
+  do_print("begin live-update test");
+  compareArrayToResult(testData, root);
+  do_print("end live-update test");
+/*
+  // we are actually not updating during a batch.
+  // see bug 432706 for details.
+
+  // Here's a batch update
+  var updateBatch = {
+    runBatched: function (aUserData) {
+      liveUpdateTestData[0].uri = "http://bookmarked3.com";
+      liveUpdateTestData[1].uri = "http://bookmarked-elsewhere3.com";
+      populateDB(liveUpdateTestData);
+      testData.push(liveUpdateTestData[0]);
+      testData.push(liveUpdateTestData[1]);
+    }
+  };
+
+  PlacesUtils.history.runInBatchMode(updateBatch, null);
+
+  // re-query and test
+  do_print("begin batched test");
+  compareArrayToResult(testData, root);
+  do_print("end batched test");
+*/
+  // Close the container when finished
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_queryMultipleFolder.js b/toolkit/components/places/tests/queries/test_queryMultipleFolder.js
new file mode 100644
index 000000000..694728a43
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_queryMultipleFolder.js
@@ -0,0 +1,65 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_queryMultipleFolders() {
+  // adding bookmarks in the folders
+  let folderIds = [];
+  let bookmarkIds = [];
+  for (let i = 0; i < 3; ++i) {
+    let folder = yield PlacesUtils.bookmarks.insert({
+      parentGuid: PlacesUtils.bookmarks.menuGuid,
+      type: PlacesUtils.bookmarks.TYPE_FOLDER,
+      title: `Folder${i}`
+    });
+    folderIds.push(yield PlacesUtils.promiseItemId(folder.guid));
+
+    for (let j = 0; j < 7; ++j) {
+      let bm = yield PlacesUtils.bookmarks.insert({
+        parentGuid: (yield PlacesUtils.promiseItemGuid(folderIds[i])),
+        url: `http://Bookmark${i}_${j}.com`,
+        title: ""
+      });
+      bookmarkIds.push(yield PlacesUtils.promiseItemId(bm.guid));
+    }
+  }
+
+  // using queryStringToQueries
+  let query = {};
+  let options = {};
+  let maxResults = 20;
+  let queryString = "place:" + folderIds.map((id) => {
+    return "folder=" + id;
+  }).join('&') + "&sort=5&maxResults=" + maxResults;
+  PlacesUtils.history.queryStringToQueries(queryString, query, {}, options);
+  let rootNode = PlacesUtils.history.executeQuery(query.value[0], options.value).root;
+  rootNode.containerOpen = true;
+  let resultLength = rootNode.childCount;
+  Assert.equal(resultLength, maxResults);
+  for (let i = 0; i < resultLength; ++i) {
+    let node = rootNode.getChild(i);
+    Assert.equal(bookmarkIds[i], node.itemId, node.uri);
+  }
+  rootNode.containerOpen = false;
+
+  // using getNewQuery and getNewQueryOptions
+  query = PlacesUtils.history.getNewQuery();
+  options = PlacesUtils.history.getNewQueryOptions();
+  query.setFolders(folderIds, folderIds.length);
+  options.sortingMode = options.SORT_BY_URI_ASCENDING;
+  options.maxResults = maxResults;
+  rootNode = PlacesUtils.history.executeQuery(query, options).root;
+  rootNode.containerOpen = true;
+  resultLength = rootNode.childCount;
+  Assert.equal(resultLength, maxResults);
+  for (let i = 0; i < resultLength; ++i) {
+    let node = rootNode.getChild(i);
+    Assert.equal(bookmarkIds[i], node.itemId, node.uri);
+  }
+  rootNode.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_querySerialization.js b/toolkit/components/places/tests/queries/test_querySerialization.js
new file mode 100644
index 000000000..24cf8aa9b
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_querySerialization.js
@@ -0,0 +1,797 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Tests Places query serialization.  Associated bug is
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=370197
+ *
+ * The simple idea behind this test is to try out different combinations of
+ * query switches and ensure that queries are the same before serialization
+ * as they are after de-serialization.
+ *
+ * In the code below, "switch" refers to a query option -- "option" in a broad
+ * sense, not nsINavHistoryQueryOptions specifically (which is why we refer to
+ * them as switches, not options).  Both nsINavHistoryQuery and
+ * nsINavHistoryQueryOptions allow you to specify switches that affect query
+ * strings.  nsINavHistoryQuery instances have attributes hasBeginTime,
+ * hasEndTime, hasSearchTerms, and so on.  nsINavHistoryQueryOptions instances
+ * have attributes sortingMode, resultType, excludeItems, etc.
+ *
+ * Ideally we would like to test all 2^N subsets of switches, where N is the
+ * total number of switches; switches might interact in erroneous or other ways
+ * we do not expect.  However, since N is large (21 at this time), that's
+ * impractical for a single test in a suite.
+ *
+ * Instead we choose all possible subsets of a certain, smaller size.  In fact
+ * we begin by choosing CHOOSE_HOW_MANY_SWITCHES_LO and ramp up to
+ * CHOOSE_HOW_MANY_SWITCHES_HI.
+ *
+ * There are two more wrinkles.  First, for some switches we'd like to be able to
+ * test multiple values.  For example, it seems like a good idea to test both an
+ * empty string and a non-empty string for switch nsINavHistoryQuery.searchTerms.
+ * When switches have more than one value for a test run, we use the Cartesian
+ * product of their values to generate all possible combinations of values.
+ *
+ * Second, we need to also test serialization of multiple nsINavHistoryQuery
+ * objects at once.  To do this, we remember the previous NUM_MULTIPLE_QUERIES
+ * queries we tested individually and then serialize them together.  We do this
+ * each time we test an individual query.  Thus the set of queries we test
+ * together loses one query and gains another each time.
+ *
+ * To summarize, here's how this test works:
+ *
+ * - For n = CHOOSE_HOW_MANY_SWITCHES_LO to CHOOSE_HOW_MANY_SWITCHES_HI:
+ *   - From the total set of switches choose all possible subsets of size n.
+ *     For each of those subsets s:
+ *     - Collect the test runs of each switch in subset s and take their
+ *       Cartesian product.  For each sequence in the product:
+ *       - Create nsINavHistoryQuery and nsINavHistoryQueryOptions objects
+ *         with the chosen switches and test run values.
+ *       - Serialize the query.
+ *       - De-serialize and ensure that the de-serialized query objects equal
+ *         the originals.
+ *       - For each of the previous NUM_MULTIPLE_QUERIES
+ *         nsINavHistoryQueryOptions objects o we created:
+ *         - Serialize the previous NUM_MULTIPLE_QUERIES nsINavHistoryQuery
+ *           objects together with o.
+ *         - De-serialize and ensure that the de-serialized query objects
+ *           equal the originals.
+ */
+
+const CHOOSE_HOW_MANY_SWITCHES_LO = 1;
+const CHOOSE_HOW_MANY_SWITCHES_HI = 2;
+
+const NUM_MULTIPLE_QUERIES        = 2;
+
+// The switches are represented by objects below, in arrays querySwitches and
+// queryOptionSwitches.  Use them to set up test runs.
+//
+// Some switches have special properties (where noted), but all switches must
+// have the following properties:
+//
+//   matches: A function that takes two nsINavHistoryQuery objects (in the case
+//            of nsINavHistoryQuery switches) or two nsINavHistoryQueryOptions
+//            objects (for nsINavHistoryQueryOptions switches) and returns true
+//            if the values of the switch in the two objects are equal.  This is
+//            the foundation of how we determine if two queries are equal.
+//   runs:    An array of functions.  Each function takes an nsINavHistoryQuery
+//            object and an nsINavHistoryQueryOptions object.  The functions
+//            should set the attributes of one of the two objects as appropriate
+//            to their switches.  This is how switch values are set for each test
+//            run.
+//
+// The following properties are optional:
+//
+//   desc:    An informational string to print out during runs when the switch
+//            is chosen.  Hopefully helpful if the test fails.
+
+// nsINavHistoryQuery switches
+const querySwitches = [
+  // hasBeginTime
+  {
+    // flag and subswitches are used by the flagSwitchMatches function.  Several
+    // of the nsINavHistoryQuery switches (like this one) are really guard flags
+    // that indicate if other "subswitches" are enabled.
+    flag:        "hasBeginTime",
+    subswitches: ["beginTime", "beginTimeReference", "absoluteBeginTime"],
+    desc:        "nsINavHistoryQuery.hasBeginTime",
+    matches:     flagSwitchMatches,
+    runs:        [
+      function (aQuery, aQueryOptions) {
+        aQuery.beginTime = Date.now() * 1000;
+        aQuery.beginTimeReference = Ci.nsINavHistoryQuery.TIME_RELATIVE_EPOCH;
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.beginTime = Date.now() * 1000;
+        aQuery.beginTimeReference = Ci.nsINavHistoryQuery.TIME_RELATIVE_TODAY;
+      }
+    ]
+  },
+  // hasEndTime
+  {
+    flag:        "hasEndTime",
+    subswitches: ["endTime", "endTimeReference", "absoluteEndTime"],
+    desc:        "nsINavHistoryQuery.hasEndTime",
+    matches:     flagSwitchMatches,
+    runs:        [
+      function (aQuery, aQueryOptions) {
+        aQuery.endTime = Date.now() * 1000;
+        aQuery.endTimeReference = Ci.nsINavHistoryQuery.TIME_RELATIVE_EPOCH;
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.endTime = Date.now() * 1000;
+        aQuery.endTimeReference = Ci.nsINavHistoryQuery.TIME_RELATIVE_TODAY;
+      }
+    ]
+  },
+  // hasSearchTerms
+  {
+    flag:        "hasSearchTerms",
+    subswitches: ["searchTerms"],
+    desc:        "nsINavHistoryQuery.hasSearchTerms",
+    matches:     flagSwitchMatches,
+    runs:        [
+      function (aQuery, aQueryOptions) {
+        aQuery.searchTerms = "shrimp and white wine";
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.searchTerms = "";
+      }
+    ]
+  },
+  // hasDomain
+  {
+    flag:        "hasDomain",
+    subswitches: ["domain", "domainIsHost"],
+    desc:        "nsINavHistoryQuery.hasDomain",
+    matches:     flagSwitchMatches,
+    runs:        [
+      function (aQuery, aQueryOptions) {
+        aQuery.domain = "mozilla.com";
+        aQuery.domainIsHost = false;
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.domain = "www.mozilla.com";
+        aQuery.domainIsHost = true;
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.domain = "";
+      }
+    ]
+  },
+  // hasUri
+  {
+    flag:        "hasUri",
+    subswitches: ["uri"],
+    desc:        "nsINavHistoryQuery.hasUri",
+    matches:     flagSwitchMatches,
+    runs:        [
+      function (aQuery, aQueryOptions) {
+        aQuery.uri = uri("http://mozilla.com");
+      },
+    ]
+  },
+  // hasAnnotation
+  {
+    flag:        "hasAnnotation",
+    subswitches: ["annotation", "annotationIsNot"],
+    desc:        "nsINavHistoryQuery.hasAnnotation",
+    matches:     flagSwitchMatches,
+    runs:        [
+      function (aQuery, aQueryOptions) {
+        aQuery.annotation = "bookmarks/toolbarFolder";
+        aQuery.annotationIsNot = false;
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.annotation = "bookmarks/toolbarFolder";
+        aQuery.annotationIsNot = true;
+      }
+    ]
+  },
+  // minVisits
+  {
+    // property is used by function simplePropertyMatches.
+    property: "minVisits",
+    desc:     "nsINavHistoryQuery.minVisits",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQuery.minVisits = 0x7fffffff; // 2^31 - 1
+      }
+    ]
+  },
+  // maxVisits
+  {
+    property: "maxVisits",
+    desc:     "nsINavHistoryQuery.maxVisits",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQuery.maxVisits = 0x7fffffff; // 2^31 - 1
+      }
+    ]
+  },
+  // onlyBookmarked
+  {
+    property: "onlyBookmarked",
+    desc:     "nsINavHistoryQuery.onlyBookmarked",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQuery.onlyBookmarked = true;
+      }
+    ]
+  },
+  // getFolders
+  {
+    desc:    "nsINavHistoryQuery.getFolders",
+    matches: function (aQuery1, aQuery2) {
+      var q1Folders = aQuery1.getFolders();
+      var q2Folders = aQuery2.getFolders();
+      if (q1Folders.length !== q2Folders.length)
+        return false;
+      for (let i = 0; i < q1Folders.length; i++) {
+        if (q2Folders.indexOf(q1Folders[i]) < 0)
+          return false;
+      }
+      for (let i = 0; i < q2Folders.length; i++) {
+        if (q1Folders.indexOf(q2Folders[i]) < 0)
+          return false;
+      }
+      return true;
+    },
+    runs: [
+      function (aQuery, aQueryOptions) {
+        aQuery.setFolders([], 0);
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.setFolders([PlacesUtils.placesRootId], 1);
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.setFolders([PlacesUtils.placesRootId, PlacesUtils.tagsFolderId], 2);
+      }
+    ]
+  },
+  // tags
+  {
+    desc:    "nsINavHistoryQuery.getTags",
+    matches: function (aQuery1, aQuery2) {
+      if (aQuery1.tagsAreNot !== aQuery2.tagsAreNot)
+        return false;
+      var q1Tags = aQuery1.tags;
+      var q2Tags = aQuery2.tags;
+      if (q1Tags.length !== q2Tags.length)
+        return false;
+      for (let i = 0; i < q1Tags.length; i++) {
+        if (q2Tags.indexOf(q1Tags[i]) < 0)
+          return false;
+      }
+      for (let i = 0; i < q2Tags.length; i++) {
+        if (q1Tags.indexOf(q2Tags[i]) < 0)
+          return false;
+      }
+      return true;
+    },
+    runs: [
+      function (aQuery, aQueryOptions) {
+        aQuery.tags = [];
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.tags = [""];
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.tags = [
+          "foo",
+          "七難",
+          "",
+          "いっぱいおっぱい",
+          "Abracadabra",
+          "１２３",
+          "Here's a pretty long tag name with some = signs and 1 2 3s and spaces oh jeez will it work I hope so!",
+          "アスキーでございません",
+          "あいうえお",
+        ];
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.tags = [
+          "foo",
+          "七難",
+          "",
+          "いっぱいおっぱい",
+          "Abracadabra",
+          "１２３",
+          "Here's a pretty long tag name with some = signs and 1 2 3s and spaces oh jeez will it work I hope so!",
+          "アスキーでございません",
+          "あいうえお",
+        ];
+        aQuery.tagsAreNot =  true;
+      }
+    ]
+  },
+  // transitions
+  {
+    desc: "tests nsINavHistoryQuery.getTransitions",
+    matches: function (aQuery1, aQuery2) {
+      var q1Trans = aQuery1.getTransitions();
+      var q2Trans = aQuery2.getTransitions();
+      if (q1Trans.length !== q2Trans.length)
+        return false;
+      for (let i = 0; i < q1Trans.length; i++) {
+        if (q2Trans.indexOf(q1Trans[i]) < 0)
+          return false;
+      }
+      for (let i = 0; i < q2Trans.length; i++) {
+        if (q1Trans.indexOf(q2Trans[i]) < 0)
+          return false;
+      }
+      return true;
+    },
+    runs: [
+      function (aQuery, aQueryOptions) {
+        aQuery.setTransitions([], 0);
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.setTransitions([Ci.nsINavHistoryService.TRANSITION_DOWNLOAD],
+                              1);
+      },
+      function (aQuery, aQueryOptions) {
+        aQuery.setTransitions([Ci.nsINavHistoryService.TRANSITION_TYPED,
+                               Ci.nsINavHistoryService.TRANSITION_BOOKMARK], 2);
+      }
+    ]
+  },
+];
+
+// nsINavHistoryQueryOptions switches
+const queryOptionSwitches = [
+  // sortingMode
+  {
+    desc:    "nsINavHistoryQueryOptions.sortingMode",
+    matches: function (aOptions1, aOptions2) {
+      if (aOptions1.sortingMode === aOptions2.sortingMode) {
+        switch (aOptions1.sortingMode) {
+          case aOptions1.SORT_BY_ANNOTATION_ASCENDING:
+          case aOptions1.SORT_BY_ANNOTATION_DESCENDING:
+            return aOptions1.sortingAnnotation === aOptions2.sortingAnnotation;
+        }
+        return true;
+      }
+      return false;
+    },
+    runs: [
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.sortingMode = aQueryOptions.SORT_BY_DATE_ASCENDING;
+      },
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.sortingMode = aQueryOptions.SORT_BY_ANNOTATION_ASCENDING;
+        aQueryOptions.sortingAnnotation = "bookmarks/toolbarFolder";
+      }
+    ]
+  },
+  // resultType
+  {
+    // property is used by function simplePropertyMatches.
+    property: "resultType",
+    desc:     "nsINavHistoryQueryOptions.resultType",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.resultType = aQueryOptions.RESULTS_AS_URI;
+      },
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.resultType = aQueryOptions.RESULTS_AS_FULL_VISIT;
+      }
+    ]
+  },
+  // excludeItems
+  {
+    property: "excludeItems",
+    desc:     "nsINavHistoryQueryOptions.excludeItems",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.excludeItems = true;
+      }
+    ]
+  },
+  // excludeQueries
+  {
+    property: "excludeQueries",
+    desc:     "nsINavHistoryQueryOptions.excludeQueries",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.excludeQueries = true;
+      }
+    ]
+  },
+  // expandQueries
+  {
+    property: "expandQueries",
+    desc:     "nsINavHistoryQueryOptions.expandQueries",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.expandQueries = true;
+      }
+    ]
+  },
+  // includeHidden
+  {
+    property: "includeHidden",
+    desc:     "nsINavHistoryQueryOptions.includeHidden",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.includeHidden = true;
+      }
+    ]
+  },
+  // maxResults
+  {
+    property: "maxResults",
+    desc:     "nsINavHistoryQueryOptions.maxResults",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.maxResults = 0xffffffff; // 2^32 - 1
+      }
+    ]
+  },
+  // queryType
+  {
+    property: "queryType",
+    desc:     "nsINavHistoryQueryOptions.queryType",
+    matches:  simplePropertyMatches,
+    runs:     [
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.queryType = aQueryOptions.QUERY_TYPE_HISTORY;
+      },
+      function (aQuery, aQueryOptions) {
+        aQueryOptions.queryType = aQueryOptions.QUERY_TYPE_UNIFIED;
+      }
+    ]
+  },
+];
+
+/**
+ * Enumerates all the sequences of the cartesian product of the arrays contained
+ * in aSequences.  Examples:
+ *
+ *   cartProd([[1, 2, 3], ["a", "b"]], callback);
+ *   // callback is called 3 * 2 = 6 times with the following arrays:
+ *   // [1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]
+ *
+ *   cartProd([["a"], [1, 2, 3], ["X", "Y"]], callback);
+ *   // callback is called 1 * 3 * 2 = 6 times with the following arrays:
+ *   // ["a", 1, "X"], ["a", 1, "Y"], ["a", 2, "X"], ["a", 2, "Y"],
+ *   // ["a", 3, "X"], ["a", 3, "Y"]
+ *
+ *   cartProd([[1], [2], [3], [4]], callback);
+ *   // callback is called 1 * 1 * 1 * 1 = 1 time with the following array:
+ *   // [1, 2, 3, 4]
+ *
+ *   cartProd([], callback);
+ *   // callback is 0 times
+ *
+ *   cartProd([[1, 2, 3, 4]], callback);
+ *   // callback is called 4 times with the following arrays:
+ *   // [1], [2], [3], [4]
+ *
+ * @param  aSequences
+ *         an array that contains an arbitrary number of arrays
+ * @param  aCallback
+ *         a function that is passed each sequence of the product as it's
+ *         computed
+ * @return the total number of sequences in the product
+ */
+function cartProd(aSequences, aCallback)
+{
+  if (aSequences.length === 0)
+    return 0;
+
+  // For each sequence in aSequences, we maintain a pointer (an array index,
+  // really) to the element we're currently enumerating in that sequence
+  var seqEltPtrs = aSequences.map(i => 0);
+
+  var numProds = 0;
+  var done = false;
+  while (!done) {
+    numProds++;
+
+    // prod = sequence in product we're currently enumerating
+    let prod = [];
+    for (let i = 0; i < aSequences.length; i++) {
+      prod.push(aSequences[i][seqEltPtrs[i]]);
+    }
+    aCallback(prod);
+
+    // The next sequence in the product differs from the current one by just a
+    // single element.  Determine which element that is.  We advance the
+    // "rightmost" element pointer to the "right" by one.  If we move past the
+    // end of that pointer's sequence, reset the pointer to the first element
+    // in its sequence and then try the sequence to the "left", and so on.
+
+    // seqPtr = index of rightmost input sequence whose element pointer is not
+    // past the end of the sequence
+    let seqPtr = aSequences.length - 1;
+    while (!done) {
+      // Advance the rightmost element pointer.
+      seqEltPtrs[seqPtr]++;
+
+      // The rightmost element pointer is past the end of its sequence.
+      if (seqEltPtrs[seqPtr] >= aSequences[seqPtr].length) {
+        seqEltPtrs[seqPtr] = 0;
+        seqPtr--;
+
+        // All element pointers are past the ends of their sequences.
+        if (seqPtr < 0)
+          done = true;
+      }
+      else break;
+    }
+  }
+  return numProds;
+}
+
+/**
+ * Enumerates all the subsets in aSet of size aHowMany.  There are
+ * C(aSet.length, aHowMany) such subsets.  aCallback will be passed each subset
+ * as it is generated.  Note that aSet and the subsets enumerated are -- even
+ * though they're arrays -- not sequences; the ordering of their elements is not
+ * important.  Example:
+ *
+ *   choose([1, 2, 3, 4], 2, callback);
+ *   // callback is called C(4, 2) = 6 times with the following sets (arrays):
+ *   // [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]
+ *
+ * @param  aSet
+ *         an array from which to choose elements, aSet.length > 0
+ * @param  aHowMany
+ *         the number of elements to choose, > 0 and <= aSet.length
+ * @return the total number of sets chosen
+ */
+function choose(aSet, aHowMany, aCallback)
+{
+  // ptrs = indices of the elements in aSet we're currently choosing
+  var ptrs = [];
+  for (let i = 0; i < aHowMany; i++) {
+    ptrs.push(i);
+  }
+
+  var numFound = 0;
+  var done = false;
+  while (!done) {
+    numFound++;
+    aCallback(ptrs.map(p => aSet[p]));
+
+    // The next subset to be chosen differs from the current one by just a
+    // single element.  Determine which element that is.  Advance the "rightmost"
+    // pointer to the "right" by one.  If we move past the end of set, move the
+    // next non-adjacent rightmost pointer to the right by one, and reset all
+    // succeeding pointers so that they're adjacent to it.  When all pointers
+    // are clustered all the way to the right, we're done.
+
+    // Advance the rightmost pointer.
+    ptrs[ptrs.length - 1]++;
+
+    // The rightmost pointer has gone past the end of set.
+    if (ptrs[ptrs.length - 1] >= aSet.length) {
+      // Find the next rightmost pointer that is not adjacent to the current one.
+      let si = aSet.length - 2; // aSet index
+      let pi = ptrs.length - 2; // ptrs index
+      while (pi >= 0 && ptrs[pi] === si) {
+        pi--;
+        si--;
+      }
+
+      // All pointers are adjacent and clustered all the way to the right.
+      if (pi < 0)
+        done = true;
+      else {
+        // pi = index of rightmost pointer with a gap between it and its
+        // succeeding pointer.  Move it right and reset all succeeding pointers
+        // so that they're adjacent to it.
+        ptrs[pi]++;
+        for (let i = 0; i < ptrs.length - pi - 1; i++) {
+          ptrs[i + pi + 1] = ptrs[pi] + i + 1;
+        }
+      }
+    }
+  }
+  return numFound;
+}
+
+/**
+ * Convenience function for nsINavHistoryQuery switches that act as flags.  This
+ * is attached to switch objects.  See querySwitches array above.
+ *
+ * @param  aQuery1
+ *         an nsINavHistoryQuery object
+ * @param  aQuery2
+ *         another nsINavHistoryQuery object
+ * @return true if this switch is the same in both aQuery1 and aQuery2
+ */
+function flagSwitchMatches(aQuery1, aQuery2)
+{
+  if (aQuery1[this.flag] && aQuery2[this.flag]) {
+    for (let p in this.subswitches) {
+      if (p in aQuery1 && p in aQuery2) {
+        if (aQuery1[p] instanceof Ci.nsIURI) {
+          if (!aQuery1[p].equals(aQuery2[p]))
+            return false;
+        }
+        else if (aQuery1[p] !== aQuery2[p])
+          return false;
+      }
+    }
+  }
+  else if (aQuery1[this.flag] || aQuery2[this.flag])
+    return false;
+
+  return true;
+}
+
+/**
+ * Tests if aObj1 and aObj2 are equal.  This function is general and may be used
+ * for either nsINavHistoryQuery or nsINavHistoryQueryOptions objects.  aSwitches
+ * determines which set of switches is used for comparison.  Pass in either
+ * querySwitches or queryOptionSwitches.
+ *
+ * @param  aSwitches
+ *         determines which set of switches applies to aObj1 and aObj2, either
+ *         querySwitches or queryOptionSwitches
+ * @param  aObj1
+ *         an nsINavHistoryQuery or nsINavHistoryQueryOptions object
+ * @param  aObj2
+ *         another nsINavHistoryQuery or nsINavHistoryQueryOptions object
+ * @return true if aObj1 and aObj2 are equal
+ */
+function queryObjsEqual(aSwitches, aObj1, aObj2)
+{
+  for (let i = 0; i < aSwitches.length; i++) {
+    if (!aSwitches[i].matches(aObj1, aObj2))
+      return false;
+  }
+  return true;
+}
+
+/**
+ * This drives the test runs.  See the comment at the top of this file.
+ *
+ * @param aHowManyLo
+ *        the size of the switch subsets to start with
+ * @param aHowManyHi
+ *        the size of the switch subsets to end with (inclusive)
+ */
+function runQuerySequences(aHowManyLo, aHowManyHi)
+{
+  var allSwitches = querySwitches.concat(queryOptionSwitches);
+  var prevQueries = [];
+  var prevOpts = [];
+
+  // Choose aHowManyLo switches up to aHowManyHi switches.
+  for (let howMany = aHowManyLo; howMany <= aHowManyHi; howMany++) {
+    let numIters = 0;
+    print("CHOOSING " + howMany + " SWITCHES");
+
+    // Choose all subsets of size howMany from allSwitches.
+    choose(allSwitches, howMany, function (chosenSwitches) {
+      print(numIters);
+      numIters++;
+
+      // Collect the runs.
+      // runs = [ [runs from switch 1], ..., [runs from switch howMany] ]
+      var runs = chosenSwitches.map(function (s) {
+        if (s.desc)
+          print("  " + s.desc);
+        return s.runs;
+      });
+
+      // cartProd(runs) => [
+      //   [switch 1 run 1, switch 2 run 1, ..., switch howMany run 1 ],
+      //   ...,
+      //   [switch 1 run 1, switch 2 run 1, ..., switch howMany run N ],
+      //   ..., ...,
+      //   [switch 1 run N, switch 2 run N, ..., switch howMany run 1 ],
+      //   ...,
+      //   [switch 1 run N, switch 2 run N, ..., switch howMany run N ],
+      // ]
+      cartProd(runs, function (runSet) {
+        // Create a new query, apply the switches in runSet, and test it.
+        var query = PlacesUtils.history.getNewQuery();
+        var opts = PlacesUtils.history.getNewQueryOptions();
+        for (let i = 0; i < runSet.length; i++) {
+          runSet[i](query, opts);
+        }
+        serializeDeserialize([query], opts);
+
+        // Test the previous NUM_MULTIPLE_QUERIES queries together.
+        prevQueries.push(query);
+        prevOpts.push(opts);
+        if (prevQueries.length >= NUM_MULTIPLE_QUERIES) {
+          // We can serialize multiple nsINavHistoryQuery objects together but
+          // only one nsINavHistoryQueryOptions object with them.  So, test each
+          // of the previous NUM_MULTIPLE_QUERIES nsINavHistoryQueryOptions.
+          for (let i = 0; i < prevOpts.length; i++) {
+            serializeDeserialize(prevQueries, prevOpts[i]);
+          }
+          prevQueries.shift();
+          prevOpts.shift();
+        }
+      });
+    });
+  }
+  print("\n");
+}
+
+/**
+ * Serializes the nsINavHistoryQuery objects in aQueryArr and the
+ * nsINavHistoryQueryOptions object aQueryOptions, de-serializes the
+ * serialization, and ensures (using do_check_* functions) that the
+ * de-serialized objects equal the originals.
+ *
+ * @param aQueryArr
+ *        an array containing nsINavHistoryQuery objects
+ * @param aQueryOptions
+ *        an nsINavHistoryQueryOptions object
+ */
+function serializeDeserialize(aQueryArr, aQueryOptions)
+{
+  var queryStr = PlacesUtils.history.queriesToQueryString(aQueryArr,
+                                                        aQueryArr.length,
+                                                        aQueryOptions);
+  print("  " + queryStr);
+  var queryArr2 = {};
+  var opts2 = {};
+  PlacesUtils.history.queryStringToQueries(queryStr, queryArr2, {}, opts2);
+  queryArr2 = queryArr2.value;
+  opts2 = opts2.value;
+
+  // The two sets of queries cannot be the same if their lengths differ.
+  do_check_eq(aQueryArr.length, queryArr2.length);
+
+  // Although the query serialization code as it is written now practically
+  // ensures that queries appear in the query string in the same order they
+  // appear in both the array to be serialized and the array resulting from
+  // de-serialization, the interface does not guarantee any ordering.  So, for
+  // each query in aQueryArr, find its equivalent in queryArr2 and delete it
+  // from queryArr2.  If queryArr2 is empty after looping through aQueryArr,
+  // the two sets of queries are equal.
+  for (let i = 0; i < aQueryArr.length; i++) {
+    let j = 0;
+    for (; j < queryArr2.length; j++) {
+      if (queryObjsEqual(querySwitches, aQueryArr[i], queryArr2[j]))
+        break;
+    }
+    if (j < queryArr2.length)
+      queryArr2.splice(j, 1);
+  }
+  do_check_eq(queryArr2.length, 0);
+
+  // Finally check the query options objects.
+  do_check_true(queryObjsEqual(queryOptionSwitches, aQueryOptions, opts2));
+}
+
+/**
+ * Convenience function for switches that have simple values.  This is attached
+ * to switch objects.  See querySwitches and queryOptionSwitches arrays above.
+ *
+ * @param  aObj1
+ *         an nsINavHistoryQuery or nsINavHistoryQueryOptions object
+ * @param  aObj2
+ *         another nsINavHistoryQuery or nsINavHistoryQueryOptions object
+ * @return true if this switch is the same in both aObj1 and aObj2
+ */
+function simplePropertyMatches(aObj1, aObj2)
+{
+  return aObj1[this.property] === aObj2[this.property];
+}
+
+function run_test()
+{
+  runQuerySequences(CHOOSE_HOW_MANY_SWITCHES_LO, CHOOSE_HOW_MANY_SWITCHES_HI);
+}
diff --git a/toolkit/components/places/tests/queries/test_redirects.js b/toolkit/components/places/tests/queries/test_redirects.js
new file mode 100644
index 000000000..1be5a626f
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_redirects.js
@@ -0,0 +1,311 @@
+/* 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/. */
+
+// Array of visits we will add to the database, will be populated later
+// in the test.
+var visits = [];
+
+/**
+ * Takes a sequence of query options, and compare query results obtained through
+ * them with a custom filtered array of visits, based on the values we are
+ * expecting from the query.
+ *
+ * @param  aSequence
+ *         an array that contains query options in the form:
+ *         [includeHidden, maxResults, sortingMode]
+ */
+function check_results_callback(aSequence) {
+  // Sanity check: we should receive 3 parameters.
+  do_check_eq(aSequence.length, 3);
+  let includeHidden = aSequence[0];
+  let maxResults = aSequence[1];
+  let sortingMode = aSequence[2];
+  print("\nTESTING: includeHidden(" + includeHidden + ")," +
+                  " maxResults("    + maxResults    + ")," +
+                  " sortingMode("   + sortingMode   + ").");
+
+  function isHidden(aVisit) {
+    return aVisit.transType == Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK ||
+           aVisit.isRedirect;
+  }
+
+  // Build expectedData array.
+  let expectedData = visits.filter(function (aVisit, aIndex, aArray) {
+    // Embed visits never appear in results.
+    if (aVisit.transType == Ci.nsINavHistoryService.TRANSITION_EMBED)
+      return false;
+
+    if (!includeHidden && isHidden(aVisit)) {
+      // If the page has any non-hidden visit, then it's visible.
+      if (visits.filter(function (refVisit) {
+        return refVisit.uri == aVisit.uri && !isHidden(refVisit);
+          }).length == 0)
+        return false;
+    }
+
+    return true;
+  });
+
+  // Remove duplicates, since queries are RESULTS_AS_URI (unique pages).
+  let seen = [];
+  expectedData = expectedData.filter(function (aData) {
+    if (seen.includes(aData.uri)) {
+      return false;
+    }
+    seen.push(aData.uri);
+    return true;
+  });
+
+  // Sort expectedData.
+  function getFirstIndexFor(aEntry) {
+    for (let i = 0; i < visits.length; i++) {
+      if (visits[i].uri == aEntry.uri)
+        return i;
+    }
+    return undefined;
+  }
+  function comparator(a, b) {
+    if (sortingMode == Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING) {
+      return b.lastVisit - a.lastVisit;
+    }
+    if (sortingMode == Ci.nsINavHistoryQueryOptions.SORT_BY_VISITCOUNT_DESCENDING) {
+      return b.visitCount - a.visitCount;
+    }
+    return getFirstIndexFor(a) - getFirstIndexFor(b);
+  }
+  expectedData.sort(comparator);
+
+  // Crop results to maxResults if it's defined.
+  if (maxResults) {
+    expectedData = expectedData.slice(0, maxResults);
+  }
+
+  // Create a new query with required options.
+  let query = PlacesUtils.history.getNewQuery();
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.includeHidden = includeHidden;
+  options.sortingMode = sortingMode;
+  if (maxResults)
+    options.maxResults = maxResults;
+
+  // Compare resultset with expectedData.
+  let result = PlacesUtils.history.executeQuery(query, options);
+  let root = result.root;
+  root.containerOpen = true;
+  compareArrayToResult(expectedData, root);
+  root.containerOpen = false;
+}
+
+/**
+ * Enumerates all the sequences of the cartesian product of the arrays contained
+ * in aSequences.  Examples:
+ *
+ *   cartProd([[1, 2, 3], ["a", "b"]], callback);
+ *   // callback is called 3 * 2 = 6 times with the following arrays:
+ *   // [1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]
+ *
+ *   cartProd([["a"], [1, 2, 3], ["X", "Y"]], callback);
+ *   // callback is called 1 * 3 * 2 = 6 times with the following arrays:
+ *   // ["a", 1, "X"], ["a", 1, "Y"], ["a", 2, "X"], ["a", 2, "Y"],
+ *   // ["a", 3, "X"], ["a", 3, "Y"]
+ *
+ *   cartProd([[1], [2], [3], [4]], callback);
+ *   // callback is called 1 * 1 * 1 * 1 = 1 time with the following array:
+ *   // [1, 2, 3, 4]
+ *
+ *   cartProd([], callback);
+ *   // callback is 0 times
+ *
+ *   cartProd([[1, 2, 3, 4]], callback);
+ *   // callback is called 4 times with the following arrays:
+ *   // [1], [2], [3], [4]
+ *
+ * @param  aSequences
+ *         an array that contains an arbitrary number of arrays
+ * @param  aCallback
+ *         a function that is passed each sequence of the product as it's
+ *         computed
+ * @return the total number of sequences in the product
+ */
+function cartProd(aSequences, aCallback)
+{
+  if (aSequences.length === 0)
+    return 0;
+
+  // For each sequence in aSequences, we maintain a pointer (an array index,
+  // really) to the element we're currently enumerating in that sequence
+  let seqEltPtrs = aSequences.map(i => 0);
+
+  let numProds = 0;
+  let done = false;
+  while (!done) {
+    numProds++;
+
+    // prod = sequence in product we're currently enumerating
+    let prod = [];
+    for (let i = 0; i < aSequences.length; i++) {
+      prod.push(aSequences[i][seqEltPtrs[i]]);
+    }
+    aCallback(prod);
+
+    // The next sequence in the product differs from the current one by just a
+    // single element.  Determine which element that is.  We advance the
+    // "rightmost" element pointer to the "right" by one.  If we move past the
+    // end of that pointer's sequence, reset the pointer to the first element
+    // in its sequence and then try the sequence to the "left", and so on.
+
+    // seqPtr = index of rightmost input sequence whose element pointer is not
+    // past the end of the sequence
+    let seqPtr = aSequences.length - 1;
+    while (!done) {
+      // Advance the rightmost element pointer.
+      seqEltPtrs[seqPtr]++;
+
+      // The rightmost element pointer is past the end of its sequence.
+      if (seqEltPtrs[seqPtr] >= aSequences[seqPtr].length) {
+        seqEltPtrs[seqPtr] = 0;
+        seqPtr--;
+
+        // All element pointers are past the ends of their sequences.
+        if (seqPtr < 0)
+          done = true;
+      }
+      else break;
+    }
+  }
+  return numProds;
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+/**
+ * Populate the visits array and add visits to the database.
+ * We will generate visit-chains like:
+ *   visit -> redirect_temp -> redirect_perm
+ */
+add_task(function* test_add_visits_to_database()
+{
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  // We don't really bother on this, but we need a time to add visits.
+  let timeInMicroseconds = Date.now() * 1000;
+  let visitCount = 1;
+
+  // Array of all possible transition types we could be redirected from.
+  let t = [
+    Ci.nsINavHistoryService.TRANSITION_LINK,
+    Ci.nsINavHistoryService.TRANSITION_TYPED,
+    Ci.nsINavHistoryService.TRANSITION_BOOKMARK,
+    // Embed visits are not added to the database and we don't want redirects
+    // to them, thus just avoid addition.
+    // Ci.nsINavHistoryService.TRANSITION_EMBED,
+    Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK,
+    // Would make hard sorting by visit date because last_visit_date is actually
+    // calculated excluding download transitions, but the query includes
+    // downloads.
+    // TODO: Bug 488966 could fix this behavior.
+    //Ci.nsINavHistoryService.TRANSITION_DOWNLOAD,
+  ];
+
+  function newTimeInMicroseconds() {
+    timeInMicroseconds = timeInMicroseconds - 1000;
+    return timeInMicroseconds;
+  }
+
+  // we add a visit for each of the above transition types.
+  t.forEach(transition => visits.push(
+    { isVisit: true,
+      transType: transition,
+      uri: "http://" + transition + ".example.com/",
+      title: transition + "-example",
+      isRedirect: true,
+      lastVisit: newTimeInMicroseconds(),
+      visitCount: (transition == Ci.nsINavHistoryService.TRANSITION_EMBED ||
+                   transition == Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK) ? 0 : visitCount++,
+      isInQuery: true }));
+
+  // Add a REDIRECT_TEMPORARY layer of visits for each of the above visits.
+  t.forEach(transition => visits.push(
+    { isVisit: true,
+      transType: Ci.nsINavHistoryService.TRANSITION_REDIRECT_TEMPORARY,
+      uri: "http://" + transition + ".redirect.temp.example.com/",
+      title: transition + "-redirect-temp-example",
+      lastVisit: newTimeInMicroseconds(),
+      isRedirect: true,
+      referrer: "http://" + transition + ".example.com/",
+      visitCount: visitCount++,
+      isInQuery: true }));
+
+  // Add a REDIRECT_PERMANENT layer of visits for each of the above redirects.
+  t.forEach(transition => visits.push(
+    { isVisit: true,
+      transType: Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT,
+      uri: "http://" + transition + ".redirect.perm.example.com/",
+      title: transition + "-redirect-perm-example",
+      lastVisit: newTimeInMicroseconds(),
+      isRedirect: true,
+      referrer: "http://" + transition + ".redirect.temp.example.com/",
+      visitCount: visitCount++,
+      isInQuery: true }));
+
+  // Add a REDIRECT_PERMANENT layer of visits that loop to the first visit.
+  // These entries should not change visitCount or lastVisit, otherwise
+  // guessing an order would be a nightmare.
+  function getLastValue(aURI, aProperty) {
+    for (let i = 0; i < visits.length; i++) {
+      if (visits[i].uri == aURI) {
+        return visits[i][aProperty];
+      }
+    }
+    do_throw("Unknown uri.");
+    return null;
+  }
+  t.forEach(transition => visits.push(
+    { isVisit: true,
+      transType: Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT,
+      uri: "http://" + transition + ".example.com/",
+      title: getLastValue("http://" + transition + ".example.com/", "title"),
+      lastVisit: getLastValue("http://" + transition + ".example.com/", "lastVisit"),
+      isRedirect: true,
+      referrer: "http://" + transition + ".redirect.perm.example.com/",
+      visitCount: getLastValue("http://" + transition + ".example.com/", "visitCount"),
+      isInQuery: true }));
+
+  // Add an unvisited bookmark in the database, it should never appear.
+  visits.push({ isBookmark: true,
+    uri: "http://unvisited.bookmark.com/",
+    parentGuid: PlacesUtils.bookmarks.menuGuid,
+    index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+    title: "Unvisited Bookmark",
+    isInQuery: false });
+
+  // Put visits in the database.
+  yield task_populateDB(visits);
+});
+
+add_task(function* test_redirects()
+{
+  // Frecency and hidden are updated asynchronously, wait for them.
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  // This array will be used by cartProd to generate a matrix of all possible
+  // combinations.
+  let includeHidden_options = [true, false];
+  let maxResults_options = [5, 10, 20, null];
+  // These sortingMode are choosen to toggle using special queries for history
+  // menu and most visited smart bookmark.
+  let sorting_options = [Ci.nsINavHistoryQueryOptions.SORT_BY_NONE,
+                         Ci.nsINavHistoryQueryOptions.SORT_BY_VISITCOUNT_DESCENDING,
+                         Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING];
+  // Will execute check_results_callback() for each generated combination.
+  cartProd([includeHidden_options, maxResults_options, sorting_options],
+           check_results_callback);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  yield PlacesTestUtils.clearHistory();
+});
diff --git a/toolkit/components/places/tests/queries/test_results-as-tag-contents-query.js b/toolkit/components/places/tests/queries/test_results-as-tag-contents-query.js
new file mode 100644
index 000000000..f1cbfd4d8
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_results-as-tag-contents-query.js
@@ -0,0 +1,127 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var testData = [
+  { isInQuery: true,
+    isDetails: true,
+    title: "bmoz",
+    uri: "http://foo.com/",
+    isBookmark: true,
+    isTag: true,
+    tagArray: ["bugzilla"] },
+
+  { isInQuery: true,
+    isDetails: true,
+    title: "C Moz",
+    uri: "http://foo.com/changeme1.html",
+    isBookmark: true,
+    isTag: true,
+    tagArray: ["moz", "bugzilla"] },
+
+  { isInQuery: false,
+    isDetails: true,
+    title: "amo",
+    uri: "http://foo2.com/",
+    isBookmark: true,
+    isTag: true,
+    tagArray: ["moz"] },
+
+  { isInQuery: false,
+    isDetails: true,
+    title: "amo",
+    uri: "http://foo.com/changeme2.html",
+    isBookmark: true },
+];
+
+function getIdForTag(aTagName) {
+  var id = -1;
+  var query = PlacesUtils.history.getNewQuery();
+  query.setFolders([PlacesUtils.tagsFolderId], 1);
+  var options = PlacesUtils.history.getNewQueryOptions();
+  var root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  var cc = root.childCount;
+  do_check_eq(root.childCount, 2);
+  for (let i = 0; i < cc; i++) {
+    let node = root.getChild(i);
+    if (node.title == aTagName) {
+      id = node.itemId;
+      break;
+    }
+  }
+  root.containerOpen = false;
+  return id;
+}
+
+ /**
+  * This test will test Queries that use relative search terms and URI options
+  */
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_results_as_tag_contents_query()
+{
+  yield task_populateDB(testData);
+
+  // Get tag id.
+  let tagId = getIdForTag("bugzilla");
+  do_check_true(tagId > 0);
+
+  var options = PlacesUtils.history.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_TAG_CONTENTS;
+  var query = PlacesUtils.history.getNewQuery();
+  query.setFolders([tagId], 1);
+
+  var root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  displayResultSet(root);
+  // Cannot use compare array to results, since results ordering is hardcoded
+  // and depending on lastModified (that could have VM timers issues).
+  testData.forEach(function(aEntry) {
+    if (aEntry.isInResult)
+      do_check_true(isInResult({uri: "http://foo.com/added.html"}, root));
+  });
+
+  // If that passes, check liveupdate
+  // Add to the query set
+  var change1 = { isVisit: true,
+                  isDetails: true,
+                  uri: "http://foo.com/added.html",
+                  title: "mozadded",
+                  isBookmark: true,
+                  isTag: true,
+                  tagArray: ["moz", "bugzilla"] };
+  do_print("Adding item to query");
+  yield task_populateDB([change1]);
+  do_print("These results should have been LIVE UPDATED with the new addition");
+  displayResultSet(root);
+  do_check_true(isInResult(change1, root));
+
+  // Add one by adding a tag, remove one by removing search term.
+  do_print("Updating items");
+  var change2 = [{ isDetails: true,
+                   uri: "http://foo3.com/",
+                   title: "foo"},
+                 { isDetails: true,
+                   uri: "http://foo.com/changeme2.html",
+                   title: "zydeco",
+                   isBookmark:true,
+                   isTag: true,
+                   tagArray: ["bugzilla", "moz"] }];
+  yield task_populateDB(change2);
+  do_check_false(isInResult({uri: "http://fooz.com/"}, root));
+  do_check_true(isInResult({uri: "http://foo.com/changeme2.html"}, root));
+
+  // Test removing a tag updates us.
+  do_print("Deleting item");
+  PlacesUtils.tagging.untagURI(uri("http://foo.com/changeme2.html"), ["bugzilla"]);
+  do_check_false(isInResult({uri: "http://foo.com/changeme2.html"}, root));
+
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_results-as-visit.js b/toolkit/components/places/tests/queries/test_results-as-visit.js
new file mode 100644
index 000000000..d0f270bd2
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_results-as-visit.js
@@ -0,0 +1,119 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+var testData = [];
+var timeInMicroseconds = PlacesUtils.toPRTime(Date.now() - 10000);
+
+function newTimeInMicroseconds() {
+  timeInMicroseconds = timeInMicroseconds + 1000;
+  return timeInMicroseconds;
+}
+
+function createTestData() {
+  function generateVisits(aPage) {
+    for (var i = 0; i < aPage.visitCount; i++) {
+      testData.push({ isInQuery: aPage.inQuery,
+                      isVisit: true,
+                      title: aPage.title,
+                      uri: aPage.uri,
+                      lastVisit: newTimeInMicroseconds(),
+                      isTag: aPage.tags && aPage.tags.length > 0,
+                      tagArray: aPage.tags });
+    }
+  }
+
+  var pages = [
+    { uri: "http://foo.com/", title: "amo", tags: ["moz"], visitCount: 3, inQuery: true },
+    { uri: "http://moilla.com/", title: "bMoz", tags: ["bugzilla"], visitCount: 5, inQuery: true },
+    { uri: "http://foo.mail.com/changeme1.html", title: "c Moz", visitCount: 7, inQuery: true },
+    { uri: "http://foo.mail.com/changeme2.html", tags: ["moz"], title: "", visitCount: 1, inQuery: false },
+    { uri: "http://foo.mail.com/changeme3.html", title: "zydeco", visitCount: 5, inQuery: false },
+  ];
+  pages.forEach(generateVisits);
+}
+
+/**
+ * This test will test Queries that use relative search terms and URI options
+ */
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_results_as_visit()
+{
+   createTestData();
+   yield task_populateDB(testData);
+   var query = PlacesUtils.history.getNewQuery();
+   query.searchTerms = "moz";
+   query.minVisits = 2;
+
+   // Options
+   var options = PlacesUtils.history.getNewQueryOptions();
+   options.sortingMode = options.SORT_BY_VISITCOUNT_ASCENDING;
+   options.resultType = options.RESULTS_AS_VISIT;
+
+   // Results
+   var result = PlacesUtils.history.executeQuery(query, options);
+   var root = result.root;
+   root.containerOpen = true;
+
+   do_print("Number of items in result set: " + root.childCount);
+   for (let i=0; i < root.childCount; ++i) {
+     do_print("result: " + root.getChild(i).uri + " Title: " + root.getChild(i).title);
+   }
+
+   // Check our inital result set
+   compareArrayToResult(testData, root);
+
+   // If that passes, check liveupdate
+   // Add to the query set
+   do_print("Adding item to query")
+   var tmp = [];
+   for (let i=0; i < 2; i++) {
+     tmp.push({ isVisit: true,
+                uri: "http://foo.com/added.html",
+                title: "ab moz" });
+   }
+   yield task_populateDB(tmp);
+   for (let i=0; i < 2; i++)
+     do_check_eq(root.getChild(i).title, "ab moz");
+
+   // Update an existing URI
+   do_print("Updating Item");
+   var change2 = [{ isVisit: true,
+                    title: "moz",
+                    uri: "http://foo.mail.com/changeme2.html" }];
+   yield task_populateDB(change2);
+   do_check_true(isInResult(change2, root));
+
+   // Update some visits - add one and take one out of query set, and simply
+   // change one so that it still applies to the query.
+   do_print("Updating More Items");
+   var change3 = [{ isVisit: true,
+                    lastVisit: newTimeInMicroseconds(),
+                    uri: "http://foo.mail.com/changeme1.html",
+                    title: "foo"},
+                  { isVisit: true,
+                    lastVisit: newTimeInMicroseconds(),
+                    uri: "http://foo.mail.com/changeme3.html",
+                    title: "moz",
+                    isTag: true,
+                    tagArray: ["foo", "moz"] }];
+   yield task_populateDB(change3);
+   do_check_false(isInResult({uri: "http://foo.mail.com/changeme1.html"}, root));
+   do_check_true(isInResult({uri: "http://foo.mail.com/changeme3.html"}, root));
+
+   // And now, delete one
+   do_print("Delete item outside of batch");
+   var change4 = [{ isVisit: true,
+                    lastVisit: newTimeInMicroseconds(),
+                    uri: "http://moilla.com/",
+                    title: "mo,z" }];
+   yield task_populateDB(change4);
+   do_check_false(isInResult(change4, root));
+
+   root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_searchTerms_includeHidden.js b/toolkit/components/places/tests/queries/test_searchTerms_includeHidden.js
new file mode 100644
index 000000000..038367c0b
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_searchTerms_includeHidden.js
@@ -0,0 +1,84 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Tests the interaction of includeHidden and searchTerms search options.
+
+var timeInMicroseconds = Date.now() * 1000;
+
+const VISITS = [
+  { isVisit: true,
+    transType: TRANSITION_TYPED,
+    uri: "http://redirect.example.com/",
+    title: "example",
+    isRedirect: true,
+    lastVisit: timeInMicroseconds--
+  },
+  { isVisit: true,
+    transType: TRANSITION_TYPED,
+    uri: "http://target.example.com/",
+    title: "example",
+    lastVisit: timeInMicroseconds--
+  }
+];
+
+const HIDDEN_VISITS = [
+  { isVisit: true,
+    transType: TRANSITION_FRAMED_LINK,
+    uri: "http://hidden.example.com/",
+    title: "red",
+    lastVisit: timeInMicroseconds--
+  },
+];
+
+const TEST_DATA = [
+  { searchTerms: "example",
+    includeHidden: true,
+    expectedResults: 2
+  },
+  { searchTerms: "example",
+    includeHidden: false,
+    expectedResults: 1
+  },
+  { searchTerms: "red",
+    includeHidden: true,
+    expectedResults: 1
+  }
+];
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_initalize()
+{
+  yield task_populateDB(VISITS);
+});
+
+add_task(function* test_searchTerms_includeHidden()
+{
+  for (let data of TEST_DATA) {
+    let query = PlacesUtils.history.getNewQuery();
+    query.searchTerms = data.searchTerms;
+    let options = PlacesUtils.history.getNewQueryOptions();
+    options.includeHidden = data.includeHidden;
+
+    let root = PlacesUtils.history.executeQuery(query, options).root;
+    root.containerOpen = true;
+
+    let cc = root.childCount;
+    // Live update with hidden visits.
+    yield task_populateDB(HIDDEN_VISITS);
+    let cc_update = root.childCount;
+
+    root.containerOpen = false;
+
+    do_check_eq(cc, data.expectedResults);
+    do_check_eq(cc_update, data.expectedResults + (data.includeHidden ? 1 : 0));
+
+    PlacesUtils.bhistory.removePage(uri("http://hidden.example.com/"));
+  }
+});
diff --git a/toolkit/components/places/tests/queries/test_searchterms-bookmarklets.js b/toolkit/components/places/tests/queries/test_searchterms-bookmarklets.js
new file mode 100644
index 000000000..7bd91f057
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_searchterms-bookmarklets.js
@@ -0,0 +1,70 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Check that bookmarklets are returned by searches with searchTerms.
+
+var testData = [
+  { isInQuery: true
+  , isBookmark: true
+  , title: "bookmark 1"
+  , uri: "http://mozilla.org/script/"
+  },
+
+  { isInQuery: true
+  , isBookmark: true
+  , title: "bookmark 2"
+  , uri: "javascript:alert('moz');"
+  }
+];
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_initalize()
+{
+  yield task_populateDB(testData);
+});
+
+add_test(function test_search_by_title()
+{
+  let query = PlacesUtils.history.getNewQuery();
+  query.searchTerms = "bookmark";
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  compareArrayToResult(testData, root);
+  root.containerOpen = false;
+
+  run_next_test();
+});
+
+add_test(function test_search_by_schemeToken()
+{
+  let query = PlacesUtils.history.getNewQuery();
+  query.searchTerms = "script";
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  compareArrayToResult(testData, root);
+  root.containerOpen = false;
+
+  run_next_test();
+});
+
+add_test(function test_search_by_uriAndTitle()
+{
+  let query = PlacesUtils.history.getNewQuery();
+  query.searchTerms = "moz";
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  compareArrayToResult(testData, root);
+  root.containerOpen = false;
+
+  run_next_test();
+});
diff --git a/toolkit/components/places/tests/queries/test_searchterms-domain.js b/toolkit/components/places/tests/queries/test_searchterms-domain.js
new file mode 100644
index 000000000..4f42e7000
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_searchterms-domain.js
@@ -0,0 +1,125 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+ // The test data for our database, note that the ordering of the results that
+ // will be returned by the query (the isInQuery: true objects) is IMPORTANT.
+ // see compareArrayToResult in head_queries.js for more info.
+ var testData = [
+   // Test ftp protocol - vary the title length, embed search term
+   {isInQuery: true, isVisit: true, isDetails: true,
+    uri: "ftp://foo.com/ftp", lastVisit: lastweek,
+    title: "hugelongconfmozlagurationofwordswithasearchtermsinit whoo-hoo"},
+
+   // Test flat domain with annotation, search term in sentence
+   {isInQuery: true, isVisit: true, isDetails: true, isPageAnnotation: true,
+    uri: "http://foo.com/", annoName: "moz/test", annoVal: "val",
+    lastVisit: lastweek, title: "you know, moz is cool"},
+
+   // Test subdomain included with isRedirect=true, different transtype
+   {isInQuery: true, isVisit: true, isDetails: true, title: "amozzie",
+    isRedirect: true, uri: "http://mail.foo.com/redirect", lastVisit: old,
+    referrer: "http://myreferrer.com", transType: PlacesUtils.history.TRANSITION_LINK},
+
+   // Test subdomain inclued, search term at end
+   {isInQuery: true, isVisit: true, isDetails: true,
+    uri: "http://mail.foo.com/yiihah", title: "blahmoz", lastVisit: daybefore},
+
+   // Test www. style URI is included, with a tag
+   {isInQuery: true, isVisit: true, isDetails: true, isTag: true,
+    uri: "http://www.foo.com/yiihah", tagArray: ["moz"],
+    lastVisit: yesterday, title: "foo"},
+
+   // Test https protocol
+   {isInQuery: true, isVisit: true, isDetails: true, title: "moz",
+    uri: "https://foo.com/", lastVisit: today},
+
+   // Begin the invalid queries: wrong search term
+   {isInQuery: false, isVisit:true, isDetails: true, title: "m o z",
+    uri: "http://foo.com/tooearly.php", lastVisit: today},
+
+   // Test bad URI
+   {isInQuery: false, isVisit:true, isDetails: true, title: "moz",
+    uri: "http://sffoo.com/justwrong.htm", lastVisit: yesterday},
+
+   // Test what we do with escaping in titles
+   {isInQuery: false, isVisit:true, isDetails: true, title: "m%0o%0z",
+    uri: "http://foo.com/changeme1.htm", lastVisit: yesterday},
+
+   // Test another invalid title - for updating later
+   {isInQuery: false, isVisit:true, isDetails: true, title: "m,oz",
+    uri: "http://foo.com/changeme2.htm", lastVisit: yesterday}];
+
+/**
+ * This test will test Queries that use relative search terms and domain options
+ */
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_searchterms_domain()
+{
+  yield task_populateDB(testData);
+  var query = PlacesUtils.history.getNewQuery();
+  query.searchTerms = "moz";
+  query.domain = "foo.com";
+  query.domainIsHost = false;
+
+  // Options
+  var options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_DATE_ASCENDING;
+  options.resultType = options.RESULTS_AS_URI;
+
+  // Results
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  do_print("Number of items in result set: " + root.childCount);
+  for (var i=0; i < root.childCount; ++i) {
+    do_print("result: " + root.getChild(i).uri + " Title: " + root.getChild(i).title);
+  }
+
+  // Check our inital result set
+  compareArrayToResult(testData, root);
+
+  // If that passes, check liveupdate
+  // Add to the query set
+  do_print("Adding item to query");
+  var change1 = [{isVisit: true, isDetails: true, uri: "http://foo.com/added.htm",
+                  title: "moz", transType: PlacesUtils.history.TRANSITION_LINK}];
+  yield task_populateDB(change1);
+  do_check_true(isInResult(change1, root));
+
+  // Update an existing URI
+  do_print("Updating Item");
+  var change2 = [{isDetails: true, uri: "http://foo.com/changeme1.htm",
+                  title: "moz" }];
+  yield task_populateDB(change2);
+  do_check_true(isInResult(change2, root));
+
+  // Add one and take one out of query set, and simply change one so that it
+  // still applies to the query.
+  do_print("Updating More Items");
+  var change3 = [{isDetails: true, uri:"http://foo.com/changeme2.htm",
+                  title: "moz"},
+                 {isDetails: true, uri: "http://mail.foo.com/yiihah",
+                  title: "moz now updated"},
+                 {isDetails: true, uri: "ftp://foo.com/ftp", title: "gone"}];
+  yield task_populateDB(change3);
+  do_check_true(isInResult({uri: "http://foo.com/changeme2.htm"}, root));
+  do_check_true(isInResult({uri: "http://mail.foo.com/yiihah"}, root));
+  do_check_false(isInResult({uri: "ftp://foo.com/ftp"}, root));
+
+  // And now, delete one
+  do_print("Deleting items");
+  var change4 = [{isDetails: true, uri: "https://foo.com/",
+                  title: "mo,z"}];
+  yield task_populateDB(change4);
+  do_check_false(isInResult(change4, root));
+
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_searchterms-uri.js b/toolkit/components/places/tests/queries/test_searchterms-uri.js
new file mode 100644
index 000000000..af4efe196
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_searchterms-uri.js
@@ -0,0 +1,87 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+  // The test data for our database, note that the ordering of the results that
+  // will be returned by the query (the isInQuery: true objects) is IMPORTANT.
+  // see compareArrayToResult in head_queries.js for more info.
+  var testData = [
+    // Test flat domain with annotation, search term in sentence
+    {isInQuery: true, isVisit: true, isDetails: true, isPageAnnotation: true,
+     uri: "http://foo.com/", annoName: "moz/test", annoVal: "val",
+     lastVisit: lastweek, title: "you know, moz is cool"},
+
+    // Test https protocol
+    {isInQuery: false, isVisit: true, isDetails: true, title: "moz",
+     uri: "https://foo.com/", lastVisit: today},
+
+    // Begin the invalid queries: wrong search term
+    {isInQuery: false, isVisit:true, isDetails: true, title: "m o z",
+     uri: "http://foo.com/wrongsearch.php", lastVisit: today},
+
+     // Test subdomain inclued, search term at end
+     {isInQuery: false, isVisit: true, isDetails: true,
+      uri: "http://mail.foo.com/yiihah", title: "blahmoz", lastVisit: daybefore},
+
+     // Test ftp protocol - vary the title length, embed search term
+     {isInQuery: false, isVisit: true, isDetails: true,
+      uri: "ftp://foo.com/ftp", lastVisit: lastweek,
+      title: "hugelongconfmozlagurationofwordswithasearchtermsinit whoo-hoo"},
+
+    // Test what we do with escaping in titles
+    {isInQuery: false, isVisit:true, isDetails: true, title: "m%0o%0z",
+     uri: "http://foo.com/changeme1.htm", lastVisit: yesterday},
+
+    // Test another invalid title - for updating later
+    {isInQuery: false, isVisit:true, isDetails: true, title: "m,oz",
+     uri: "http://foo.com/changeme2.htm", lastVisit: yesterday}];
+
+/**
+ * This test will test Queries that use relative search terms and URI options
+ */
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_searchterms_uri()
+{
+  yield task_populateDB(testData);
+   var query = PlacesUtils.history.getNewQuery();
+   query.searchTerms = "moz";
+   query.uri = uri("http://foo.com");
+
+   // Options
+   var options = PlacesUtils.history.getNewQueryOptions();
+   options.sortingMode = options.SORT_BY_DATE_ASCENDING;
+   options.resultType = options.RESULTS_AS_URI;
+
+   // Results
+   var result = PlacesUtils.history.executeQuery(query, options);
+   var root = result.root;
+   root.containerOpen = true;
+
+   do_print("Number of items in result set: " + root.childCount);
+   for (var i=0; i < root.childCount; ++i) {
+     do_print("result: " + root.getChild(i).uri + " Title: " + root.getChild(i).title);
+   }
+
+   // Check our inital result set
+   compareArrayToResult(testData, root);
+
+   // live update.
+   do_print("change title");
+   var change1 = [{isDetails: true, uri:"http://foo.com/",
+                   title: "mo"}, ];
+   yield task_populateDB(change1);
+
+   do_check_false(isInResult({uri: "http://foo.com/"}, root));
+   var change2 = [{isDetails: true, uri:"http://foo.com/",
+                   title: "moz"}, ];
+   yield task_populateDB(change2);
+   do_check_true(isInResult({uri: "http://foo.com/"}, root));
+
+   root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/queries/test_sort-date-site-grouping.js b/toolkit/components/places/tests/queries/test_sort-date-site-grouping.js
new file mode 100644
index 000000000..7ca50e6de
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_sort-date-site-grouping.js
@@ -0,0 +1,225 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+ * ***** END LICENSE BLOCK ***** */
+
+// This test ensures that the date and site type of |place:| query maintains
+// its quantifications correctly. Namely, it ensures that the date part of the
+// query is not lost when the domain queries are made.
+
+// We specifically craft these entries so that if a by Date and Site sorting is
+// applied, we find one domain in the today range, and two domains in the older
+// than six months range.
+// The correspondence between item in |testData| and date range is stored in
+// leveledTestData.
+var testData = [
+  {
+    isVisit: true,
+    uri: "file:///directory/1",
+    lastVisit: today,
+    title: "test visit",
+    isInQuery: true
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/1",
+    lastVisit: today,
+    title: "test visit",
+    isInQuery: true
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/2",
+    lastVisit: today,
+    title: "test visit",
+    isInQuery: true
+  },
+  {
+    isVisit: true,
+    uri: "file:///directory/2",
+    lastVisit: olderthansixmonths,
+    title: "test visit",
+    isInQuery: true
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/3",
+    lastVisit: olderthansixmonths,
+    title: "test visit",
+    isInQuery: true
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/4",
+    lastVisit: olderthansixmonths,
+    title: "test visit",
+    isInQuery: true
+  },
+  {
+    isVisit: true,
+    uri: "http://example.net/1",
+    lastVisit: olderthansixmonths + 1000,
+    title: "test visit",
+    isInQuery: true
+  }
+];
+var domainsInRange = [2, 3];
+var leveledTestData = [// Today
+                       [[0],    // Today, local files
+                        [1, 2]], // Today, example.com
+                       // Older than six months
+                       [[3],    // Older than six months, local files
+                        [4, 5],  // Older than six months, example.com
+                        [6]     // Older than six months, example.net
+                        ]];
+
+// This test data is meant for live updating. The |levels| property indicates
+// date range index and then domain index.
+var testDataAddedLater = [
+  {
+    isVisit: true,
+    uri: "http://example.com/5",
+    lastVisit: olderthansixmonths,
+    title: "test visit",
+    isInQuery: true,
+    levels: [1, 1]
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/6",
+    lastVisit: olderthansixmonths,
+    title: "test visit",
+    isInQuery: true,
+    levels: [1, 1]
+  },
+  {
+    isVisit: true,
+    uri: "http://example.com/7",
+    lastVisit: today,
+    title: "test visit",
+    isInQuery: true,
+    levels: [0, 1]
+  },
+  {
+    isVisit: true,
+    uri: "file:///directory/3",
+    lastVisit: today,
+    title: "test visit",
+    isInQuery: true,
+    levels: [0, 0]
+  }
+];
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_sort_date_site_grouping()
+{
+  yield task_populateDB(testData);
+
+  // On Linux, the (local files) folder is shown after sites unlike Mac/Windows.
+  // Thus, we avoid running this test on Linux but this should be re-enabled
+  // after bug 624024 is resolved.
+  let isLinux = ("@mozilla.org/gnome-gconf-service;1" in Components.classes);
+  if (isLinux)
+    return;
+
+  // In this test, there are three levels of results:
+  // 1st: Date queries. e.g., today, last week, or older than 6 months.
+  // 2nd: Domain queries restricted to a date. e.g. mozilla.com today.
+  // 3rd: Actual visits. e.g. mozilla.com/index.html today.
+  //
+  // We store all the third level result roots so that we can easily close all
+  // containers and test live updating into specific results.
+  let roots = [];
+
+  let query = PlacesUtils.history.getNewQuery();
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.resultType = Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY;
+
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  // This corresponds to the number of date ranges.
+  do_check_eq(root.childCount, leveledTestData.length);
+
+  // We pass off to |checkFirstLevel| to check the first level of results.
+  for (let index = 0; index < leveledTestData.length; index++) {
+    let node = root.getChild(index);
+    checkFirstLevel(index, node, roots);
+  }
+
+  // Test live updating.
+  for (let visit of testDataAddedLater) {
+    yield task_populateDB([visit]);
+    let oldLength = testData.length;
+    let i = visit.levels[0];
+    let j = visit.levels[1];
+    testData.push(visit);
+    leveledTestData[i][j].push(oldLength);
+    compareArrayToResult(leveledTestData[i][j].
+                         map(x => testData[x]), roots[i][j]);
+  }
+
+  for (let i = 0; i < roots.length; i++) {
+    for (let j = 0; j < roots[i].length; j++)
+      roots[i][j].containerOpen = false;
+  }
+
+  root.containerOpen = false;
+});
+
+function checkFirstLevel(index, node, roots) {
+    PlacesUtils.asContainer(node).containerOpen = true;
+
+    do_check_true(PlacesUtils.nodeIsDay(node));
+    PlacesUtils.asQuery(node);
+    let queries = node.getQueries();
+    let options = node.queryOptions;
+
+    do_check_eq(queries.length, 1);
+    let query = queries[0];
+
+    do_check_true(query.hasBeginTime && query.hasEndTime);
+
+    // Here we check the second level of results.
+    let root = PlacesUtils.history.executeQuery(query, options).root;
+    roots.push([]);
+    root.containerOpen = true;
+
+    do_check_eq(root.childCount, leveledTestData[index].length);
+    for (var secondIndex = 0; secondIndex < root.childCount; secondIndex++) {
+      let child = PlacesUtils.asQuery(root.getChild(secondIndex));
+      checkSecondLevel(index, secondIndex, child, roots);
+    }
+    root.containerOpen = false;
+    node.containerOpen = false;
+}
+
+function checkSecondLevel(index, secondIndex, child, roots) {
+    let queries = child.getQueries();
+    let options = child.queryOptions;
+
+    do_check_eq(queries.length, 1);
+    let query = queries[0];
+
+    do_check_true(query.hasDomain);
+    do_check_true(query.hasBeginTime && query.hasEndTime);
+
+    let root = PlacesUtils.history.executeQuery(query, options).root;
+    // We should now have that roots[index][secondIndex] is set to the second
+    // level's results root.
+    roots[index].push(root);
+
+    // We pass off to compareArrayToResult to check the third level of
+    // results.
+    root.containerOpen = true;
+    compareArrayToResult(leveledTestData[index][secondIndex].
+                         map(x => testData[x]), root);
+    // We close |root|'s container later so that we can test live
+    // updates into it.
+}
diff --git a/toolkit/components/places/tests/queries/test_sorting.js b/toolkit/components/places/tests/queries/test_sorting.js
new file mode 100644
index 000000000..4d8e1146d
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_sorting.js
@@ -0,0 +1,1265 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var tests = [];
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_NONE,
+
+  *setup() {
+    do_print("Sorting test 1: SORT BY NONE");
+
+    this._unsortedData = [
+      { isBookmark: true,
+        uri: "http://example.com/b",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "y",
+        keyword: "b",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/a",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "z",
+        keyword: "a",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/c",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "x",
+        keyword: "c",
+        isInQuery: true },
+    ];
+
+    this._sortedData = this._unsortedData;
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    query.onlyBookmarked = true;
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    // no reverse sorting for SORT BY NONE
+  }
+});
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 2: SORT BY TITLE");
+
+    this._unsortedData = [
+      { isBookmark: true,
+        uri: "http://example.com/b1",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "y",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/a",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "z",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/c",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "x",
+        isInQuery: true },
+
+      // if titles are equal, should fall back to URI
+      { isBookmark: true,
+        uri: "http://example.com/b2",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "y",
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[2],
+      this._unsortedData[0],
+      this._unsortedData[3],
+      this._unsortedData[1],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    query.onlyBookmarked = true;
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 3: SORT BY DATE");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    this._unsortedData = [
+      { isVisit: true,
+        isDetails: true,
+        isBookmark: true,
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 0,
+        uri: "http://example.com/c1",
+        lastVisit: timeInMicroseconds - 2000,
+        title: "x1",
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        isBookmark: true,
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 1,
+        uri: "http://example.com/a",
+        lastVisit: timeInMicroseconds - 1000,
+        title: "z",
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        isBookmark: true,
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 2,
+        uri: "http://example.com/b",
+        lastVisit: timeInMicroseconds - 3000,
+        title: "y",
+        isInQuery: true },
+
+      // if dates are equal, should fall back to title
+      { isVisit: true,
+        isDetails: true,
+        isBookmark: true,
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 3,
+        uri: "http://example.com/c2",
+        lastVisit: timeInMicroseconds - 2000,
+        title: "x2",
+        isInQuery: true },
+
+      // if dates and title are equal, should fall back to bookmark index
+      { isVisit: true,
+        isDetails: true,
+        isBookmark: true,
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 4,
+        uri: "http://example.com/c2",
+        lastVisit: timeInMicroseconds - 2000,
+        title: "x2",
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[2],
+      this._unsortedData[0],
+      this._unsortedData[3],
+      this._unsortedData[4],
+      this._unsortedData[1],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    query.onlyBookmarked = true;
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_URI_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 4: SORT BY URI");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    this._unsortedData = [
+      { isBookmark: true,
+        isDetails: true,
+        lastVisit: timeInMicroseconds,
+        uri: "http://example.com/b",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 0,
+        title: "y",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/c",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 1,
+        title: "x",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/a",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 2,
+        title: "z",
+        isInQuery: true },
+
+      // if URIs are equal, should fall back to date
+      { isBookmark: true,
+        isDetails: true,
+        lastVisit: timeInMicroseconds + 1000,
+        uri: "http://example.com/c",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 3,
+        title: "x",
+        isInQuery: true },
+
+      // if no URI (e.g., node is a folder), should fall back to title
+      { isFolder: true,
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 4,
+        title: "a",
+        isInQuery: true },
+
+      // if URIs and dates are equal, should fall back to bookmark index
+      { isBookmark: true,
+        isDetails: true,
+        lastVisit: timeInMicroseconds + 1000,
+        uri: "http://example.com/c",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 5,
+        title: "x",
+        isInQuery: true },
+
+      // if no URI and titles are equal, should fall back to bookmark index
+      { isFolder: true,
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 6,
+        title: "a",
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[4],
+      this._unsortedData[6],
+      this._unsortedData[2],
+      this._unsortedData[0],
+      this._unsortedData[1],
+      this._unsortedData[3],
+      this._unsortedData[5],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_URI_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_VISITCOUNT_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 5: SORT BY VISITCOUNT");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    this._unsortedData = [
+      { isBookmark: true,
+        uri: "http://example.com/a",
+        lastVisit: timeInMicroseconds,
+        title: "z",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 0,
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/c",
+        lastVisit: timeInMicroseconds,
+        title: "x",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 1,
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/b1",
+        lastVisit: timeInMicroseconds,
+        title: "y1",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 2,
+        isInQuery: true },
+
+      // if visitCounts are equal, should fall back to date
+      { isBookmark: true,
+        uri: "http://example.com/b2",
+        lastVisit: timeInMicroseconds + 1000,
+        title: "y2a",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 3,
+        isInQuery: true },
+
+      // if visitCounts and dates are equal, should fall back to bookmark index
+      { isBookmark: true,
+        uri: "http://example.com/b2",
+        lastVisit: timeInMicroseconds + 1000,
+        title: "y2b",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 4,
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[0],
+      this._unsortedData[2],
+      this._unsortedData[3],
+      this._unsortedData[4],
+      this._unsortedData[1],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+    // add visits to increase visit count
+    yield PlacesTestUtils.addVisits([
+      { uri: uri("http://example.com/a"), transition: TRANSITION_TYPED, visitDate: timeInMicroseconds },
+      { uri: uri("http://example.com/b1"), transition: TRANSITION_TYPED, visitDate: timeInMicroseconds },
+      { uri: uri("http://example.com/b1"), transition: TRANSITION_TYPED, visitDate: timeInMicroseconds },
+      { uri: uri("http://example.com/b2"), transition: TRANSITION_TYPED, visitDate: timeInMicroseconds + 1000 },
+      { uri: uri("http://example.com/b2"), transition: TRANSITION_TYPED, visitDate: timeInMicroseconds + 1000 },
+      { uri: uri("http://example.com/c"), transition: TRANSITION_TYPED, visitDate: timeInMicroseconds },
+      { uri: uri("http://example.com/c"), transition: TRANSITION_TYPED, visitDate: timeInMicroseconds },
+      { uri: uri("http://example.com/c"), transition: TRANSITION_TYPED, visitDate: timeInMicroseconds },
+    ]);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    query.onlyBookmarked = true;
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_VISITCOUNT_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_KEYWORD_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 6: SORT BY KEYWORD");
+
+    this._unsortedData = [
+      { isBookmark: true,
+        uri: "http://example.com/a",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "z",
+        keyword: "a",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/c",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "x",
+        keyword: "c",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/b1",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "y9",
+        keyword: "b",
+        isInQuery: true },
+
+      // without a keyword, should fall back to title
+      { isBookmark: true,
+        uri: "http://example.com/null2",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "null8",
+        keyword: null,
+        isInQuery: true },
+
+      // without a keyword, should fall back to title
+      { isBookmark: true,
+        uri: "http://example.com/null1",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "null9",
+        keyword: null,
+        isInQuery: true },
+
+      // if keywords are equal, should fall back to title
+      { isBookmark: true,
+        uri: "http://example.com/b1",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "y8",
+        keyword: "b",
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[3],
+      this._unsortedData[4],
+      this._unsortedData[0],
+      this._unsortedData[5],
+      this._unsortedData[2],
+      this._unsortedData[1],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    query.onlyBookmarked = true;
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_KEYWORD_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 7: SORT BY DATEADDED");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    this._unsortedData = [
+      { isBookmark: true,
+        uri: "http://example.com/b1",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 0,
+        title: "y1",
+        dateAdded: timeInMicroseconds - 1000,
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/a",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 1,
+        title: "z",
+        dateAdded: timeInMicroseconds - 2000,
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/c",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 2,
+        title: "x",
+        dateAdded: timeInMicroseconds,
+        isInQuery: true },
+
+      // if dateAddeds are equal, should fall back to title
+      { isBookmark: true,
+        uri: "http://example.com/b2",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 3,
+        title: "y2",
+        dateAdded: timeInMicroseconds - 1000,
+        isInQuery: true },
+
+      // if dateAddeds and titles are equal, should fall back to bookmark index
+      { isBookmark: true,
+        uri: "http://example.com/b3",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 4,
+        title: "y3",
+        dateAdded: timeInMicroseconds - 1000,
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[1],
+      this._unsortedData[0],
+      this._unsortedData[3],
+      this._unsortedData[4],
+      this._unsortedData[2],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    query.onlyBookmarked = true;
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_LASTMODIFIED_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 8: SORT BY LASTMODIFIED");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    var timeAddedInMicroseconds = timeInMicroseconds - 10000;
+
+    this._unsortedData = [
+      { isBookmark: true,
+        uri: "http://example.com/b1",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 0,
+        title: "y1",
+        dateAdded: timeAddedInMicroseconds,
+        lastModified: timeInMicroseconds - 1000,
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/a",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 1,
+        title: "z",
+        dateAdded: timeAddedInMicroseconds,
+        lastModified: timeInMicroseconds - 2000,
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://example.com/c",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 2,
+        title: "x",
+        dateAdded: timeAddedInMicroseconds,
+        lastModified: timeInMicroseconds,
+        isInQuery: true },
+
+      // if lastModifieds are equal, should fall back to title
+      { isBookmark: true,
+        uri: "http://example.com/b2",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 3,
+        title: "y2",
+        dateAdded: timeAddedInMicroseconds,
+        lastModified: timeInMicroseconds - 1000,
+        isInQuery: true },
+
+      // if lastModifieds and titles are equal, should fall back to bookmark
+      // index
+      { isBookmark: true,
+        uri: "http://example.com/b3",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: 4,
+        title: "y3",
+        dateAdded: timeAddedInMicroseconds,
+        lastModified: timeInMicroseconds - 1000,
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[1],
+      this._unsortedData[0],
+      this._unsortedData[3],
+      this._unsortedData[4],
+      this._unsortedData[2],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    query.onlyBookmarked = true;
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_LASTMODIFIED_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_TAGS_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 9: SORT BY TAGS");
+
+    this._unsortedData = [
+      { isBookmark: true,
+        uri: "http://url2.com/",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "title x",
+        isTag: true,
+        tagArray: ["x", "y", "z"],
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://url1a.com/",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "title y1",
+        isTag: true,
+        tagArray: ["a", "b"],
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://url3a.com/",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "title w1",
+        isInQuery: true },
+
+      { isBookmark: true,
+        uri: "http://url0.com/",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "title z",
+        isTag: true,
+        tagArray: ["a", "y", "z"],
+        isInQuery: true },
+
+      // if tags are equal, should fall back to title
+      { isBookmark: true,
+        uri: "http://url1b.com/",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "title y2",
+        isTag: true,
+        tagArray: ["b", "a"],
+        isInQuery: true },
+
+      // if tags are equal, should fall back to title
+      { isBookmark: true,
+        uri: "http://url3b.com/",
+        parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+        title: "title w2",
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[2],
+      this._unsortedData[5],
+      this._unsortedData[1],
+      this._unsortedData[4],
+      this._unsortedData[3],
+      this._unsortedData[0],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+    query.setFolders([PlacesUtils.bookmarks.toolbarFolder], 1);
+    query.onlyBookmarked = true;
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_TAGS_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+// SORT_BY_ANNOTATION_* (int32)
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_ANNOTATION_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 10: SORT BY ANNOTATION (int32)");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    this._unsortedData = [
+      { isVisit: true,
+        isDetails: true,
+        lastVisit: timeInMicroseconds,
+        uri: "http://example.com/b1",
+        title: "y1",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 2,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        lastVisit: timeInMicroseconds,
+        uri: "http://example.com/a",
+        title: "z",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 1,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        lastVisit: timeInMicroseconds,
+        uri: "http://example.com/c",
+        title: "x",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 3,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      // if annotations are equal, should fall back to title
+      { isVisit: true,
+        isDetails: true,
+        lastVisit: timeInMicroseconds,
+        uri: "http://example.com/b2",
+        title: "y2",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 2,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[1],
+      this._unsortedData[0],
+      this._unsortedData[3],
+      this._unsortedData[2],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingAnnotation = "sorting";
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_ANNOTATION_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+// SORT_BY_ANNOTATION_* (int64)
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_ANNOTATION_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 11: SORT BY ANNOTATION (int64)");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    this._unsortedData = [
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://moz.com/",
+        lastVisit: timeInMicroseconds,
+        title: "I",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 0xffffffff1,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://is.com/",
+        lastVisit: timeInMicroseconds,
+        title: "love",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 0xffffffff0,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://best.com/",
+        lastVisit: timeInMicroseconds,
+        title: "moz",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 0xffffffff2,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[1],
+      this._unsortedData[0],
+      this._unsortedData[2],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingAnnotation = "sorting";
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_ANNOTATION_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+// SORT_BY_ANNOTATION_* (string)
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_ANNOTATION_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 12: SORT BY ANNOTATION (string)");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    this._unsortedData = [
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://moz.com/",
+        lastVisit: timeInMicroseconds,
+        title: "I",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: "a",
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://is.com/",
+        lastVisit: timeInMicroseconds,
+        title: "love",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: "",
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://best.com/",
+        lastVisit: timeInMicroseconds,
+        title: "moz",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: "z",
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[1],
+      this._unsortedData[0],
+      this._unsortedData[2],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingAnnotation = "sorting";
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_ANNOTATION_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+// SORT_BY_ANNOTATION_* (double)
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_ANNOTATION_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 13: SORT BY ANNOTATION (double)");
+
+    var timeInMicroseconds = Date.now() * 1000;
+    this._unsortedData = [
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://moz.com/",
+        lastVisit: timeInMicroseconds,
+        title: "I",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 1.2,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://is.com/",
+        lastVisit: timeInMicroseconds,
+        title: "love",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 1.1,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://best.com/",
+        lastVisit: timeInMicroseconds,
+        title: "moz",
+        isPageAnnotation: true,
+        annoName: "sorting",
+        annoVal: 1.3,
+        annoFlags: 0,
+        annoExpiration: Ci.nsIAnnotationService.EXPIRE_NEVER,
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[1],
+      this._unsortedData[0],
+      this._unsortedData[2],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    // Query
+    var query = PlacesUtils.history.getNewQuery();
+
+    // query options
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingAnnotation = "sorting";
+    options.sortingMode = this._sortingMode;
+
+    // Results - this gets the result set and opens it for reading and modification.
+    var result = PlacesUtils.history.executeQuery(query, options);
+    var root = result.root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_ANNOTATION_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+// SORT_BY_FRECENCY_*
+
+tests.push({
+  _sortingMode: Ci.nsINavHistoryQueryOptions.SORT_BY_FRECENCY_ASCENDING,
+
+  *setup() {
+    do_print("Sorting test 13: SORT BY FRECENCY ");
+
+    let timeInMicroseconds = PlacesUtils.toPRTime(Date.now() - 10000);
+
+    function newTimeInMicroseconds() {
+      timeInMicroseconds = timeInMicroseconds + 1000;
+      return timeInMicroseconds;
+    }
+
+    this._unsortedData = [
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://moz.com/",
+        lastVisit: newTimeInMicroseconds(),
+        title: "I",
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://moz.com/",
+        lastVisit: newTimeInMicroseconds(),
+        title: "I",
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://moz.com/",
+        lastVisit: newTimeInMicroseconds(),
+        title: "I",
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://is.com/",
+        lastVisit: newTimeInMicroseconds(),
+        title: "love",
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://best.com/",
+        lastVisit: newTimeInMicroseconds(),
+        title: "moz",
+        isInQuery: true },
+
+      { isVisit: true,
+        isDetails: true,
+        uri: "http://best.com/",
+        lastVisit: newTimeInMicroseconds(),
+        title: "moz",
+        isInQuery: true },
+    ];
+
+    this._sortedData = [
+      this._unsortedData[3],
+      this._unsortedData[5],
+      this._unsortedData[2],
+    ];
+
+    // This function in head_queries.js creates our database with the above data
+    yield task_populateDB(this._unsortedData);
+  },
+
+  check: function() {
+    var query = PlacesUtils.history.getNewQuery();
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = this._sortingMode;
+
+    var root = PlacesUtils.history.executeQuery(query, options).root;
+    root.containerOpen = true;
+    compareArrayToResult(this._sortedData, root);
+    root.containerOpen = false;
+  },
+
+  check_reverse: function() {
+    this._sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_FRECENCY_DESCENDING;
+    this._sortedData.reverse();
+    this.check();
+  }
+});
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_sorting()
+{
+  for (let test of tests) {
+    yield test.setup();
+    yield PlacesTestUtils.promiseAsyncUpdates();
+    test.check();
+    // sorting reversed, usually SORT_BY have ASC and DESC
+    test.check_reverse();
+    // Execute cleanup tasks
+    yield PlacesUtils.bookmarks.eraseEverything();
+    yield PlacesTestUtils.clearHistory();
+  }
+});
diff --git a/toolkit/components/places/tests/queries/test_tags.js b/toolkit/components/places/tests/queries/test_tags.js
new file mode 100644
index 000000000..afda3f03f
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_tags.js
@@ -0,0 +1,743 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Tests bookmark and history queries with tags.  See bug 399799.
+ */
+
+"use strict";
+
+add_task(function* tags_getter_setter() {
+  do_print("Tags getter/setter should work correctly");
+  do_print("Without setting tags, tags getter should return empty array");
+  var [query] = makeQuery();
+  do_check_eq(query.tags.length, 0);
+
+  do_print("Setting tags to an empty array, tags getter should return "+
+           "empty array");
+  [query] = makeQuery([]);
+  do_check_eq(query.tags.length, 0);
+
+  do_print("Setting a few tags, tags getter should return correct array");
+  var tags = ["bar", "baz", "foo"];
+  [query] = makeQuery(tags);
+  setsAreEqual(query.tags, tags, true);
+
+  do_print("Setting some dupe tags, tags getter return unique tags");
+  [query] = makeQuery(["foo", "foo", "bar", "foo", "baz", "bar"]);
+  setsAreEqual(query.tags, ["bar", "baz", "foo"], true);
+});
+
+add_task(function* invalid_setter_calls() {
+  do_print("Invalid calls to tags setter should fail");
+  try {
+    var query = PlacesUtils.history.getNewQuery();
+    query.tags = null;
+    do_throw("Passing null to SetTags should fail");
+  }
+  catch (exc) {}
+
+  try {
+    query = PlacesUtils.history.getNewQuery();
+    query.tags = "this should not work";
+    do_throw("Passing a string to SetTags should fail");
+  }
+  catch (exc) {}
+
+  try {
+    makeQuery([null]);
+    do_throw("Passing one-element array with null to SetTags should fail");
+  }
+  catch (exc) {}
+
+  try {
+    makeQuery([undefined]);
+    do_throw("Passing one-element array with undefined to SetTags " +
+             "should fail");
+  }
+  catch (exc) {}
+
+  try {
+    makeQuery(["foo", null, "bar"]);
+    do_throw("Passing mixture of tags and null to SetTags should fail");
+  }
+  catch (exc) {}
+
+  try {
+    makeQuery(["foo", undefined, "bar"]);
+    do_throw("Passing mixture of tags and undefined to SetTags " +
+             "should fail");
+  }
+  catch (exc) {}
+
+  try {
+    makeQuery([1, 2, 3]);
+    do_throw("Passing numbers to SetTags should fail");
+  }
+  catch (exc) {}
+
+  try {
+    makeQuery(["foo", 1, 2, 3]);
+    do_throw("Passing mixture of tags and numbers to SetTags should fail");
+  }
+  catch (exc) {}
+
+  try {
+    var str = PlacesUtils.toISupportsString("foo");
+    query = PlacesUtils.history.getNewQuery();
+    query.tags = str;
+    do_throw("Passing nsISupportsString to SetTags should fail");
+  }
+  catch (exc) {}
+
+  try {
+    makeQuery([str]);
+    do_throw("Passing array of nsISupportsStrings to SetTags should fail");
+  }
+  catch (exc) {}
+});
+
+add_task(function* not_setting_tags() {
+  do_print("Not setting tags at all should not affect query URI");
+  checkQueryURI();
+});
+
+add_task(function* empty_array_tags() {
+  do_print("Setting tags with an empty array should not affect query URI");
+  checkQueryURI([]);
+});
+
+add_task(function* set_tags() {
+  do_print("Setting some tags should result in correct query URI");
+  checkQueryURI([
+    "foo",
+    "七難",
+    "",
+    "いっぱいおっぱい",
+    "Abracadabra",
+    "１２３",
+    "Here's a pretty long tag name with some = signs and 1 2 3s and spaces oh jeez will it work I hope so!",
+    "アスキーでございません",
+    "あいうえお",
+  ]);
+});
+
+add_task(function* no_tags_tagsAreNot() {
+  do_print("Not setting tags at all but setting tagsAreNot should " +
+           "affect query URI");
+  checkQueryURI(null, true);
+});
+
+add_task(function* empty_array_tags_tagsAreNot() {
+  do_print("Setting tags with an empty array and setting tagsAreNot " +
+           "should affect query URI");
+  checkQueryURI([], true);
+});
+
+add_task(function* () {
+  do_print("Setting some tags and setting tagsAreNot should result in " +
+           "correct query URI");
+  checkQueryURI([
+    "foo",
+    "七難",
+    "",
+    "いっぱいおっぱい",
+    "Abracadabra",
+    "１２３",
+    "Here's a pretty long tag name with some = signs and 1 2 3s and spaces oh jeez will it work I hope so!",
+    "アスキーでございません",
+    "あいうえお",
+  ], true);
+});
+
+add_task(function* tag_to_uri() {
+  do_print("Querying history on tag associated with a URI should return " +
+           "that URI");
+  yield task_doWithVisit(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["foo"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["bar"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["baz"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+  });
+});
+
+add_task(function* tags_to_uri() {
+  do_print("Querying history on many tags associated with a URI should " +
+           "return that URI");
+  yield task_doWithVisit(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["foo", "bar"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["foo", "baz"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["bar", "baz"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["foo", "bar", "baz"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+  });
+});
+
+add_task(function* repeated_tag() {
+  do_print("Specifying the same tag multiple times in a history query " +
+           "should not matter");
+  yield task_doWithVisit(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["foo", "foo"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["foo", "foo", "foo", "bar", "bar", "baz"]);
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+  });
+});
+
+add_task(function* many_tags_no_uri() {
+  do_print("Querying history on many tags associated with a URI and " +
+           "tags not associated with that URI should not return that URI");
+  yield task_doWithVisit(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["foo", "bogus"]);
+    executeAndCheckQueryResults(query, opts, []);
+    [query, opts] = makeQuery(["foo", "bar", "bogus"]);
+    executeAndCheckQueryResults(query, opts, []);
+    [query, opts] = makeQuery(["foo", "bar", "baz", "bogus"]);
+    executeAndCheckQueryResults(query, opts, []);
+  });
+});
+
+add_task(function* nonexistent_tags() {
+  do_print("Querying history on nonexistent tags should return no results");
+  yield task_doWithVisit(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["bogus"]);
+    executeAndCheckQueryResults(query, opts, []);
+    [query, opts] = makeQuery(["bogus", "gnarly"]);
+    executeAndCheckQueryResults(query, opts, []);
+  });
+});
+
+add_task(function* tag_to_bookmark() {
+  do_print("Querying bookmarks on tag associated with a URI should " +
+           "return that URI");
+  yield task_doWithBookmark(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["foo"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["bar"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["baz"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+  });
+});
+
+add_task(function* many_tags_to_bookmark() {
+  do_print("Querying bookmarks on many tags associated with a URI " +
+           "should return that URI");
+  yield task_doWithBookmark(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["foo", "bar"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["foo", "baz"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["bar", "baz"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["foo", "bar", "baz"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+  });
+});
+
+add_task(function* repeated_tag_to_bookmarks() {
+  do_print("Specifying the same tag multiple times in a bookmark query " +
+           "should not matter");
+  yield task_doWithBookmark(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["foo", "foo"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+    [query, opts] = makeQuery(["foo", "foo", "foo", "bar", "bar", "baz"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, [aURI.spec]);
+  });
+});
+
+add_task(function* many_tags_no_bookmark() {
+  do_print("Querying bookmarks on many tags associated with a URI and " +
+           "tags not associated with that URI should not return that URI");
+  yield task_doWithBookmark(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["foo", "bogus"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, []);
+    [query, opts] = makeQuery(["foo", "bar", "bogus"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, []);
+    [query, opts] = makeQuery(["foo", "bar", "baz", "bogus"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, []);
+  });
+});
+
+add_task(function* nonexistent_tags_bookmark() {
+  do_print("Querying bookmarks on nonexistent tag should return no results");
+  yield task_doWithBookmark(["foo", "bar", "baz"], function (aURI) {
+    var [query, opts] = makeQuery(["bogus"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, []);
+    [query, opts] = makeQuery(["bogus", "gnarly"]);
+    opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+    executeAndCheckQueryResults(query, opts, []);
+  });
+});
+
+add_task(function* tagsAreNot_history() {
+  do_print("Querying history using tagsAreNot should work correctly");
+  var urisAndTags = {
+    "http://example.com/1": ["foo", "bar"],
+    "http://example.com/2": ["baz", "qux"],
+    "http://example.com/3": null
+  };
+
+  do_print("Add visits and tag the URIs");
+  for (let [pURI, tags] of Object.entries(urisAndTags)) {
+    let nsiuri = uri(pURI);
+    yield PlacesTestUtils.addVisits(nsiuri);
+    if (tags)
+      PlacesUtils.tagging.tagURI(nsiuri, tags);
+  }
+
+  do_print('  Querying for "foo" should match only /2 and /3');
+  var [query, opts] = makeQuery(["foo"], true);
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/2", "http://example.com/3"]);
+
+  do_print('  Querying for "foo" and "bar" should match only /2 and /3');
+  [query, opts] = makeQuery(["foo", "bar"], true);
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/2", "http://example.com/3"]);
+
+  do_print('  Querying for "foo" and "bogus" should match only /2 and /3');
+  [query, opts] = makeQuery(["foo", "bogus"], true);
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/2", "http://example.com/3"]);
+
+  do_print('  Querying for "foo" and "baz" should match only /3');
+  [query, opts] = makeQuery(["foo", "baz"], true);
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/3"]);
+
+  do_print('  Querying for "bogus" should match all');
+  [query, opts] = makeQuery(["bogus"], true);
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/1",
+                   "http://example.com/2",
+                   "http://example.com/3"]);
+
+  // Clean up.
+  for (let [pURI, tags] of Object.entries(urisAndTags)) {
+    let nsiuri = uri(pURI);
+    if (tags)
+      PlacesUtils.tagging.untagURI(nsiuri, tags);
+  }
+  yield task_cleanDatabase();
+});
+
+add_task(function* tagsAreNot_bookmarks() {
+  do_print("Querying bookmarks using tagsAreNot should work correctly");
+  var urisAndTags = {
+    "http://example.com/1": ["foo", "bar"],
+    "http://example.com/2": ["baz", "qux"],
+    "http://example.com/3": null
+  };
+
+  do_print("Add bookmarks and tag the URIs");
+  for (let [pURI, tags] of Object.entries(urisAndTags)) {
+    let nsiuri = uri(pURI);
+    yield addBookmark(nsiuri);
+    if (tags)
+      PlacesUtils.tagging.tagURI(nsiuri, tags);
+  }
+
+  do_print('  Querying for "foo" should match only /2 and /3');
+  var [query, opts] = makeQuery(["foo"], true);
+  opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/2", "http://example.com/3"]);
+
+  do_print('  Querying for "foo" and "bar" should match only /2 and /3');
+  [query, opts] = makeQuery(["foo", "bar"], true);
+  opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/2", "http://example.com/3"]);
+
+  do_print('  Querying for "foo" and "bogus" should match only /2 and /3');
+  [query, opts] = makeQuery(["foo", "bogus"], true);
+  opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/2", "http://example.com/3"]);
+
+  do_print('  Querying for "foo" and "baz" should match only /3');
+  [query, opts] = makeQuery(["foo", "baz"], true);
+  opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/3"]);
+
+  do_print('  Querying for "bogus" should match all');
+  [query, opts] = makeQuery(["bogus"], true);
+  opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root,
+                  ["http://example.com/1",
+                   "http://example.com/2",
+                   "http://example.com/3"]);
+
+  // Clean up.
+  for (let [pURI, tags] of Object.entries(urisAndTags)) {
+    let nsiuri = uri(pURI);
+    if (tags)
+      PlacesUtils.tagging.untagURI(nsiuri, tags);
+  }
+  yield task_cleanDatabase();
+});
+
+add_task(function* duplicate_tags() {
+  do_print("Duplicate existing tags (i.e., multiple tag folders with " +
+           "same name) should not throw off query results");
+  var tagName = "foo";
+
+  do_print("Add bookmark and tag it normally");
+  yield addBookmark(TEST_URI);
+  PlacesUtils.tagging.tagURI(TEST_URI, [tagName]);
+
+  do_print("Manually create tag folder with same name as tag and insert " +
+           "bookmark");
+  let dupTag = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.tagsGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: tagName
+  });
+
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: dupTag.guid,
+    title: "title",
+    url: TEST_URI
+  });
+
+  do_print("Querying for tag should match URI");
+  var [query, opts] = makeQuery([tagName]);
+  opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root, [TEST_URI.spec]);
+
+  PlacesUtils.tagging.untagURI(TEST_URI, [tagName]);
+  yield task_cleanDatabase();
+});
+
+add_task(function* folder_named_as_tag() {
+  do_print("Regular folders with the same name as tag should not throw " +
+           "off query results");
+  var tagName = "foo";
+
+  do_print("Add bookmark and tag it");
+  yield addBookmark(TEST_URI);
+  PlacesUtils.tagging.tagURI(TEST_URI, [tagName]);
+
+  do_print("Create folder with same name as tag");
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: tagName
+  });
+
+  do_print("Querying for tag should match URI");
+  var [query, opts] = makeQuery([tagName]);
+  opts.queryType = opts.QUERY_TYPE_BOOKMARKS;
+  queryResultsAre(PlacesUtils.history.executeQuery(query, opts).root, [TEST_URI.spec]);
+
+  PlacesUtils.tagging.untagURI(TEST_URI, [tagName]);
+  yield task_cleanDatabase();
+});
+
+add_task(function* ORed_queries() {
+  do_print("Multiple queries ORed together should work");
+  var urisAndTags = {
+    "http://example.com/1": [],
+    "http://example.com/2": []
+  };
+
+  // Search with lots of tags to make sure tag parameter substitution in SQL
+  // can handle it with more than one query.
+  for (let i = 0; i < 11; i++) {
+    urisAndTags["http://example.com/1"].push("/1 tag " + i);
+    urisAndTags["http://example.com/2"].push("/2 tag " + i);
+  }
+
+  do_print("Add visits and tag the URIs");
+  for (let [pURI, tags] of Object.entries(urisAndTags)) {
+    let nsiuri = uri(pURI);
+    yield PlacesTestUtils.addVisits(nsiuri);
+    if (tags)
+      PlacesUtils.tagging.tagURI(nsiuri, tags);
+  }
+
+  do_print("Query for /1 OR query for /2 should match both /1 and /2");
+  var [query1, opts] = makeQuery(urisAndTags["http://example.com/1"]);
+  var [query2] = makeQuery(urisAndTags["http://example.com/2"]);
+  var root = PlacesUtils.history.executeQueries([query1, query2], 2, opts).root;
+  queryResultsAre(root, ["http://example.com/1", "http://example.com/2"]);
+
+  do_print("Query for /1 OR query on bogus tag should match only /1");
+  [query1, opts] = makeQuery(urisAndTags["http://example.com/1"]);
+  [query2] = makeQuery(["bogus"]);
+  root = PlacesUtils.history.executeQueries([query1, query2], 2, opts).root;
+  queryResultsAre(root, ["http://example.com/1"]);
+
+  do_print("Query for /1 OR query for /1 should match only /1");
+  [query1, opts] = makeQuery(urisAndTags["http://example.com/1"]);
+  [query2] = makeQuery(urisAndTags["http://example.com/1"]);
+  root = PlacesUtils.history.executeQueries([query1, query2], 2, opts).root;
+  queryResultsAre(root, ["http://example.com/1"]);
+
+  do_print("Query for /1 with tagsAreNot OR query for /2 with tagsAreNot " +
+           "should match both /1 and /2");
+  [query1, opts] = makeQuery(urisAndTags["http://example.com/1"], true);
+  [query2] = makeQuery(urisAndTags["http://example.com/2"], true);
+  root = PlacesUtils.history.executeQueries([query1, query2], 2, opts).root;
+  queryResultsAre(root, ["http://example.com/1", "http://example.com/2"]);
+
+  do_print("Query for /1 OR query for /2 with tagsAreNot should match " +
+           "only /1");
+  [query1, opts] = makeQuery(urisAndTags["http://example.com/1"]);
+  [query2] = makeQuery(urisAndTags["http://example.com/2"], true);
+  root = PlacesUtils.history.executeQueries([query1, query2], 2, opts).root;
+  queryResultsAre(root, ["http://example.com/1"]);
+
+  do_print("Query for /1 OR query for /1 with tagsAreNot should match " +
+           "both URIs");
+  [query1, opts] = makeQuery(urisAndTags["http://example.com/1"]);
+  [query2] = makeQuery(urisAndTags["http://example.com/1"], true);
+  root = PlacesUtils.history.executeQueries([query1, query2], 2, opts).root;
+  queryResultsAre(root, ["http://example.com/1", "http://example.com/2"]);
+
+  // Clean up.
+  for (let [pURI, tags] of Object.entries(urisAndTags)) {
+    let nsiuri = uri(pURI);
+    if (tags)
+      PlacesUtils.tagging.untagURI(nsiuri, tags);
+  }
+  yield task_cleanDatabase();
+});
+
+// The tag keys in query URIs, i.e., "place:tag=foo&!tags=1"
+//                                          ---     -----
+const QUERY_KEY_TAG      = "tag";
+const QUERY_KEY_NOT_TAGS = "!tags";
+
+const TEST_URI = uri("http://example.com/");
+
+/**
+ * Adds a bookmark.
+ *
+ * @param aURI
+ *        URI of the page (an nsIURI)
+ */
+function addBookmark(aURI) {
+  return PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    title: aURI.spec,
+    url: aURI
+  });
+}
+
+/**
+ * Asynchronous task that removes all pages from history and bookmarks.
+ */
+function* task_cleanDatabase(aCallback) {
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+}
+
+/**
+ * Sets up a query with the specified tags, converts it to a URI, and makes sure
+ * the URI is what we expect it to be.
+ *
+ * @param aTags
+ *        The query's tags will be set to those in this array
+ * @param aTagsAreNot
+ *        The query's tagsAreNot property will be set to this
+ */
+function checkQueryURI(aTags, aTagsAreNot) {
+  var pairs = (aTags || []).sort().map(t => QUERY_KEY_TAG + "=" + encodeTag(t));
+  if (aTagsAreNot)
+    pairs.push(QUERY_KEY_NOT_TAGS + "=1");
+  var expURI = "place:" + pairs.join("&");
+  var [query, opts] = makeQuery(aTags, aTagsAreNot);
+  var actualURI = queryURI(query, opts);
+  do_print("Query URI should be what we expect for the given tags");
+  do_check_eq(actualURI, expURI);
+}
+
+/**
+ * Asynchronous task that executes a callback task in a "scoped" database state.
+ * A bookmark is added and tagged before the callback is called, and afterward
+ * the database is cleared.
+ *
+ * @param aTags
+ *        A bookmark will be added and tagged with this array of tags
+ * @param aCallback
+ *        A task function that will be called after the bookmark has been tagged
+ */
+function* task_doWithBookmark(aTags, aCallback) {
+  yield addBookmark(TEST_URI);
+  PlacesUtils.tagging.tagURI(TEST_URI, aTags);
+  yield aCallback(TEST_URI);
+  PlacesUtils.tagging.untagURI(TEST_URI, aTags);
+  yield task_cleanDatabase();
+}
+
+/**
+ * Asynchronous task that executes a callback function in a "scoped" database
+ * state.  A history visit is added and tagged before the callback is called,
+ * and afterward the database is cleared.
+ *
+ * @param aTags
+ *        A history visit will be added and tagged with this array of tags
+ * @param aCallback
+ *        A function that will be called after the visit has been tagged
+ */
+function* task_doWithVisit(aTags, aCallback) {
+  yield PlacesTestUtils.addVisits(TEST_URI);
+  PlacesUtils.tagging.tagURI(TEST_URI, aTags);
+  yield aCallback(TEST_URI);
+  PlacesUtils.tagging.untagURI(TEST_URI, aTags);
+  yield task_cleanDatabase();
+}
+
+/**
+ * queriesToQueryString() encodes every character in the query URI that doesn't
+ * match /[a-zA-Z]/.  There's no simple JavaScript function that does the same,
+ * but encodeURIComponent() comes close, only missing some punctuation.  This
+ * function takes care of all of that.
+ *
+ * @param  aTag
+ *         A tag name to encode
+ * @return A UTF-8 escaped string suitable for inclusion in a query URI
+ */
+function encodeTag(aTag) {
+  return encodeURIComponent(aTag).
+         replace(/[-_.!~*'()]/g, // '
+                 s => "%" + s.charCodeAt(0).toString(16));
+}
+
+/**
+ * Executes the given query and compares the results to the given URIs.
+ * See queryResultsAre().
+ *
+ * @param aQuery
+ *        An nsINavHistoryQuery
+ * @param aQueryOpts
+ *        An nsINavHistoryQueryOptions
+ * @param aExpectedURIs
+ *        Array of URIs (as strings) that aResultRoot should contain
+ */
+function executeAndCheckQueryResults(aQuery, aQueryOpts, aExpectedURIs) {
+  var root = PlacesUtils.history.executeQuery(aQuery, aQueryOpts).root;
+  root.containerOpen = true;
+  queryResultsAre(root, aExpectedURIs);
+  root.containerOpen = false;
+}
+
+/**
+ * Returns new query and query options objects.  The query's tags will be
+ * set to aTags.  aTags may be null, in which case setTags() is not called at
+ * all on the query.
+ *
+ * @param  aTags
+ *         The query's tags will be set to those in this array
+ * @param  aTagsAreNot
+ *         The query's tagsAreNot property will be set to this
+ * @return [query, queryOptions]
+ */
+function makeQuery(aTags, aTagsAreNot) {
+  aTagsAreNot = !!aTagsAreNot;
+  do_print("Making a query " +
+        (aTags ?
+         "with tags " + aTags.toSource() :
+         "without calling setTags() at all") +
+        " and with tagsAreNot=" +
+        aTagsAreNot);
+  var query = PlacesUtils.history.getNewQuery();
+  query.tagsAreNot = aTagsAreNot;
+  if (aTags) {
+    query.tags = aTags;
+    var uniqueTags = [];
+    aTags.forEach(function (t) {
+      if (typeof(t) === "string" && uniqueTags.indexOf(t) < 0)
+        uniqueTags.push(t);
+    });
+    uniqueTags.sort();
+  }
+
+  do_print("Made query should be correct for tags and tagsAreNot");
+  if (uniqueTags)
+    setsAreEqual(query.tags, uniqueTags, true);
+  var expCount = uniqueTags ? uniqueTags.length : 0;
+  do_check_eq(query.tags.length, expCount);
+  do_check_eq(query.tagsAreNot, aTagsAreNot);
+
+  return [query, PlacesUtils.history.getNewQueryOptions()];
+}
+
+/**
+ * Ensures that the URIs of aResultRoot are the same as those in aExpectedURIs.
+ *
+ * @param aResultRoot
+ *        The nsINavHistoryContainerResultNode root of an nsINavHistoryResult
+ * @param aExpectedURIs
+ *        Array of URIs (as strings) that aResultRoot should contain
+ */
+function queryResultsAre(aResultRoot, aExpectedURIs) {
+  var rootWasOpen = aResultRoot.containerOpen;
+  if (!rootWasOpen)
+    aResultRoot.containerOpen = true;
+  var actualURIs = [];
+  for (let i = 0; i < aResultRoot.childCount; i++) {
+    actualURIs.push(aResultRoot.getChild(i).uri);
+  }
+  setsAreEqual(actualURIs, aExpectedURIs);
+  if (!rootWasOpen)
+    aResultRoot.containerOpen = false;
+}
+
+/**
+ * Converts the given query into its query URI.
+ *
+ * @param  aQuery
+ *         An nsINavHistoryQuery
+ * @param  aQueryOpts
+ *         An nsINavHistoryQueryOptions
+ * @return The query's URI
+ */
+function queryURI(aQuery, aQueryOpts) {
+  return PlacesUtils.history.queriesToQueryString([aQuery], 1, aQueryOpts);
+}
+
+/**
+ * Ensures that the arrays contain the same elements and, optionally, in the
+ * same order.
+ */
+function setsAreEqual(aArr1, aArr2, aIsOrdered) {
+  do_check_eq(aArr1.length, aArr2.length);
+  if (aIsOrdered) {
+    for (let i = 0; i < aArr1.length; i++) {
+      do_check_eq(aArr1[i], aArr2[i]);
+    }
+  }
+  else {
+    aArr1.forEach(u => do_check_true(aArr2.indexOf(u) >= 0));
+    aArr2.forEach(u => do_check_true(aArr1.indexOf(u) >= 0));
+  }
+}
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/queries/test_transitions.js b/toolkit/components/places/tests/queries/test_transitions.js
new file mode 100644
index 000000000..bbd4c9e01
--- /dev/null
+++ b/toolkit/components/places/tests/queries/test_transitions.js
@@ -0,0 +1,178 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* ***** BEGIN LICENSE BLOCK *****
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+ * ***** END LICENSE BLOCK ***** */
+var beginTime = Date.now();
+var testData = [
+  {
+    isVisit: true,
+    title: "page 0",
+    uri: "http://mozilla.com/",
+    transType: Ci.nsINavHistoryService.TRANSITION_TYPED
+  },
+  {
+    isVisit: true,
+    title: "page 1",
+    uri: "http://google.com/",
+    transType: Ci.nsINavHistoryService.TRANSITION_DOWNLOAD
+  },
+  {
+    isVisit: true,
+    title: "page 2",
+    uri: "http://microsoft.com/",
+    transType: Ci.nsINavHistoryService.TRANSITION_DOWNLOAD
+  },
+  {
+    isVisit: true,
+    title: "page 3",
+    uri: "http://en.wikipedia.org/",
+    transType: Ci.nsINavHistoryService.TRANSITION_BOOKMARK
+  },
+  {
+    isVisit: true,
+    title: "page 4",
+    uri: "http://fr.wikipedia.org/",
+    transType: Ci.nsINavHistoryService.TRANSITION_DOWNLOAD
+  },
+  {
+    isVisit: true,
+    title: "page 5",
+    uri: "http://apple.com/",
+    transType: Ci.nsINavHistoryService.TRANSITION_TYPED
+  },
+  {
+    isVisit: true,
+    title: "page 6",
+    uri: "http://campus-bike-store.com/",
+    transType: Ci.nsINavHistoryService.TRANSITION_DOWNLOAD
+  },
+  {
+    isVisit: true,
+    title: "page 7",
+    uri: "http://uwaterloo.ca/",
+    transType: Ci.nsINavHistoryService.TRANSITION_TYPED
+  },
+  {
+    isVisit: true,
+    title: "page 8",
+    uri: "http://pugcleaner.com/",
+    transType: Ci.nsINavHistoryService.TRANSITION_BOOKMARK
+  },
+  {
+    isVisit: true,
+    title: "page 9",
+    uri: "http://de.wikipedia.org/",
+    transType: Ci.nsINavHistoryService.TRANSITION_TYPED
+  },
+  {
+    isVisit: true,
+    title: "arewefastyet",
+    uri: "http://arewefastyet.com/",
+    transType: Ci.nsINavHistoryService.TRANSITION_DOWNLOAD
+  },
+  {
+    isVisit: true,
+    title: "arewefastyet",
+    uri: "http://arewefastyet.com/",
+    transType: Ci.nsINavHistoryService.TRANSITION_BOOKMARK
+  }];
+// sets of indices of testData array by transition type
+var testDataTyped = [0, 5, 7, 9];
+var testDataDownload = [1, 2, 4, 6, 10];
+var testDataBookmark = [3, 8, 11];
+
+/**
+ * run_test is where the magic happens.  This is automatically run by the test
+ * harness.  It is where you do the work of creating the query, running it, and
+ * playing with the result set.
+ */
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_transitions()
+{
+  let timeNow = Date.now();
+  for (let item of testData) {
+    yield PlacesTestUtils.addVisits({
+      uri: uri(item.uri),
+      transition: item.transType,
+      visitDate: timeNow++ * 1000,
+      title: item.title
+    });
+  }
+
+  // dump_table("moz_places");
+  // dump_table("moz_historyvisits");
+
+  var numSortFunc = function (a, b) { return (a - b); };
+  var arrs = testDataTyped.concat(testDataDownload).concat(testDataBookmark)
+              .sort(numSortFunc);
+
+  // Four tests which compare the result of a query to an expected set.
+  var data = arrs.filter(function (index) {
+      return (testData[index].uri.match(/arewefastyet\.com/) &&
+              testData[index].transType ==
+                Ci.nsINavHistoryService.TRANSITION_DOWNLOAD);
+    });
+
+  compareQueryToTestData("place:domain=arewefastyet.com&transition=" +
+                         Ci.nsINavHistoryService.TRANSITION_DOWNLOAD,
+                         data.slice());
+
+  compareQueryToTestData("place:transition=" +
+                         Ci.nsINavHistoryService.TRANSITION_DOWNLOAD,
+                         testDataDownload.slice());
+
+  compareQueryToTestData("place:transition=" +
+                         Ci.nsINavHistoryService.TRANSITION_TYPED,
+                         testDataTyped.slice());
+
+  compareQueryToTestData("place:transition=" +
+                         Ci.nsINavHistoryService.TRANSITION_DOWNLOAD +
+                         "&transition=" +
+                         Ci.nsINavHistoryService.TRANSITION_BOOKMARK,
+                         data);
+
+  // Tests the live update property of transitions.
+  var query = {};
+  var options = {};
+  PlacesUtils.history.
+    queryStringToQueries("place:transition=" +
+                         Ci.nsINavHistoryService.TRANSITION_DOWNLOAD,
+                         query, {}, options);
+  query = (query.value)[0];
+  options = PlacesUtils.history.getNewQueryOptions();
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  do_check_eq(testDataDownload.length, root.childCount);
+  yield PlacesTestUtils.addVisits({
+    uri: uri("http://getfirefox.com"),
+    transition: TRANSITION_DOWNLOAD
+  });
+  do_check_eq(testDataDownload.length + 1, root.childCount);
+  root.containerOpen = false;
+});
+
+/*
+ * Takes a query and a set of indices. The indices correspond to elements
+ * of testData that are the result of the query.
+ */
+function compareQueryToTestData(queryStr, data) {
+  var query = {};
+  var options = {};
+  PlacesUtils.history.queryStringToQueries(queryStr, query, {}, options);
+  query = query.value[0];
+  options = options.value;
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var root = result.root;
+  for (var i = 0; i < data.length; i++) {
+    data[i] = testData[data[i]];
+    data[i].isInQuery = true;
+  }
+  compareArrayToResult(data, root);
+}
diff --git a/toolkit/components/places/tests/queries/xpcshell.ini b/toolkit/components/places/tests/queries/xpcshell.ini
new file mode 100644
index 000000000..7ff864679
--- /dev/null
+++ b/toolkit/components/places/tests/queries/xpcshell.ini
@@ -0,0 +1,34 @@
+[DEFAULT]
+head = head_queries.js
+tail =
+skip-if = toolkit == 'android'
+
+[test_415716.js]
+[test_abstime-annotation-domain.js]
+[test_abstime-annotation-uri.js]
+[test_async.js]
+[test_containersQueries_sorting.js]
+[test_history_queries_tags_liveUpdate.js]
+[test_history_queries_titles_liveUpdate.js]
+[test_onlyBookmarked.js]
+[test_queryMultipleFolder.js]
+[test_querySerialization.js]
+[test_redirects.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_results-as-tag-contents-query.js]
+[test_results-as-visit.js]
+[test_searchterms-domain.js]
+[test_searchterms-uri.js]
+[test_searchterms-bookmarklets.js]
+[test_sort-date-site-grouping.js]
+[test_sorting.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android" 
+[test_tags.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_transitions.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_searchTerms_includeHidden.js]
diff --git a/toolkit/components/places/tests/unifiedcomplete/.eslintrc.js b/toolkit/components/places/tests/unifiedcomplete/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/unifiedcomplete/data/engine-rel-searchform.xml b/toolkit/components/places/tests/unifiedcomplete/data/engine-rel-searchform.xml
new file mode 100644
index 000000000..f4baad28a
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/data/engine-rel-searchform.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<SearchPlugin xmlns="http://www.mozilla.org/2006/browser/search/">
+<ShortName>engine-rel-searchform.xml</ShortName>
+<Url type="text/html" method="GET" template="http://example.com/?search" rel="searchform"/>
+</SearchPlugin>
diff --git a/toolkit/components/places/tests/unifiedcomplete/data/engine-suggestions.xml b/toolkit/components/places/tests/unifiedcomplete/data/engine-suggestions.xml
new file mode 100644
index 000000000..a322a7c86
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/data/engine-suggestions.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+
+<SearchPlugin xmlns="http://www.mozilla.org/2006/browser/search/">
+<ShortName>engine-suggestions.xml</ShortName>
+<Url type="application/x-suggestions+json"
+     method="GET"
+     template="http://localhost:9000/suggest?{searchTerms}"/>
+<Url type="text/html"
+     method="GET"
+     template="http://localhost:9000/search"
+     rel="searchform"/>
+</SearchPlugin>
diff --git a/toolkit/components/places/tests/unifiedcomplete/head_autocomplete.js b/toolkit/components/places/tests/unifiedcomplete/head_autocomplete.js
new file mode 100644
index 000000000..11e917e18
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/head_autocomplete.js
@@ -0,0 +1,505 @@
+/* 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/. */
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+const FRECENCY_DEFAULT = 10000;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://testing-common/httpd.js");
+
+// Import common head.
+{
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
+
+// Put any other stuff relative to this test folder below.
+
+const TITLE_SEARCH_ENGINE_SEPARATOR = " \u00B7\u2013\u00B7 ";
+
+function run_test() {
+  run_next_test();
+}
+
+function* cleanup() {
+  Services.prefs.clearUserPref("browser.urlbar.autocomplete.enabled");
+  Services.prefs.clearUserPref("browser.urlbar.autoFill");
+  Services.prefs.clearUserPref("browser.urlbar.autoFill.typed");
+  Services.prefs.clearUserPref("browser.urlbar.autoFill.searchEngines");
+  let suggestPrefs = [
+    "history",
+    "bookmark",
+    "history.onlyTyped",
+    "openpage",
+    "searches",
+  ];
+  for (let type of suggestPrefs) {
+    Services.prefs.clearUserPref("browser.urlbar.suggest." + type);
+  }
+  Services.prefs.clearUserPref("browser.search.suggest.enabled");
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+}
+do_register_cleanup(cleanup);
+
+/**
+ * @param aSearches
+ *        Array of AutoCompleteSearch names.
+ */
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  popup: {
+    selectedIndex: -1,
+    invalidate: function () {},
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompletePopup])
+  },
+  popupOpen: false,
+
+  disableAutoComplete: false,
+  completeDefaultIndex: true,
+  completeSelectedIndex: true,
+  forceComplete: false,
+
+  minResultsForPopup: 0,
+  maxRows: 0,
+
+  showCommentColumn: false,
+  showImageColumn: false,
+
+  timeout: 10,
+  searchParam: "",
+
+  get searchCount() {
+    return this.searches.length;
+  },
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  textValue: "",
+  // Text selection range
+  _selStart: 0,
+  _selEnd: 0,
+  get selectionStart() {
+    return this._selStart;
+  },
+  get selectionEnd() {
+    return this._selEnd;
+  },
+  selectTextRange: function(aStart, aEnd) {
+    this._selStart = aStart;
+    this._selEnd = aEnd;
+  },
+
+  onSearchBegin: function () {},
+  onSearchComplete: function () {},
+
+  onTextEntered: () => false,
+  onTextReverted: () => false,
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompleteInput])
+}
+
+// A helper for check_autocomplete to check a specific match against data from
+// the controller.
+function _check_autocomplete_matches(match, result) {
+  let { uri, title, tags, style } = match;
+  if (tags)
+    title += " \u2013 " + tags.sort().join(", ");
+  if (style)
+    style = style.sort();
+  else
+    style = ["favicon"];
+
+  do_print(`Checking against expected "${uri.spec}", "${title}"`);
+  // Got a match on both uri and title?
+  if (stripPrefix(uri.spec) != stripPrefix(result.value) || title != result.comment) {
+    return false;
+  }
+
+  let actualStyle = result.style.split(/\s+/).sort();
+  if (style)
+    Assert.equal(actualStyle.toString(), style.toString(), "Match should have expected style");
+  if (uri.spec.startsWith("moz-action:")) {
+    Assert.ok(actualStyle.includes("action"), "moz-action results should always have 'action' in their style");
+  }
+
+  if (match.icon)
+    Assert.equal(result.image, match.icon, "Match should have expected image");
+
+  return true;
+}
+
+function* check_autocomplete(test) {
+  // At this point frecency could still be updating due to latest pages
+  // updates.
+  // This is not a problem in real life, but autocomplete tests should
+  // return reliable resultsets, thus we have to wait.
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  // Make an AutoCompleteInput that uses our searches and confirms results.
+  let input = new AutoCompleteInput(["unifiedcomplete"]);
+  input.textValue = test.search;
+
+  if (test.searchParam)
+    input.searchParam = test.searchParam;
+
+  // Caret must be at the end for autoFill to happen.
+  let strLen = test.search.length;
+  input.selectTextRange(strLen, strLen);
+  Assert.equal(input.selectionStart, strLen, "Selection starts at end");
+  Assert.equal(input.selectionEnd, strLen, "Selection ends at the end");
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"]
+                     .getService(Ci.nsIAutoCompleteController);
+  controller.input = input;
+
+  let numSearchesStarted = 0;
+  input.onSearchBegin = () => {
+    do_print("onSearchBegin received");
+    numSearchesStarted++;
+  };
+  let searchCompletePromise = new Promise(resolve => {
+    input.onSearchComplete = () => {
+      do_print("onSearchComplete received");
+      resolve();
+    }
+  });
+  let expectedSearches = 1;
+  if (test.incompleteSearch) {
+    controller.startSearch(test.incompleteSearch);
+    expectedSearches++;
+  }
+
+  do_print("Searching for: '" + test.search + "'");
+  controller.startSearch(test.search);
+  yield searchCompletePromise;
+
+  Assert.equal(numSearchesStarted, expectedSearches, "All searches started");
+
+  // Check to see the expected uris and titles match up. If 'enable-actions'
+  // is specified, we check that the first specified match is the first
+  // controller value (as this is the "special" always selected item), but the
+  // rest can match in any order.
+  // If 'enable-actions' is not specified, they can match in any order.
+  if (test.matches) {
+    // Do not modify the test original matches.
+    let matches = test.matches.slice();
+
+    if (matches.length) {
+      let firstIndexToCheck = 0;
+      if (test.searchParam && test.searchParam.includes("enable-actions")) {
+        firstIndexToCheck = 1;
+        do_print("Checking first match is first autocomplete entry")
+        let result = {
+          value: controller.getValueAt(0),
+          comment: controller.getCommentAt(0),
+          style: controller.getStyleAt(0),
+          image: controller.getImageAt(0),
+        }
+        do_print(`First match is "${result.value}", "${result.comment}"`);
+        Assert.ok(_check_autocomplete_matches(matches[0], result), "first item is correct");
+        do_print("Checking rest of the matches");
+      }
+
+      for (let i = firstIndexToCheck; i < controller.matchCount; i++) {
+        let result = {
+          value: controller.getValueAt(i),
+          comment: controller.getCommentAt(i),
+          style: controller.getStyleAt(i),
+          image: controller.getImageAt(i),
+        }
+        do_print(`Looking for "${result.value}", "${result.comment}" in expected results...`);
+        let lowerBound = test.checkSorting ? i : firstIndexToCheck;
+        let upperBound = test.checkSorting ? i + 1 : matches.length;
+        let found = false;
+        for (let j = lowerBound; j < upperBound; ++j) {
+          // Skip processed expected results
+          if (matches[j] == undefined)
+            continue;
+          if (_check_autocomplete_matches(matches[j], result)) {
+            do_print("Got a match at index " + j + "!");
+            // Make it undefined so we don't process it again
+            matches[j] = undefined;
+            found = true;
+            break;
+          }
+        }
+
+        if (!found)
+          do_throw(`Didn't find the current result ("${result.value}", "${result.comment}") in matches`); // ' (Emacs syntax highlighting fix)
+      }
+    }
+
+    Assert.equal(controller.matchCount, matches.length,
+                 "Got as many results as expected");
+
+    // If we expect results, make sure we got matches.
+    do_check_eq(controller.searchStatus, matches.length ?
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH :
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH);
+  }
+
+  if (test.autofilled) {
+    // Check the autoFilled result.
+    Assert.equal(input.textValue, test.autofilled,
+                 "Autofilled value is correct");
+
+    // Now force completion and check correct casing of the result.
+    // This ensures the controller is able to do its magic case-preserving
+    // stuff and correct replacement of the user's casing with result's one.
+    controller.handleEnter(false);
+    Assert.equal(input.textValue, test.completed,
+                 "Completed value is correct");
+  }
+}
+
+var addBookmark = Task.async(function* (aBookmarkObj) {
+  Assert.ok(!!aBookmarkObj.uri, "Bookmark object contains an uri");
+  let parentId = aBookmarkObj.parentId ? aBookmarkObj.parentId
+                                       : PlacesUtils.unfiledBookmarksFolderId;
+
+  let bm = yield PlacesUtils.bookmarks.insert({
+    parentGuid: (yield PlacesUtils.promiseItemGuid(parentId)),
+    title: aBookmarkObj.title || "A bookmark",
+    url: aBookmarkObj.uri
+  });
+  yield PlacesUtils.promiseItemId(bm.guid);
+
+  if (aBookmarkObj.keyword) {
+    yield PlacesUtils.keywords.insert({ keyword: aBookmarkObj.keyword,
+                                        url: aBookmarkObj.uri.spec,
+                                        postData: aBookmarkObj.postData
+                                      });
+  }
+
+  if (aBookmarkObj.tags) {
+    PlacesUtils.tagging.tagURI(aBookmarkObj.uri, aBookmarkObj.tags);
+  }
+});
+
+function addOpenPages(aUri, aCount=1, aUserContextId=0) {
+  let ac = Cc["@mozilla.org/autocomplete/search;1?name=unifiedcomplete"]
+             .getService(Ci.mozIPlacesAutoComplete);
+  for (let i = 0; i < aCount; i++) {
+    ac.registerOpenPage(aUri, aUserContextId);
+  }
+}
+
+function removeOpenPages(aUri, aCount=1, aUserContextId=0) {
+  let ac = Cc["@mozilla.org/autocomplete/search;1?name=unifiedcomplete"]
+             .getService(Ci.mozIPlacesAutoComplete);
+  for (let i = 0; i < aCount; i++) {
+    ac.unregisterOpenPage(aUri, aUserContextId);
+  }
+}
+
+function changeRestrict(aType, aChar) {
+  let branch = "browser.urlbar.";
+  // "title" and "url" are different from everything else, so special case them.
+  if (aType == "title" || aType == "url")
+    branch += "match.";
+  else
+    branch += "restrict.";
+
+  do_print("changing restrict for " + aType + " to '" + aChar + "'");
+  Services.prefs.setCharPref(branch + aType, aChar);
+}
+
+function resetRestrict(aType) {
+  let branch = "browser.urlbar.";
+  // "title" and "url" are different from everything else, so special case them.
+  if (aType == "title" || aType == "url")
+    branch += "match.";
+  else
+    branch += "restrict.";
+
+  Services.prefs.clearUserPref(branch + aType);
+}
+
+/**
+ * Strip prefixes from the URI that we don't care about for searching.
+ *
+ * @param spec
+ *        The text to modify.
+ * @return the modified spec.
+ */
+function stripPrefix(spec)
+{
+  ["http://", "https://", "ftp://"].some(scheme => {
+    if (spec.startsWith(scheme)) {
+      spec = spec.slice(scheme.length);
+      return true;
+    }
+    return false;
+  });
+
+  if (spec.startsWith("www.")) {
+    spec = spec.slice(4);
+  }
+  return spec;
+}
+
+function makeActionURI(action, params) {
+  let encodedParams = {};
+  for (let key in params) {
+    encodedParams[key] = encodeURIComponent(params[key]);
+  }
+  let url = "moz-action:" + action + "," + JSON.stringify(encodedParams);
+  return NetUtil.newURI(url);
+}
+
+// Creates a full "match" entry for a search result, suitable for passing as
+// an entry to check_autocomplete.
+function makeSearchMatch(input, extra = {}) {
+  // Note that counter-intuitively, the order the object properties are defined
+  // in the object passed to makeActionURI is important for check_autocomplete
+  // to match them :(
+  let params = {
+    engineName: extra.engineName || "MozSearch",
+    input,
+    searchQuery: "searchQuery" in extra ? extra.searchQuery : input,
+  };
+  if ("alias" in extra) {
+    // May be undefined, which is expected, but in that case make sure it's not
+    // included in the params of the moz-action URL.
+    params.alias = extra.alias;
+  }
+  let style = [ "action", "searchengine" ];
+  if (Array.isArray(extra.style)) {
+    style.push(...extra.style);
+  }
+  if (extra.heuristic) {
+    style.push("heuristic");
+  }
+  return {
+    uri: makeActionURI("searchengine", params),
+    title: params.engineName,
+    style,
+  }
+}
+
+// Creates a full "match" entry for a search result, suitable for passing as
+// an entry to check_autocomplete.
+function makeVisitMatch(input, url, extra = {}) {
+  // Note that counter-intuitively, the order the object properties are defined
+  // in the object passed to makeActionURI is important for check_autocomplete
+  // to match them :(
+  let params = {
+    url,
+    input,
+  }
+  let style = [ "action", "visiturl" ];
+  if (extra.heuristic) {
+    style.push("heuristic");
+  }
+  return {
+    uri: makeActionURI("visiturl", params),
+    title: extra.title || url,
+    style,
+  }
+}
+
+function makeSwitchToTabMatch(url, extra = {}) {
+  return {
+    uri: makeActionURI("switchtab", {url}),
+    title: extra.title || url,
+    style: [ "action", "switchtab" ],
+  }
+}
+
+function makeExtensionMatch(extra = {}) {
+  let style = [ "action", "extension" ];
+  if (extra.heuristic) {
+    style.push("heuristic");
+  }
+
+  return {
+    uri: makeActionURI("extension", {
+      content: extra.content,
+      keyword: extra.keyword,
+    }),
+    title: extra.description,
+    style,
+  };
+}
+
+function setFaviconForHref(href, iconHref) {
+  return new Promise(resolve => {
+    PlacesUtils.favicons.setAndFetchFaviconForPage(
+      NetUtil.newURI(href),
+      NetUtil.newURI(iconHref),
+      true,
+      PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+      resolve,
+      Services.scriptSecurityManager.getSystemPrincipal()
+    );
+  });
+}
+
+function makeTestServer(port=-1) {
+  let httpServer = new HttpServer();
+  httpServer.start(port);
+  do_register_cleanup(() => httpServer.stop(() => {}));
+  return httpServer;
+}
+
+function* addTestEngine(basename, httpServer=undefined) {
+  httpServer = httpServer || makeTestServer();
+  httpServer.registerDirectory("/", do_get_cwd());
+  let dataUrl =
+    "http://localhost:" + httpServer.identity.primaryPort + "/data/";
+
+  do_print("Adding engine: " + basename);
+  return yield new Promise(resolve => {
+    Services.obs.addObserver(function obs(subject, topic, data) {
+      let engine = subject.QueryInterface(Ci.nsISearchEngine);
+      do_print("Observed " + data + " for " + engine.name);
+      if (data != "engine-added" || engine.name != basename) {
+        return;
+      }
+
+      Services.obs.removeObserver(obs, "browser-search-engine-modified");
+      do_register_cleanup(() => Services.search.removeEngine(engine));
+      resolve(engine);
+    }, "browser-search-engine-modified", false);
+
+    do_print("Adding engine from URL: " + dataUrl + basename);
+    Services.search.addEngine(dataUrl + basename, null, null, false);
+  });
+}
+
+// Ensure we have a default search engine and the keyword.enabled preference
+// set.
+add_task(function* ensure_search_engine() {
+  // keyword.enabled is necessary for the tests to see keyword searches.
+  Services.prefs.setBoolPref("keyword.enabled", true);
+
+  // Initialize the search service, but first set this geo IP pref to a dummy
+  // string.  When the search service is initialized, it contacts the URI named
+  // in this pref, which breaks the test since outside connections aren't
+  // allowed.
+  let geoPref = "browser.search.geoip.url";
+  Services.prefs.setCharPref(geoPref, "");
+  do_register_cleanup(() => Services.prefs.clearUserPref(geoPref));
+  yield new Promise(resolve => {
+    Services.search.init(resolve);
+  });
+
+  // Remove any existing engines before adding ours.
+  for (let engine of Services.search.getEngines()) {
+    Services.search.removeEngine(engine);
+  }
+  Services.search.addEngineWithDetails("MozSearch", "", "", "", "GET",
+                                       "http://s.example.com/search");
+  let engine = Services.search.getEngineByName("MozSearch");
+  Services.search.currentEngine = engine;
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_416211.js b/toolkit/components/places/tests/unifiedcomplete/test_416211.js
new file mode 100644
index 000000000..e02906ddc
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_416211.js
@@ -0,0 +1,22 @@
+/* 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/. */
+
+/*
+ * Test bug 416211 to make sure results that match the tag show the bookmark
+ * title instead of the page title.
+ */
+
+add_task(function* test_tag_match_has_bookmark_title() {
+  do_print("Make sure the tag match gives the bookmark title");
+  let uri = NetUtil.newURI("http://theuri/");
+  yield PlacesTestUtils.addVisits({ uri: uri, title: "Page title" });
+  yield addBookmark({ uri: uri,
+                      title: "Bookmark title",
+                      tags: [ "superTag" ]});
+  yield check_autocomplete({
+    search: "superTag",
+    matches: [ { uri: uri, title: "Bookmark title", tags: [ "superTag" ], style: [ "bookmark-tag" ] } ]
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_416214.js b/toolkit/components/places/tests/unifiedcomplete/test_416214.js
new file mode 100644
index 000000000..a30b3fe74
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_416214.js
@@ -0,0 +1,39 @@
+/* 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/. */
+
+/*
+ * Test autocomplete for non-English URLs that match the tag bug 416214. Also
+ * test bug 417441 by making sure escaped ascii characters like "+" remain
+ * escaped.
+ *
+ * - add a visit for a page with a non-English URL
+ * - add a tag for the page
+ * - search for the tag
+ * - test number of matches (should be exactly one)
+ * - make sure the url is decoded
+ */
+
+add_task(function* test_tag_match_url() {
+  do_print("Make sure tag matches return the right url as well as '+' remain escaped");
+  let uri1 = NetUtil.newURI("http://escaped/ユニコード");
+  let uri2 = NetUtil.newURI("http://asciiescaped/blocking-firefox3%2B");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "title" },
+    { uri: uri2, title: "title" }
+  ]);
+  yield addBookmark({ uri: uri1,
+                      title: "title",
+                      tags: [ "superTag" ],
+                      style: [ "bookmark-tag" ] });
+  yield addBookmark({ uri: uri2,
+                      title: "title",
+                      tags: [ "superTag" ],
+                      style: [ "bookmark-tag" ] });
+  yield check_autocomplete({
+    search: "superTag",
+    matches: [ { uri: uri1, title: "title", tags: [ "superTag" ], style: [ "bookmark-tag" ] },
+               { uri: uri2, title: "title", tags: [ "superTag" ], style: [ "bookmark-tag" ] } ]
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_417798.js b/toolkit/components/places/tests/unifiedcomplete/test_417798.js
new file mode 100644
index 000000000..bed14b2ce
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_417798.js
@@ -0,0 +1,51 @@
+/* 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/. */
+
+/**
+ * Test for bug 417798 to make sure javascript: URIs don't show up unless the
+ * user searches for javascript: explicitly.
+ */
+
+add_task(function* test_javascript_match() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", false);
+
+  let uri1 = NetUtil.newURI("http://abc/def");
+  let uri2 = NetUtil.newURI("javascript:5");
+  yield PlacesTestUtils.addVisits([ { uri: uri1, title: "Title with javascript:" } ]);
+  yield addBookmark({ uri: uri2,
+                      title: "Title with javascript:" });
+
+  do_print("Match non-javascript: with plain search");
+  yield check_autocomplete({
+    search: "a",
+    matches: [ { uri: uri1, title: "Title with javascript:" } ]
+  });
+
+  do_print("Match non-javascript: with almost javascript:");
+  yield check_autocomplete({
+    search: "javascript",
+    matches: [ { uri: uri1, title: "Title with javascript:" } ]
+  });
+
+  do_print("Match javascript:");
+  yield check_autocomplete({
+    search: "javascript:",
+    matches: [ { uri: uri1, title: "Title with javascript:" },
+               { uri: uri2, title: "Title with javascript:", style: [ "bookmark" ]} ]
+  });
+
+  do_print("Match nothing with non-first javascript:");
+  yield check_autocomplete({
+    search: "5 javascript:",
+    matches: [ ]
+  });
+
+  do_print("Match javascript: with multi-word search");
+  yield check_autocomplete({
+    search: "javascript: 5",
+    matches: [ { uri: uri2, title: "Title with javascript:", style: [ "bookmark" ]} ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_418257.js b/toolkit/components/places/tests/unifiedcomplete/test_418257.js
new file mode 100644
index 000000000..323c2a7af
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_418257.js
@@ -0,0 +1,67 @@
+/* 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/. */
+
+/**
+ * Test bug 418257 by making sure tags are returned with the title as part of
+ * the "comment" if there are tags even if we didn't match in the tags. They
+ * are separated from the title by a endash.
+ */
+
+add_task(function* test_javascript_match() {
+  let uri1 = NetUtil.newURI("http://page1");
+  let uri2 = NetUtil.newURI("http://page2");
+  let uri3 = NetUtil.newURI("http://page3");
+  let uri4 = NetUtil.newURI("http://page4");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "tagged" },
+    { uri: uri2, title: "tagged" },
+    { uri: uri3, title: "tagged" },
+    { uri: uri4, title: "tagged" }
+  ]);
+  yield addBookmark({ uri: uri1,
+                      title: "tagged",
+                      tags: [ "tag1" ] });
+  yield addBookmark({ uri: uri2,
+                      title: "tagged",
+                      tags: [ "tag1", "tag2" ] });
+  yield addBookmark({ uri: uri3,
+                      title: "tagged",
+                      tags: [ "tag1", "tag3" ] });
+  yield addBookmark({ uri: uri4,
+                      title: "tagged",
+                      tags: [ "tag1", "tag2", "tag3" ] });
+
+  do_print("Make sure tags come back in the title when matching tags");
+  yield check_autocomplete({
+    search: "page1 tag",
+    matches: [ { uri: uri1, title: "tagged", tags: [ "tag1" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("Check tags in title for page2");
+  yield check_autocomplete({
+    search: "page2 tag",
+    matches: [ { uri: uri2, title: "tagged", tags: [ "tag1", "tag2" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("Make sure tags appear even when not matching the tag");
+  yield check_autocomplete({
+    search: "page3",
+    matches: [ { uri: uri3, title: "tagged", tags: [ "tag1", "tag3" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("Multiple tags come in commas for page4");
+  yield check_autocomplete({
+    search: "page4",
+    matches: [ { uri: uri4, title: "tagged", tags: [ "tag1", "tag2", "tag3" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("Extra test just to make sure we match the title");
+  yield check_autocomplete({
+    search: "tag2",
+    matches: [ { uri: uri2, title: "tagged", tags: [ "tag1", "tag2" ], style: [ "bookmark-tag" ] },
+               { uri: uri4, title: "tagged", tags: [ "tag1", "tag2", "tag3" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_422277.js b/toolkit/components/places/tests/unifiedcomplete/test_422277.js
new file mode 100644
index 000000000..df6f7601a
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_422277.js
@@ -0,0 +1,19 @@
+/* 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/. */
+
+/**
+ * Test bug 422277 to make sure bad escaped uris don't get escaped. This makes
+ * sure we don't hit an assertion for "not a UTF8 string".
+ */
+
+add_task(function* test_javascript_match() {
+  do_print("Bad escaped uri stays escaped");
+  let uri1 = NetUtil.newURI("http://site/%EAid");
+  yield PlacesTestUtils.addVisits([ { uri: uri1, title: "title" } ]);
+  yield check_autocomplete({
+    search: "site",
+    matches: [ { uri: uri1, title: "title" } ]
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_autocomplete_functional.js b/toolkit/components/places/tests/unifiedcomplete/test_autocomplete_functional.js
new file mode 100644
index 000000000..cd2dfdb17
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_autocomplete_functional.js
@@ -0,0 +1,171 @@
+/* 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/. */
+
+// Functional tests for inline autocomplete
+
+const PREF_AUTOCOMPLETE_ENABLED = "browser.urlbar.autocomplete.enabled";
+
+add_task(function* test_disabling_autocomplete() {
+  do_print("Check disabling autocomplete disables autofill");
+  Services.prefs.setBoolPref(PREF_AUTOCOMPLETE_ENABLED, false);
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://visit.mozilla.org"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "vis",
+    autofilled: "vis",
+    completed: "vis"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_urls_order() {
+  do_print("Add urls, check for correct order");
+  let places = [{ uri: NetUtil.newURI("http://visit1.mozilla.org") },
+                { uri: NetUtil.newURI("http://visit2.mozilla.org"),
+                  transition: TRANSITION_TYPED }];
+  yield PlacesTestUtils.addVisits(places);
+  yield check_autocomplete({
+    search: "vis",
+    autofilled: "visit2.mozilla.org/",
+    completed: "visit2.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_ignore_prefix() {
+  do_print("Add urls, make sure www and http are ignored");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://www.visit1.mozilla.org"));
+  yield check_autocomplete({
+    search: "visit1",
+    autofilled: "visit1.mozilla.org/",
+    completed: "visit1.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_after_host() {
+  do_print("Autocompleting after an existing host completes to the url");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://www.visit3.mozilla.org"));
+  yield check_autocomplete({
+    search: "visit3.mozilla.org/",
+    autofilled: "visit3.mozilla.org/",
+    completed: "visit3.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_respect_www() {
+  do_print("Searching for www.me should yield www.me.mozilla.org/");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://www.me.mozilla.org"));
+  yield check_autocomplete({
+    search: "www.me",
+    autofilled: "www.me.mozilla.org/",
+    completed: "www.me.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_bookmark_first() {
+  do_print("With a bookmark and history, the query result should be the bookmark");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield addBookmark({ uri: NetUtil.newURI("http://bookmark1.mozilla.org/") });
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://bookmark1.mozilla.org/foo"));
+  yield check_autocomplete({
+    search: "bookmark",
+    autofilled: "bookmark1.mozilla.org/",
+    completed: "bookmark1.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_full_path() {
+  do_print("Check to make sure we get the proper results with full paths");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  let places = [{ uri: NetUtil.newURI("http://smokey.mozilla.org/foo/bar/baz?bacon=delicious") },
+                { uri: NetUtil.newURI("http://smokey.mozilla.org/foo/bar/baz?bacon=smokey") }];
+  yield PlacesTestUtils.addVisits(places);
+  yield check_autocomplete({
+    search: "smokey",
+    autofilled: "smokey.mozilla.org/",
+    completed: "smokey.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_complete_to_slash() {
+  do_print("Check to make sure we autocomplete to the following '/'");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  let places = [{ uri: NetUtil.newURI("http://smokey.mozilla.org/foo/bar/baz?bacon=delicious") },
+                { uri: NetUtil.newURI("http://smokey.mozilla.org/foo/bar/baz?bacon=smokey") }];
+  yield PlacesTestUtils.addVisits(places);
+  yield check_autocomplete({
+    search: "smokey.mozilla.org/fo",
+    autofilled: "smokey.mozilla.org/foo/",
+    completed: "http://smokey.mozilla.org/foo/",
+  });
+  yield cleanup();
+});
+
+add_task(function* test_complete_to_slash_with_www() {
+  do_print("Check to make sure we autocomplete to the following '/'");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  let places = [{ uri: NetUtil.newURI("http://www.smokey.mozilla.org/foo/bar/baz?bacon=delicious") },
+                { uri: NetUtil.newURI("http://www.smokey.mozilla.org/foo/bar/baz?bacon=smokey") }];
+  yield PlacesTestUtils.addVisits(places);
+  yield check_autocomplete({
+    search: "smokey.mozilla.org/fo",
+    autofilled: "smokey.mozilla.org/foo/",
+    completed: "http://www.smokey.mozilla.org/foo/",
+  });
+  yield cleanup();
+});
+
+add_task(function* test_complete_querystring() {
+  do_print("Check to make sure we autocomplete after ?");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://smokey.mozilla.org/foo?bacon=delicious"));
+  yield check_autocomplete({
+    search: "smokey.mozilla.org/foo?",
+    autofilled: "smokey.mozilla.org/foo?bacon=delicious",
+    completed: "http://smokey.mozilla.org/foo?bacon=delicious",
+  });
+  yield cleanup();
+});
+
+add_task(function* test_complete_fragment() {
+  do_print("Check to make sure we autocomplete after #");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://smokey.mozilla.org/foo?bacon=delicious#bar"));
+  yield check_autocomplete({
+    search: "smokey.mozilla.org/foo?bacon=delicious#bar",
+    autofilled: "smokey.mozilla.org/foo?bacon=delicious#bar",
+    completed: "http://smokey.mozilla.org/foo?bacon=delicious#bar",
+  });
+  yield cleanup();
+});
+
+add_task(function* test_autocomplete_enabled_pref() {
+  Services.prefs.setBoolPref(PREF_AUTOCOMPLETE_ENABLED, false);
+  let types = ["history", "bookmark", "openpage"];
+  for (type of types) {
+    do_check_eq(Services.prefs.getBoolPref("browser.urlbar.suggest." + type), false,
+                "suggest." + type + "pref should be false");
+  }
+  Services.prefs.setBoolPref(PREF_AUTOCOMPLETE_ENABLED, true);
+  for (type of types) {
+    do_check_eq(Services.prefs.getBoolPref("browser.urlbar.suggest." + type), true,
+                "suggest." + type + "pref should be true");
+  }
+
+  // Clear prefs.
+  Services.prefs.clearUserPref(PREF_AUTOCOMPLETE_ENABLED);
+  for (type of types) {
+    Services.prefs.clearUserPref("browser.urlbar.suggest." + type);
+  }
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_autocomplete_on_value_removed_479089.js b/toolkit/components/places/tests/unifiedcomplete/test_autocomplete_on_value_removed_479089.js
new file mode 100644
index 000000000..ecc96266b
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_autocomplete_on_value_removed_479089.js
@@ -0,0 +1,39 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/*
+ * Need to test that removing a page from autocomplete actually removes a page
+ * Description From  Shawn Wilsher :sdwilsh   2009-02-18 11:29:06 PST
+ * We don't test the code path of onValueRemoved
+ * for the autocomplete implementation
+ * Bug 479089
+ */
+
+add_task(function* test_autocomplete_on_value_removed() {
+  let listener = Cc["@mozilla.org/autocomplete/search;1?name=unifiedcomplete"].
+                 getService(Components.interfaces.nsIAutoCompleteSimpleResultListener);
+
+  let testUri = NetUtil.newURI("http://foo.mozilla.com/");
+  yield PlacesTestUtils.addVisits({
+    uri: testUri,
+    referrer: uri("http://mozilla.com/")
+  });
+
+  let query = PlacesUtils.history.getNewQuery();
+  let options = PlacesUtils.history.getNewQueryOptions();
+  // look for this uri only
+  query.uri = testUri;
+
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  Assert.equal(root.childCount, 1);
+  // call the untested code path
+  listener.onValueRemoved(null, testUri.spec, true);
+  // make sure it is GONE from the DB
+  Assert.equal(root.childCount, 0);
+  // close the container
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_autofill_default_behavior.js b/toolkit/components/places/tests/unifiedcomplete/test_autofill_default_behavior.js
new file mode 100644
index 000000000..482fcf485
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_autofill_default_behavior.js
@@ -0,0 +1,310 @@
+/* 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/. */
+
+/**
+ * Test autoFill for different default behaviors.
+ */
+
+add_task(function* test_default_behavior_host() {
+  let uri1 = NetUtil.newURI("http://typed/");
+  let uri2 = NetUtil.newURI("http://visited/");
+  let uri3 = NetUtil.newURI("http://bookmarked/");
+  let uri4 = NetUtil.newURI("http://tpbk/");
+  let uri5 = NetUtil.newURI("http://tagged/");
+
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "typed", transition: TRANSITION_TYPED },
+    { uri: uri2, title: "visited" },
+    { uri: uri4, title: "tpbk", transition: TRANSITION_TYPED },
+  ]);
+  yield addBookmark( { uri: uri3, title: "bookmarked" } );
+  yield addBookmark( { uri: uri4, title: "tpbk" } );
+  yield addBookmark( { uri: uri5, title: "title", tags: ["foo"] } );
+
+  yield setFaviconForHref(uri1.spec, "chrome://global/skin/icons/information-16.png");
+  yield setFaviconForHref(uri3.spec, "chrome://global/skin/icons/error-16.png");
+
+  // RESTRICT TO HISTORY.
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", true);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history.onlyTyped", false);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", false);
+
+  do_print("Restrict history, common visit, should not autoFill");
+  yield check_autocomplete({
+    search: "vi",
+    matches: [ { uri: uri2, title: "visited" } ],
+    autofilled: "vi",
+    completed: "vi"
+  });
+
+  do_print("Restrict history, typed visit, should autoFill");
+  yield check_autocomplete({
+    search: "ty",
+    matches: [ { uri: uri1, title: "typed", style: [ "autofill", "heuristic" ],
+                 icon: "chrome://global/skin/icons/information-16.png" } ],
+    autofilled: "typed/",
+    completed: "typed/"
+  });
+
+  // Don't autoFill this one cause it's not typed.
+  do_print("Restrict history, bookmark, should not autoFill");
+  yield check_autocomplete({
+    search: "bo",
+    matches: [ ],
+    autofilled: "bo",
+    completed: "bo"
+  });
+
+  // Note we don't show this one cause it's not typed.
+  do_print("Restrict history, typed bookmark, should autoFill");
+  yield check_autocomplete({
+    search: "tp",
+    matches: [ { uri: uri4, title: "tpbk", style: [ "autofill", "heuristic" ] } ],
+    autofilled: "tpbk/",
+    completed: "tpbk/"
+  });
+
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+
+  // We are not restricting on typed, so we autoFill the bookmark even if we
+  // are restricted to history.  We accept that cause not doing that
+  // would be a perf hit and the privacy implications are very weak.
+  do_print("Restrict history, bookmark, autoFill.typed = false, should autoFill");
+  yield check_autocomplete({
+    search: "bo",
+    matches: [ { uri: uri3, title: "bookmarked", style: [ "autofill", "heuristic" ],
+                 icon: "chrome://global/skin/icons/error-16.png" } ],
+    autofilled: "bookmarked/",
+    completed: "bookmarked/"
+  });
+
+  do_print("Restrict history, common visit, autoFill.typed = false, should autoFill");
+  yield check_autocomplete({
+    search: "vi",
+    matches: [ { uri: uri2, title: "visited", style: [ "autofill", "heuristic" ] } ],
+    autofilled: "visited/",
+    completed: "visited/"
+  });
+
+  // RESTRICT TO TYPED.
+  // This should basically ignore autoFill.typed and acts as if it would be set.
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history.onlyTyped", true);
+
+  // Typed behavior basically acts like history, but filters on typed.
+  do_print("Restrict typed, common visit, autoFill.typed = false, should not autoFill");
+  yield check_autocomplete({
+    search: "vi",
+    matches: [ ],
+    autofilled: "vi",
+    completed: "vi"
+  });
+
+  do_print("Restrict typed, typed visit, autofill.typed = false, should autoFill");
+  yield check_autocomplete({
+    search: "ty",
+    matches: [ { uri: uri1, title: "typed", style: [ "autofill", "heuristic" ],
+                 icon: "chrome://global/skin/icons/information-16.png"} ],
+    autofilled: "typed/",
+    completed: "typed/"
+  });
+
+  do_print("Restrict typed, bookmark, autofill.typed = false, should not autoFill");
+  yield check_autocomplete({
+    search: "bo",
+    matches: [ ],
+    autofilled: "bo",
+    completed: "bo"
+  });
+
+  do_print("Restrict typed, typed bookmark, autofill.typed = false, should autoFill");
+  yield check_autocomplete({
+    search: "tp",
+    matches: [ { uri: uri4, title: "tpbk", style: [ "autofill", "heuristic" ] } ],
+    autofilled: "tpbk/",
+    completed: "tpbk/"
+  });
+
+  // RESTRICT BOOKMARKS.
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", false);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", true);
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", true);
+
+  do_print("Restrict bookmarks, common visit, should not autoFill");
+  yield check_autocomplete({
+    search: "vi",
+    matches: [ ],
+    autofilled: "vi",
+    completed: "vi"
+  });
+
+  do_print("Restrict bookmarks, typed visit, should not autoFill");
+  yield check_autocomplete({
+    search: "ty",
+    matches: [ ],
+    autofilled: "ty",
+    completed: "ty"
+  });
+
+  // Don't autoFill this one cause it's not typed.
+  do_print("Restrict bookmarks, bookmark, should not autoFill");
+  yield check_autocomplete({
+    search: "bo",
+    matches: [ { uri: uri3, title: "bookmarked", style: [ "bookmark" ],
+                 icon: "chrome://global/skin/icons/error-16.png"} ],
+    autofilled: "bo",
+    completed: "bo"
+  });
+
+  // Note we don't show this one cause it's not typed.
+  do_print("Restrict bookmarks, typed bookmark, should autoFill");
+  yield check_autocomplete({
+    search: "tp",
+    matches: [ { uri: uri4, title: "tpbk", style: [ "autofill", "heuristic" ] } ],
+    autofilled: "tpbk/",
+    completed: "tpbk/"
+  });
+
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+
+  do_print("Restrict bookmarks, bookmark, autofill.typed = false, should autoFill");
+  yield check_autocomplete({
+    search: "bo",
+    matches: [ { uri: uri3, title: "bookmarked", style: [ "autofill", "heuristic" ],
+                 icon: "chrome://global/skin/icons/error-16.png" } ],
+    autofilled: "bookmarked/",
+    completed: "bookmarked/"
+  });
+
+  // Don't autofill because it's a title.
+  do_print("Restrict bookmarks, title, autofill.typed = false, should not autoFill");
+  yield check_autocomplete({
+    search: "# ta",
+    matches: [ ],
+    autofilled: "# ta",
+    completed: "# ta"
+  });
+
+  // Don't autofill because it's a tag.
+  do_print("Restrict bookmarks, tag, autofill.typed = false, should not autoFill");
+  yield check_autocomplete({
+    search: "+ ta",
+    matches: [ { uri: uri5, title: "title", tags: [ "foo" ], style: [ "tag" ] } ],
+    autofilled: "+ ta",
+    completed: "+ ta"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_default_behavior_url() {
+  let uri1 = NetUtil.newURI("http://typed/ty/");
+  let uri2 = NetUtil.newURI("http://visited/vi/");
+  let uri3 = NetUtil.newURI("http://bookmarked/bo/");
+  let uri4 = NetUtil.newURI("http://tpbk/tp/");
+
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "typed", transition: TRANSITION_TYPED },
+    { uri: uri2, title: "visited" },
+    { uri: uri4, title: "tpbk", transition: TRANSITION_TYPED },
+  ]);
+  yield addBookmark( { uri: uri3, title: "bookmarked" } );
+  yield addBookmark( { uri: uri4, title: "tpbk" } );
+
+  yield setFaviconForHref(uri1.spec, "chrome://global/skin/icons/information-16.png");
+  yield setFaviconForHref(uri3.spec, "chrome://global/skin/icons/error-16.png");
+
+  // RESTRICT TO HISTORY.
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", true);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history.onlyTyped", false);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", false);
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", true);
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", false);
+
+  do_print("URL: Restrict history, common visit, should not autoFill");
+  yield check_autocomplete({
+    search: "visited/v",
+    matches: [ { uri: uri2, title: "visited" } ],
+    autofilled: "visited/v",
+    completed: "visited/v"
+  });
+
+  do_print("URL: Restrict history, typed visit, should autoFill");
+  yield check_autocomplete({
+    search: "typed/t",
+    matches: [ { uri: uri1, title: "typed/ty/", style: [ "autofill", "heuristic" ],
+                 icon: "chrome://global/skin/icons/information-16.png"} ],
+    autofilled: "typed/ty/",
+    completed: "http://typed/ty/"
+  });
+
+  // Don't autoFill this one cause it's not typed.
+  do_print("URL: Restrict history, bookmark, should not autoFill");
+  yield check_autocomplete({
+    search: "bookmarked/b",
+    matches: [ ],
+    autofilled: "bookmarked/b",
+    completed: "bookmarked/b"
+  });
+
+  // Note we don't show this one cause it's not typed.
+  do_print("URL: Restrict history, typed bookmark, should autoFill");
+  yield check_autocomplete({
+    search: "tpbk/t",
+    matches: [ { uri: uri4, title: "tpbk/tp/", style: [ "autofill", "heuristic" ] } ],
+    autofilled: "tpbk/tp/",
+    completed: "http://tpbk/tp/"
+  });
+
+  // RESTRICT BOOKMARKS.
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", false);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", true);
+
+  do_print("URL: Restrict bookmarks, common visit, should not autoFill");
+  yield check_autocomplete({
+    search: "visited/v",
+    matches: [ ],
+    autofilled: "visited/v",
+    completed: "visited/v"
+  });
+
+  do_print("URL: Restrict bookmarks, typed visit, should not autoFill");
+  yield check_autocomplete({
+    search: "typed/t",
+    matches: [ ],
+    autofilled: "typed/t",
+    completed: "typed/t"
+  });
+
+  // Don't autoFill this one cause it's not typed.
+  do_print("URL: Restrict bookmarks, bookmark, should not autoFill");
+  yield check_autocomplete({
+    search: "bookmarked/b",
+    matches: [ { uri: uri3, title: "bookmarked", style: [ "bookmark" ],
+                 icon: "chrome://global/skin/icons/error-16.png" } ],
+    autofilled: "bookmarked/b",
+    completed: "bookmarked/b"
+  });
+
+  // Note we don't show this one cause it's not typed.
+  do_print("URL: Restrict bookmarks, typed bookmark, should autoFill");
+  yield check_autocomplete({
+    search: "tpbk/t",
+    matches: [ { uri: uri4, title: "tpbk/tp/", style: [ "autofill", "heuristic" ] } ],
+    autofilled: "tpbk/tp/",
+    completed: "http://tpbk/tp/"
+  });
+
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+
+  do_print("URL: Restrict bookmarks, bookmark, autofill.typed = false, should autoFill");
+  yield check_autocomplete({
+    search: "bookmarked/b",
+    matches: [ { uri: uri3, title: "bookmarked/bo/", style: [ "autofill", "heuristic" ],
+                 icon: "chrome://global/skin/icons/error-16.png" } ],
+    autofilled: "bookmarked/bo/",
+    completed: "http://bookmarked/bo/"
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_avoid_middle_complete.js b/toolkit/components/places/tests/unifiedcomplete/test_avoid_middle_complete.js
new file mode 100644
index 000000000..54fc343ca
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_avoid_middle_complete.js
@@ -0,0 +1,179 @@
+/* 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/. */
+
+add_task(function* test_prefix_space_noautofill() {
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://moz.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+
+  do_print("Should not try to autoFill if search string contains a space");
+  yield check_autocomplete({
+    search: " mo",
+    autofilled: " mo",
+    completed: " mo"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_trailing_space_noautofill() {
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://moz.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+
+  do_print("Should not try to autoFill if search string contains a space");
+  yield check_autocomplete({
+    search: "mo ",
+    autofilled: "mo ",
+    completed: "mo "
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_searchEngine_autofill() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", true);
+  Services.search.addEngineWithDetails("CakeSearch", "", "", "",
+                                       "GET", "http://cake.search/");
+  let engine = Services.search.getEngineByName("CakeSearch");
+  engine.addParam("q", "{searchTerms}", null);
+  do_register_cleanup(() => Services.search.removeEngine(engine));
+
+  do_print("Should autoFill search engine if search string does not contains a space");
+  yield check_autocomplete({
+    search: "ca",
+    autofilled: "cake.search",
+    completed: "http://cake.search"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_searchEngine_prefix_space_noautofill() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", true);
+  Services.search.addEngineWithDetails("CupcakeSearch", "", "", "",
+                                       "GET", "http://cupcake.search/");
+  let engine = Services.search.getEngineByName("CupcakeSearch");
+  engine.addParam("q", "{searchTerms}", null);
+  do_register_cleanup(() => Services.search.removeEngine(engine));
+
+  do_print("Should not try to autoFill search engine if search string contains a space");
+  yield check_autocomplete({
+    search: " cu",
+    autofilled: " cu",
+    completed: " cu"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_searchEngine_trailing_space_noautofill() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", true);
+  Services.search.addEngineWithDetails("BaconSearch", "", "", "",
+                                       "GET", "http://bacon.search/");
+  let engine = Services.search.getEngineByName("BaconSearch");
+  engine.addParam("q", "{searchTerms}", null);
+  do_register_cleanup(() => Services.search.removeEngine(engine));
+
+  do_print("Should not try to autoFill search engine if search string contains a space");
+  yield check_autocomplete({
+    search: "ba ",
+    autofilled: "ba ",
+    completed: "ba "
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_searchEngine_www_noautofill() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", true);
+  Services.search.addEngineWithDetails("HamSearch", "", "", "",
+                                       "GET", "http://ham.search/");
+  let engine = Services.search.getEngineByName("HamSearch");
+  engine.addParam("q", "{searchTerms}", null);
+  do_register_cleanup(() => Services.search.removeEngine(engine));
+
+  do_print("Should not autoFill search engine if search string contains www. but engine doesn't");
+  yield check_autocomplete({
+    search: "www.ham",
+    autofilled: "www.ham",
+    completed: "www.ham"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_searchEngine_different_scheme_noautofill() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", true);
+  Services.search.addEngineWithDetails("PieSearch", "", "", "",
+                                       "GET", "https://pie.search/");
+  let engine = Services.search.getEngineByName("PieSearch");
+  engine.addParam("q", "{searchTerms}", null);
+  do_register_cleanup(() => Services.search.removeEngine(engine));
+
+  do_print("Should not autoFill search engine if search string has a different scheme.");
+  yield check_autocomplete({
+    search: "http://pie",
+    autofilled: "http://pie",
+    completed: "http://pie"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_searchEngine_matching_prefix_autofill() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", true);
+  Services.search.addEngineWithDetails("BeanSearch", "", "", "",
+                                       "GET", "http://www.bean.search/");
+  let engine = Services.search.getEngineByName("BeanSearch");
+  engine.addParam("q", "{searchTerms}", null);
+  do_register_cleanup(() => Services.search.removeEngine(engine));
+
+
+  do_print("Should autoFill search engine if search string has matching prefix.");
+  yield check_autocomplete({
+    search: "http://www.be",
+    autofilled: "http://www.bean.search",
+    completed: "http://www.bean.search"
+  })
+
+  do_print("Should autoFill search engine if search string has www prefix.");
+  yield check_autocomplete({
+    search: "www.be",
+    autofilled: "www.bean.search",
+    completed: "http://www.bean.search"
+  });
+
+  do_print("Should autoFill search engine if search string has matching scheme.");
+  yield check_autocomplete({
+    search: "http://be",
+    autofilled: "http://bean.search",
+    completed: "http://www.bean.search"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_prefix_autofill() {
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://moz.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+
+  do_print("Should not try to autoFill in-the-middle if a search is canceled immediately");
+  yield check_autocomplete({
+    incompleteSearch: "moz",
+    search: "mozi",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/"
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_avoid_stripping_to_empty_tokens.js b/toolkit/components/places/tests/unifiedcomplete/test_avoid_stripping_to_empty_tokens.js
new file mode 100644
index 000000000..1fcfe1c75
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_avoid_stripping_to_empty_tokens.js
@@ -0,0 +1,41 @@
+/* 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/. */
+
+add_task(function* test_protocol_trimming() {
+  for (let prot of ["http", "https", "ftp"]) {
+    let visit = {
+      // Include the protocol in the query string to ensure we get matches (see bug 1059395)
+      uri: NetUtil.newURI(prot + "://www.mozilla.org/test/?q=" + prot + encodeURIComponent("://") + "www.foo"),
+      title: "Test title",
+      transition: TRANSITION_TYPED
+    };
+    yield PlacesTestUtils.addVisits(visit);
+    let matches = [{uri: visit.uri, title: visit.title}];
+
+    let inputs = [
+      prot + "://",
+      prot + ":// ",
+      prot + ":// mo",
+      prot + "://mo te",
+      prot + "://www.",
+      prot + "://www. ",
+      prot + "://www. mo",
+      prot + "://www.mo te",
+      "www.",
+      "www. ",
+      "www. mo",
+      "www.mo te"
+    ];
+    for (let input of inputs) {
+      do_print("Searching for: " + input);
+      yield check_autocomplete({
+        search: input,
+        matches: matches
+      });
+    }
+
+    yield cleanup();
+  }
+});
+
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_casing.js b/toolkit/components/places/tests/unifiedcomplete/test_casing.js
new file mode 100644
index 000000000..585b51be1
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_casing.js
@@ -0,0 +1,157 @@
+/* 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/. */
+
+add_task(function* test_casing_1() {
+  do_print("Searching for cased entry 1");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "MOZ",
+    autofilled: "MOZilla.org/",
+    completed: "mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_casing_2() {
+  do_print("Searching for cased entry 2");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/T",
+    autofilled: "mozilla.org/T",
+    completed: "mozilla.org/T"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_casing_3() {
+  do_print("Searching for cased entry 3");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/T",
+    autofilled: "mozilla.org/Test/",
+    completed: "http://mozilla.org/Test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_casing_4() {
+  do_print("Searching for cased entry 4");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mOzilla.org/t",
+    autofilled: "mOzilla.org/t",
+    completed: "mOzilla.org/t"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_casing_5() {
+  do_print("Searching for cased entry 5");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mOzilla.org/T",
+    autofilled: "mOzilla.org/Test/",
+    completed: "http://mozilla.org/Test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_casing() {
+  do_print("Searching for untrimmed cased entry");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "http://mOz",
+    autofilled: "http://mOzilla.org/",
+    completed: "http://mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_www_casing() {
+  do_print("Searching for untrimmed cased entry with www");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://www.mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "http://www.mOz",
+    autofilled: "http://www.mOzilla.org/",
+    completed: "http://www.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_path_casing() {
+  do_print("Searching for untrimmed cased entry with path");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "http://mOzilla.org/t",
+    autofilled: "http://mOzilla.org/t",
+    completed: "http://mOzilla.org/t"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_path_casing_2() {
+  do_print("Searching for untrimmed cased entry with path 2");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "http://mOzilla.org/T",
+    autofilled: "http://mOzilla.org/Test/",
+    completed: "http://mozilla.org/Test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_path_www_casing() {
+  do_print("Searching for untrimmed cased entry with www and path");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://www.mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "http://www.mOzilla.org/t",
+    autofilled: "http://www.mOzilla.org/t",
+    completed: "http://www.mOzilla.org/t"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_path_www_casing_2() {
+  do_print("Searching for untrimmed cased entry with www and path 2");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://www.mozilla.org/Test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "http://www.mOzilla.org/T",
+    autofilled: "http://www.mOzilla.org/Test/",
+    completed: "http://www.mozilla.org/Test/"
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_do_not_trim.js b/toolkit/components/places/tests/unifiedcomplete/test_do_not_trim.js
new file mode 100644
index 000000000..014d74998
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_do_not_trim.js
@@ -0,0 +1,91 @@
+/* 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/. */
+
+// Inline should never return matches shorter than the search string, since
+// that largely confuses completeDefaultIndex
+
+add_task(function* test_not_autofill_ws_1() {
+  do_print("Do not autofill whitespaced entry 1");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/link/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org ",
+    autofilled: "mozilla.org ",
+    completed: "mozilla.org "
+  });
+  yield cleanup();
+});
+
+add_task(function* test_not_autofill_ws_2() {
+  do_print("Do not autofill whitespaced entry 2");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/link/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/ ",
+    autofilled: "mozilla.org/ ",
+    completed: "mozilla.org/ "
+  });
+  yield cleanup();
+});
+
+add_task(function* test_not_autofill_ws_3() {
+  do_print("Do not autofill whitespaced entry 3");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/link/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/link ",
+    autofilled: "mozilla.org/link ",
+    completed: "mozilla.org/link "
+  });
+  yield cleanup();
+});
+
+add_task(function* test_not_autofill_ws_4() {
+  do_print("Do not autofill whitespaced entry 4");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/link/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/link/ ",
+    autofilled: "mozilla.org/link/ ",
+    completed: "mozilla.org/link/ "
+  });
+  yield cleanup();
+});
+
+
+add_task(function* test_not_autofill_ws_5() {
+  do_print("Do not autofill whitespaced entry 5");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/link/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "moz illa ",
+    autofilled: "moz illa ",
+    completed: "moz illa "
+  });
+  yield cleanup();
+});
+
+add_task(function* test_not_autofill_ws_6() {
+  do_print("Do not autofill whitespaced entry 6");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/link/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: " mozilla",
+    autofilled: " mozilla",
+    completed: " mozilla"
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_download_embed_bookmarks.js b/toolkit/components/places/tests/unifiedcomplete/test_download_embed_bookmarks.js
new file mode 100644
index 000000000..72661d075
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_download_embed_bookmarks.js
@@ -0,0 +1,71 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim:set ts=2 sw=2 sts=2 et:
+ * 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/. */
+
+/**
+ * Tests bug 449406 to ensure that TRANSITION_DOWNLOAD, TRANSITION_EMBED and
+ * TRANSITION_FRAMED_LINK bookmarked uri's show up in the location bar.
+ */
+
+add_task(function* test_download_embed_bookmarks() {
+  let uri1 = NetUtil.newURI("http://download/bookmarked");
+  let uri2 = NetUtil.newURI("http://embed/bookmarked");
+  let uri3 = NetUtil.newURI("http://framed/bookmarked");
+  let uri4 = NetUtil.newURI("http://download");
+  let uri5 = NetUtil.newURI("http://embed");
+  let uri6 = NetUtil.newURI("http://framed");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "download-bookmark", transition: TRANSITION_DOWNLOAD },
+    { uri: uri2, title: "embed-bookmark", transition: TRANSITION_EMBED },
+    { uri: uri3, title: "framed-bookmark", transition: TRANSITION_FRAMED_LINK},
+    { uri: uri4, title: "download2", transition: TRANSITION_DOWNLOAD },
+    { uri: uri5, title: "embed2", transition: TRANSITION_EMBED },
+    { uri: uri6, title: "framed2", transition: TRANSITION_FRAMED_LINK }
+  ]);
+  yield addBookmark({ uri: uri1,
+                      title: "download-bookmark" });
+  yield addBookmark({ uri: uri2,
+                      title: "embed-bookmark" });
+  yield addBookmark({ uri: uri3,
+                      title: "framed-bookmark" });
+
+  do_print("Searching for bookmarked download uri matches");
+  yield check_autocomplete({
+    search: "download-bookmark",
+    matches: [ { uri: uri1, title: "download-bookmark", style: [ "bookmark" ] } ]
+  });
+
+  do_print("Searching for bookmarked embed uri matches");
+  yield check_autocomplete({
+    search: "embed-bookmark",
+    matches: [ { uri: uri2, title: "embed-bookmark", style: [ "bookmark" ] } ]
+  });
+
+  do_print("Searching for bookmarked framed uri matches");
+  yield check_autocomplete({
+    search: "framed-bookmark",
+    matches: [ { uri: uri3, title: "framed-bookmark", style: [ "bookmark" ] } ]
+  });
+
+  do_print("Searching for download uri does not match");
+  yield check_autocomplete({
+    search: "download2",
+    matches: [ ]
+  });
+
+  do_print("Searching for embed uri does not match");
+  yield check_autocomplete({
+    search: "embed2",
+    matches: [ ]
+  });
+
+  do_print("Searching for framed uri does not match");
+  yield check_autocomplete({
+    search: "framed2",
+    matches: [ ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_dupe_urls.js b/toolkit/components/places/tests/unifiedcomplete/test_dupe_urls.js
new file mode 100644
index 000000000..a39c15236
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_dupe_urls.js
@@ -0,0 +1,23 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Ensure inline autocomplete doesn't return zero frecency pages.
+
+add_task(function* test_dupe_urls() {
+  do_print("Searching for urls with dupes should only show one");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/"),
+    transition: TRANSITION_TYPED
+  }, {
+    uri: NetUtil.newURI("http://mozilla.org/?")
+  });
+  yield check_autocomplete({
+    search: "moz",
+    autofilled: "mozilla.org/",
+    completed:  "mozilla.org/",
+    matches: [ { uri: NetUtil.newURI("http://mozilla.org/"),
+                 title: "mozilla.org",
+                 style: [ "autofill", "heuristic" ] } ]
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_empty_search.js b/toolkit/components/places/tests/unifiedcomplete/test_empty_search.js
new file mode 100644
index 000000000..ef1159705
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_empty_search.js
@@ -0,0 +1,98 @@
+/* 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/. */
+
+/**
+ * Test for bug 426864 that makes sure the empty search (drop down list) only
+ * shows typed pages from history.
+ */
+
+add_task(function* test_javascript_match() {
+  let uri1 = NetUtil.newURI("http://t.foo/0");
+  let uri2 = NetUtil.newURI("http://t.foo/1");
+  let uri3 = NetUtil.newURI("http://t.foo/2");
+  let uri4 = NetUtil.newURI("http://t.foo/3");
+  let uri5 = NetUtil.newURI("http://t.foo/4");
+  let uri6 = NetUtil.newURI("http://t.foo/5");
+  let uri7 = NetUtil.newURI("http://t.foo/6");
+
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "title" },
+    { uri: uri2, title: "title" },
+    { uri: uri3, title: "title", transition: TRANSITION_TYPED},
+    { uri: uri4, title: "title", transition: TRANSITION_TYPED },
+    { uri: uri6, title: "title", transition: TRANSITION_TYPED },
+    { uri: uri7, title: "title" }
+  ]);
+
+  yield addBookmark({ uri: uri2,
+                      title: "title" });
+  yield addBookmark({ uri: uri4,
+                      title: "title" });
+  yield addBookmark({ uri: uri5,
+                      title: "title" });
+  yield addBookmark({ uri: uri6,
+                      title: "title" });
+
+  addOpenPages(uri7, 1);
+
+  // Now remove page 6 from history, so it is an unvisited bookmark.
+  PlacesUtils.history.removePage(uri6);
+
+  do_print("Match everything");
+  yield check_autocomplete({
+    search: "foo",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("foo", { heuristic: true }),
+               { uri: uri1, title: "title" },
+               { uri: uri2, title: "title", style: ["bookmark"] },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "title", style: ["bookmark"] },
+               { uri: uri5, title: "title", style: ["bookmark"] },
+               { uri: uri6, title: "title", style: ["bookmark"] },
+               makeSwitchToTabMatch("http://t.foo/6", { title: "title" }),
+             ]
+  });
+
+  // Note the next few tests do *not* get a search result as enable-actions
+  // isn't specified.
+  do_print("Match only typed history");
+  yield check_autocomplete({
+    search: "foo ^ ~",
+    matches: [ { uri: uri3, title: "title" },
+               { uri: uri4, title: "title" } ]
+  });
+
+  do_print("Drop-down empty search matches only typed history");
+  yield check_autocomplete({
+    search: "",
+    matches: [ { uri: uri3, title: "title" },
+               { uri: uri4, title: "title" } ]
+  });
+
+  do_print("Drop-down empty search matches only bookmarks");
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", false);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", true);
+  yield check_autocomplete({
+    search: "",
+    matches: [ { uri: uri2, title: "title", style: ["bookmark"] },
+               { uri: uri4, title: "title", style: ["bookmark"] },
+               { uri: uri5, title: "title", style: ["bookmark"] },
+               { uri: uri6, title: "title", style: ["bookmark"] } ]
+  });
+
+  do_print("Drop-down empty search matches only open tabs");
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", false);
+  yield check_autocomplete({
+    search: "",
+    searchParam: "enable-actions",
+    matches: [
+               makeSwitchToTabMatch("http://t.foo/6", { title: "title" }),
+             ]
+  });
+
+  Services.prefs.clearUserPref("browser.urlbar.suggest.history");
+  Services.prefs.clearUserPref("browser.urlbar.suggest.bookmark");
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_enabled.js b/toolkit/components/places/tests/unifiedcomplete/test_enabled.js
new file mode 100644
index 000000000..dee8df8ec
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_enabled.js
@@ -0,0 +1,68 @@
+add_task(function* test_enabled() {
+  // Test for bug 471903 to make sure searching in autocomplete can be turned on
+  // and off. Also test bug 463535 for pref changing search.
+  let uri = NetUtil.newURI("http://url/0");
+  yield PlacesTestUtils.addVisits([ { uri: uri, title: "title" } ]);
+
+  do_print("plain search");
+  yield check_autocomplete({
+    search: "url",
+    matches: [ { uri: uri, title: "title" } ]
+  });
+
+  do_print("search disabled");
+  Services.prefs.setBoolPref("browser.urlbar.autocomplete.enabled", false);
+  yield check_autocomplete({
+    search: "url",
+    matches: [ ]
+  });
+
+  do_print("resume normal search");
+  Services.prefs.setBoolPref("browser.urlbar.autocomplete.enabled", true);
+  yield check_autocomplete({
+    search: "url",
+    matches: [ { uri: uri, title: "title" } ]
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_sync_enabled() {
+  // Initialize unified complete.
+  Cc["@mozilla.org/autocomplete/search;1?name=unifiedcomplete"]
+    .getService(Ci.mozIPlacesAutoComplete);
+
+  let types = [ "history", "bookmark", "openpage", "searches" ];
+
+  // Test the service keeps browser.urlbar.autocomplete.enabled synchronized
+  // with browser.urlbar.suggest prefs.
+  for (let type of types) {
+    Services.prefs.setBoolPref("browser.urlbar.suggest." + type, true);
+  }
+  Assert.equal(Services.prefs.getBoolPref("browser.urlbar.autocomplete.enabled"), true);
+
+  // Disable autocomplete and check all the suggest prefs are set to false.
+  Services.prefs.setBoolPref("browser.urlbar.autocomplete.enabled", false);
+  for (let type of types) {
+    Assert.equal(Services.prefs.getBoolPref("browser.urlbar.suggest." + type), false);
+  }
+
+  // Setting even a single suggest pref to true should enable autocomplete.
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", true);
+  for (let type of types.filter(t => t != "history")) {
+    Assert.equal(Services.prefs.getBoolPref("browser.urlbar.suggest." + type), false);
+  }
+  Assert.equal(Services.prefs.getBoolPref("browser.urlbar.autocomplete.enabled"), true);
+
+  // Disable autocoplete again, then re-enable it and check suggest prefs
+  // have been reset.
+  Services.prefs.setBoolPref("browser.urlbar.autocomplete.enabled", false);
+  Services.prefs.setBoolPref("browser.urlbar.autocomplete.enabled", true);
+  for (let type of types.filter(t => t != "history")) {
+    if (type == "searches") {
+      Assert.equal(Services.prefs.getBoolPref("browser.urlbar.suggest." + type), false);
+    } else {
+      Assert.equal(Services.prefs.getBoolPref("browser.urlbar.suggest." + type), true);
+    }
+  }
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_escape_self.js b/toolkit/components/places/tests/unifiedcomplete/test_escape_self.js
new file mode 100644
index 000000000..ff6e5f929
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_escape_self.js
@@ -0,0 +1,31 @@
+/* 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/. */
+
+/**
+ * Test bug 422698 to make sure searches with urls from the location bar
+ * correctly match itself when it contains escaped characters.
+ */
+
+add_task(function* test_escape() {
+  let uri1 = NetUtil.newURI("http://unescapeduri/");
+  let uri2 = NetUtil.newURI("http://escapeduri/%40/");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "title" },
+    { uri: uri2, title: "title" }
+  ]);
+
+  do_print("Unescaped location matches itself");
+  yield check_autocomplete({
+    search: "http://unescapeduri/",
+    matches: [ { uri: uri1, title: "title" } ]
+  });
+
+  do_print("Escaped location matches itself");
+  yield check_autocomplete({
+    search: "http://escapeduri/%40/",
+    matches: [ { uri: uri2, title: "title" } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_extension_matches.js b/toolkit/components/places/tests/unifiedcomplete/test_extension_matches.js
new file mode 100644
index 000000000..76af20558
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_extension_matches.js
@@ -0,0 +1,384 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim:set ts=2 sw=2 sts=2 et:
+ * 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/. */
+
+Cu.import("resource://gre/modules/ExtensionSearchHandler.jsm");
+
+let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(Ci.nsIAutoCompleteController);
+
+add_task(function* test_correct_errors_are_thrown() {
+  let keyword = "foo";
+  let anotherKeyword = "bar";
+  let unregisteredKeyword = "baz";
+
+  // Register a keyword.
+  ExtensionSearchHandler.registerKeyword(keyword, { emit: () => {} });
+
+  // Try registering the keyword again.
+  Assert.throws(() => ExtensionSearchHandler.registerKeyword(keyword, { emit: () => {} }));
+
+  // Register a different keyword.
+  ExtensionSearchHandler.registerKeyword(anotherKeyword, { emit: () => {} });
+
+  // Try calling handleSearch for an unregistered keyword.
+  Assert.throws(() => ExtensionSearchHandler.handleSearch(unregisteredKeyword, `${unregisteredKeyword} `, () => {}));
+
+  // Try calling handleSearch without a callback.
+  Assert.throws(() => ExtensionSearchHandler.handleSearch(unregisteredKeyword, `${unregisteredKeyword} `));
+
+  // Try getting the description for a keyword which isn't registered.
+  Assert.throws(() => ExtensionSearchHandler.getDescription(unregisteredKeyword));
+
+  // Try getting the extension name for a keyword which isn't registered.
+  Assert.throws(() => ExtensionSearchHandler.getExtensionName(unregisteredKeyword));
+
+  // Try setting the default suggestion for a keyword which isn't registered.
+  Assert.throws(() => ExtensionSearchHandler.setDefaultSuggestion(unregisteredKeyword, "suggestion"));
+
+  // Try calling handleInputCancelled when there is no active input session.
+  Assert.throws(() => ExtensionSearchHandler.handleInputCancelled());
+
+  // Try calling handleInputEntered when there is no active input session.
+  Assert.throws(() => ExtensionSearchHandler.handleInputEntered(anotherKeyword, `${anotherKeyword} test`, "tab"));
+
+  // Start a session by calling handleSearch with the registered keyword.
+  ExtensionSearchHandler.handleSearch(keyword, `${keyword} test`, () => {});
+
+  // Try providing suggestions for an unregistered keyword.
+  Assert.throws(() => ExtensionSearchHandler.addSuggestions(unregisteredKeyword, 0, []));
+
+  // Try providing suggestions for an inactive keyword.
+  Assert.throws(() => ExtensionSearchHandler.addSuggestions(anotherKeyword, 0, []));
+
+  // Try calling handleSearch for an inactive keyword.
+  Assert.throws(() => ExtensionSearchHandler.handleSearch(anotherKeyword, `${anotherKeyword} `, () => {}));
+
+  // Try calling addSuggestions with an old callback ID.
+  Assert.throws(() => ExtensionSearchHandler.addSuggestions(keyword, 0, []));
+
+  // Add suggestions with a valid callback ID.
+  ExtensionSearchHandler.addSuggestions(keyword, 1, []);
+
+  // Add suggestions again with a valid callback ID.
+  ExtensionSearchHandler.addSuggestions(keyword, 1, []);
+
+  // Try calling addSuggestions with a future callback ID.
+  Assert.throws(() => ExtensionSearchHandler.addSuggestions(keyword, 2, []));
+
+  // End the input session by calling handleInputCancelled.
+  ExtensionSearchHandler.handleInputCancelled();
+
+  // Try calling handleInputCancelled after the session has ended.
+  Assert.throws(() => ExtensionSearchHandler.handleInputCancelled());
+
+  // Try calling handleSearch that doesn't have a space after the keyword.
+  Assert.throws(() => ExtensionSearchHandler.handleSearch(anotherKeyword, `${anotherKeyword}`, () => {}));
+
+  // Try calling handleSearch with text starting with the wrong keyword.
+  Assert.throws(() => ExtensionSearchHandler.handleSearch(anotherKeyword, `${keyword} test`, () => {}));
+
+  // Start a new session by calling handleSearch with a different keyword
+  ExtensionSearchHandler.handleSearch(anotherKeyword, `${anotherKeyword} test`, () => {});
+
+  // Try adding suggestions again with the same callback ID now that the input session has ended.
+  Assert.throws(() => ExtensionSearchHandler.addSuggestions(keyword, 1, []));
+
+  // Add suggestions with a valid callback ID.
+  ExtensionSearchHandler.addSuggestions(anotherKeyword, 2, []);
+
+  // Try adding suggestions with a valid callback ID but a different keyword.
+  Assert.throws(() => ExtensionSearchHandler.addSuggestions(keyword, 2, []));
+
+  // Try adding suggestions with a valid callback ID but an unregistered keyword.
+  Assert.throws(() => ExtensionSearchHandler.addSuggestions(unregisteredKeyword, 2, []));
+
+  // Set the default suggestion.
+  ExtensionSearchHandler.setDefaultSuggestion(anotherKeyword, {description: "test result"});
+
+  // Try ending the session using handleInputEntered with a different keyword.
+  Assert.throws(() => ExtensionSearchHandler.handleInputEntered(keyword, `${keyword} test`, "tab"));
+
+  // Try calling handleInputEntered with invalid text.
+  Assert.throws(() => ExtensionSearchHandler.handleInputEntered(anotherKeyword, ` test`, "tab"));
+
+  // Try calling handleInputEntered with an invalid disposition.
+  Assert.throws(() => ExtensionSearchHandler.handleInputEntered(anotherKeyword, `${anotherKeyword} test`, "invalid"));
+
+  // End the session by calling handleInputEntered.
+  ExtensionSearchHandler.handleInputEntered(anotherKeyword, `${anotherKeyword} test`, "tab");
+
+  // Try calling handleInputEntered after the session has ended.
+  Assert.throws(() => ExtensionSearchHandler.handleInputEntered(anotherKeyword, `${anotherKeyword} test`, "tab"));
+
+  // Unregister the keyword.
+  ExtensionSearchHandler.unregisterKeyword(keyword);
+
+  // Try setting the default suggestion for the unregistered keyword.
+  Assert.throws(() => ExtensionSearchHandler.setDefaultSuggestion(keyword, {description: "test"}));
+
+  // Try handling a search with the unregistered keyword.
+  Assert.throws(() => ExtensionSearchHandler.handleSearch(keyword, `${keyword} test`, () => {}));
+
+  // Try unregistering the keyword again.
+  Assert.throws(() => ExtensionSearchHandler.unregisterKeyword(keyword));
+
+  // Unregister the other keyword.
+  ExtensionSearchHandler.unregisterKeyword(anotherKeyword);
+
+  // Try unregistering the word which was never registered.
+  Assert.throws(() => ExtensionSearchHandler.unregisterKeyword(unregisteredKeyword));
+
+  // Try setting the default suggestion for a word that was never registered.
+  Assert.throws(() => ExtensionSearchHandler.setDefaultSuggestion(unregisteredKeyword, {description: "test"}));
+
+  yield cleanup();
+});
+
+add_task(function* test_correct_events_are_emitted() {
+  let events = [];
+  function checkEvents(expectedEvents) {
+    Assert.equal(events.length, expectedEvents.length, "The correct number of events fired");
+    expectedEvents.forEach((e, i) => Assert.equal(e, events[i], `Expected "${e}" event to fire`));
+    events = [];
+  }
+
+  let mockExtension = { emit: message => events.push(message) };
+
+  let keyword = "foo";
+  let anotherKeyword = "bar";
+
+  ExtensionSearchHandler.registerKeyword(keyword, mockExtension);
+  ExtensionSearchHandler.registerKeyword(anotherKeyword, mockExtension);
+
+  ExtensionSearchHandler.handleSearch(keyword, `${keyword} `, () => {});
+  checkEvents([ExtensionSearchHandler.MSG_INPUT_STARTED]);
+
+  ExtensionSearchHandler.handleSearch(keyword, `${keyword} f`, () => {});
+  checkEvents([ExtensionSearchHandler.MSG_INPUT_CHANGED]);
+
+  ExtensionSearchHandler.handleInputEntered(keyword, `${keyword} f`, "tab");
+  checkEvents([ExtensionSearchHandler.MSG_INPUT_ENTERED]);
+
+  ExtensionSearchHandler.handleSearch(keyword, `${keyword} f`, () => {});
+  checkEvents([
+    ExtensionSearchHandler.MSG_INPUT_STARTED,
+    ExtensionSearchHandler.MSG_INPUT_CHANGED
+  ]);
+
+  ExtensionSearchHandler.handleInputCancelled();
+  checkEvents([ExtensionSearchHandler.MSG_INPUT_CANCELLED]);
+
+  ExtensionSearchHandler.handleSearch(anotherKeyword, `${anotherKeyword} baz`, () => {});
+  checkEvents([
+    ExtensionSearchHandler.MSG_INPUT_STARTED,
+    ExtensionSearchHandler.MSG_INPUT_CHANGED
+  ]);
+
+  ExtensionSearchHandler.handleInputEntered(anotherKeyword, `${anotherKeyword} baz`, "tab");
+  checkEvents([ExtensionSearchHandler.MSG_INPUT_ENTERED]);
+
+  ExtensionSearchHandler.unregisterKeyword(keyword);
+});
+
+add_task(function* test_removes_suggestion_if_its_content_is_typed_in() {
+  let keyword = "test";
+  let extensionName = "Foo Bar";
+
+  let mockExtension = {
+    name: extensionName,
+    emit(message, text, id) {
+      if (message === ExtensionSearchHandler.MSG_INPUT_CHANGED) {
+        ExtensionSearchHandler.addSuggestions(keyword, id, [
+          {content: "foo", description: "first suggestion"},
+          {content: "bar", description: "second suggestion"},
+          {content: "baz", description: "third suggestion"},
+        ]);
+        controller.stopSearch();
+      }
+    }
+  };
+
+  ExtensionSearchHandler.registerKeyword(keyword, mockExtension);
+
+  yield check_autocomplete({
+    search: `${keyword} unmatched`,
+    searchParam: "enable-actions",
+    matches: [
+      makeExtensionMatch({heuristic: true, keyword, description: extensionName, content: `${keyword} unmatched`}),
+      makeExtensionMatch({keyword, content: `${keyword} foo`, description: "first suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} bar`, description: "second suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} baz`, description: "third suggestion"})
+    ]
+  });
+
+  yield check_autocomplete({
+    search: `${keyword} foo`,
+    searchParam: "enable-actions",
+    matches: [
+      makeExtensionMatch({heuristic: true, keyword, description: extensionName, content: `${keyword} foo`}),
+      makeExtensionMatch({keyword, content: `${keyword} bar`, description: "second suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} baz`, description: "third suggestion"})
+    ]
+  });
+
+  yield check_autocomplete({
+    search: `${keyword} bar`,
+    searchParam: "enable-actions",
+    matches: [
+      makeExtensionMatch({heuristic: true, keyword, description: extensionName, content: `${keyword} bar`}),
+      makeExtensionMatch({keyword, content: `${keyword} foo`, description: "first suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} baz`, description: "third suggestion"})
+    ]
+  });
+
+  yield check_autocomplete({
+    search: `${keyword} baz`,
+    searchParam: "enable-actions",
+    matches: [
+      makeExtensionMatch({heuristic: true, keyword, description: extensionName, content: `${keyword} baz`}),
+      makeExtensionMatch({keyword, content: `${keyword} foo`, description: "first suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} bar`, description: "second suggestion"})
+    ]
+  });
+
+  ExtensionSearchHandler.unregisterKeyword(keyword);
+  yield cleanup();
+});
+
+add_task(function* test_extension_results_should_come_first() {
+  let keyword = "test";
+  let extensionName = "Omnibox Example";
+
+  let uri = NetUtil.newURI(`http://a.com/b`);
+  yield PlacesTestUtils.addVisits([
+    { uri, title: `${keyword} -` },
+  ]);
+
+  let mockExtension = {
+    name: extensionName,
+    emit(message, text, id) {
+      if (message === ExtensionSearchHandler.MSG_INPUT_CHANGED) {
+        ExtensionSearchHandler.addSuggestions(keyword, id, [
+          {content: "foo", description: "first suggestion"},
+          {content: "bar", description: "second suggestion"},
+          {content: "baz", description: "third suggestion"},
+        ]);
+      }
+      controller.stopSearch();
+    }
+  };
+
+  ExtensionSearchHandler.registerKeyword(keyword, mockExtension);
+
+  // Start an input session before testing MSG_INPUT_CHANGED.
+  ExtensionSearchHandler.handleSearch(keyword, `${keyword} `, () => {});
+
+  yield check_autocomplete({
+    search: `${keyword} -`,
+    searchParam: "enable-actions",
+    matches: [
+      makeExtensionMatch({heuristic: true, keyword, description: extensionName, content: `${keyword} -`}),
+      makeExtensionMatch({keyword, content: `${keyword} foo`, description: "first suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} bar`, description: "second suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} baz`, description: "third suggestion"}),
+      { uri, title: `${keyword} -` }
+    ]
+  });
+
+  ExtensionSearchHandler.unregisterKeyword(keyword);
+  yield cleanup();
+});
+
+add_task(function* test_setting_the_default_suggestion() {
+  let keyword = "test";
+  let extensionName = "Omnibox Example";
+
+  let mockExtension = {
+    name: extensionName,
+    emit(message, text, id) {
+      if (message === ExtensionSearchHandler.MSG_INPUT_CHANGED) {
+        ExtensionSearchHandler.addSuggestions(keyword, id, []);
+      }
+      controller.stopSearch();
+    }
+  };
+
+  ExtensionSearchHandler.registerKeyword(keyword, mockExtension);
+
+  ExtensionSearchHandler.setDefaultSuggestion(keyword, {
+    description: "hello world"
+  });
+
+  let searchString = `${keyword} search query`;
+  yield check_autocomplete({
+    search: searchString,
+    searchParam: "enable-actions",
+    matches: [
+      makeExtensionMatch({heuristic: true, keyword, description: "hello world", content: searchString}),
+    ]
+  });
+
+  ExtensionSearchHandler.setDefaultSuggestion(keyword, {
+    description: "foo bar"
+  });
+
+  yield check_autocomplete({
+    search: searchString,
+    searchParam: "enable-actions",
+    matches: [
+      makeExtensionMatch({heuristic: true, keyword, description: "foo bar", content: searchString}),
+    ]
+  });
+
+  ExtensionSearchHandler.unregisterKeyword(keyword);
+  yield cleanup();
+});
+
+add_task(function* test_maximum_number_of_suggestions_is_enforced() {
+  let keyword = "test";
+  let extensionName = "Omnibox Example";
+
+  let mockExtension = {
+    name: extensionName,
+    emit(message, text, id) {
+      if (message === ExtensionSearchHandler.MSG_INPUT_CHANGED) {
+        ExtensionSearchHandler.addSuggestions(keyword, id, [
+          {content: "a", description: "first suggestion"},
+          {content: "b", description: "second suggestion"},
+          {content: "c", description: "third suggestion"},
+          {content: "d", description: "fourth suggestion"},
+          {content: "e", description: "fifth suggestion"},
+          {content: "f", description: "sixth suggestion"},
+          {content: "g", description: "seventh suggestion"},
+          {content: "h", description: "eigth suggestion"},
+          {content: "i", description: "ninth suggestion"},
+          {content: "j", description: "tenth suggestion"},
+        ]);
+        controller.stopSearch();
+      }
+    }
+  };
+
+  ExtensionSearchHandler.registerKeyword(keyword, mockExtension);
+
+  // Start an input session before testing MSG_INPUT_CHANGED.
+  ExtensionSearchHandler.handleSearch(keyword, `${keyword} `, () => {});
+
+  yield check_autocomplete({
+    search: `${keyword} #`,
+    searchParam: "enable-actions",
+    matches: [
+      makeExtensionMatch({heuristic: true, keyword, description: extensionName, content: `${keyword} #`}),
+      makeExtensionMatch({keyword, content: `${keyword} a`, description: "first suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} b`, description: "second suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} c`, description: "third suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} d`, description: "fourth suggestion"}),
+      makeExtensionMatch({keyword, content: `${keyword} e`, description: "fifth suggestion"}),
+    ]
+  });
+
+  ExtensionSearchHandler.unregisterKeyword(keyword);
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_ignore_protocol.js b/toolkit/components/places/tests/unifiedcomplete/test_ignore_protocol.js
new file mode 100644
index 000000000..92e7f601a
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_ignore_protocol.js
@@ -0,0 +1,24 @@
+/* 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/. */
+
+/**
+ * Test bug 424509 to make sure searching for "h" doesn't match "http" of urls.
+ */
+
+add_task(function* test_escape() {
+  let uri1 = NetUtil.newURI("http://site/");
+  let uri2 = NetUtil.newURI("http://happytimes/");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "title" },
+    { uri: uri2, title: "title" }
+  ]);
+
+  do_print("Searching for h matches site and not http://");
+  yield check_autocomplete({
+    search: "h",
+    matches: [ { uri: uri2, title: "title" } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_keyword_search.js b/toolkit/components/places/tests/unifiedcomplete/test_keyword_search.js
new file mode 100644
index 000000000..12b7fea77
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_keyword_search.js
@@ -0,0 +1,73 @@
+/* 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/. */
+
+/**
+ * Test for bug 392143 that puts keyword results into the autocomplete. Makes
+ * sure that multiple parameter queries get spaces converted to +, + converted
+ * to %2B, non-ascii become escaped, and pages in history that match the
+ * keyword uses the page's title.
+ *
+ * Also test for bug 249468 by making sure multiple keyword bookmarks with the
+ * same keyword appear in the list.
+ */
+
+add_task(function* test_keyword_searc() {
+  let uri1 = NetUtil.newURI("http://abc/?search=%s");
+  let uri2 = NetUtil.newURI("http://abc/?search=ThisPageIsInHistory");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "Generic page title" },
+    { uri: uri2, title: "Generic page title" }
+  ]);
+  yield addBookmark({ uri: uri1, title: "Bookmark title", keyword: "key"});
+
+  do_print("Plain keyword query");
+  yield check_autocomplete({
+    search: "key term",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search=term"), title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  do_print("Plain keyword UC");
+  yield check_autocomplete({
+    search: "key TERM",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search=TERM"), title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  do_print("Multi-word keyword query");
+  yield check_autocomplete({
+    search: "key multi word",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search=multi%20word"), title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  do_print("Keyword query with +");
+  yield check_autocomplete({
+    search: "key blocking+",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search=blocking%2B"), title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  do_print("Unescaped term in query");
+  yield check_autocomplete({
+    search: "key ユニコード",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search=ユニコード"), title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  do_print("Keyword that happens to match a page");
+  yield check_autocomplete({
+    search: "key ThisPageIsInHistory",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search=ThisPageIsInHistory"), title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  do_print("Keyword without query (without space)");
+  yield check_autocomplete({
+    search: "key",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search="), title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  do_print("Keyword without query (with space)");
+  yield check_autocomplete({
+    search: "key ",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search="), title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_keyword_search_actions.js b/toolkit/components/places/tests/unifiedcomplete/test_keyword_search_actions.js
new file mode 100644
index 000000000..61d98f72d
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_keyword_search_actions.js
@@ -0,0 +1,149 @@
+/* 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/. */
+
+/**
+ * Test for bug 392143 that puts keyword results into the autocomplete. Makes
+ * sure that multiple parameter queries get spaces converted to +, + converted
+ * to %2B, non-ascii become escaped, and pages in history that match the
+ * keyword uses the page's title.
+ *
+ * Also test for bug 249468 by making sure multiple keyword bookmarks with the
+ * same keyword appear in the list.
+ */
+
+add_task(function* test_keyword_search() {
+  let uri1 = NetUtil.newURI("http://abc/?search=%s");
+  let uri2 = NetUtil.newURI("http://abc/?search=ThisPageIsInHistory");
+  let uri3 = NetUtil.newURI("http://abc/?search=%s&raw=%S");
+  let uri4 = NetUtil.newURI("http://abc/?search=%s&raw=%S&mozcharset=ISO-8859-1");
+  yield PlacesTestUtils.addVisits([{ uri: uri1 },
+                                   { uri: uri2 },
+                                   { uri: uri3 }]);
+  yield addBookmark({ uri: uri1, title: "Keyword", keyword: "key"});
+  yield addBookmark({ uri: uri1, title: "Post", keyword: "post", postData: "post_search=%s"});
+  yield addBookmark({ uri: uri3, title: "Encoded", keyword: "encoded"});
+  yield addBookmark({ uri: uri4, title: "Charset", keyword: "charset"});
+  yield addBookmark({ uri: uri2, title: "Noparam", keyword: "noparam"});
+  yield addBookmark({ uri: uri2, title: "Noparam-Post", keyword: "post_noparam", postData: "noparam=1"});
+
+  do_print("Plain keyword query");
+  yield check_autocomplete({
+    search: "key term",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=term", input: "key term"}),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Plain keyword UC");
+  yield check_autocomplete({
+    search: "key TERM",
+    matches: [ { uri: NetUtil.newURI("http://abc/?search=TERM"),
+                 title: "abc", style: ["keyword", "heuristic"] } ]
+  });
+
+  do_print("Multi-word keyword query");
+  yield check_autocomplete({
+    search: "key multi word",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=multi%20word", input: "key multi word"}),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Keyword query with +");
+  yield check_autocomplete({
+    search: "key blocking+",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=blocking%2B", input: "key blocking+"}),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Unescaped term in query");
+  // ... but note that UnifiedComplete calls encodeURIComponent() on the query
+  // string when it builds the URL, so the expected result will have the
+  // ユニコード substring encoded in the URL.
+  yield check_autocomplete({
+    search: "key ユニコード",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=" + encodeURIComponent("ユニコード"), input: "key ユニコード"}),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Keyword that happens to match a page");
+  yield check_autocomplete({
+    search: "key ThisPageIsInHistory",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=ThisPageIsInHistory", input: "key ThisPageIsInHistory"}),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Keyword without query (without space)");
+  yield check_autocomplete({
+    search: "key",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=", input: "key"}),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Keyword without query (with space)");
+  yield check_autocomplete({
+    search: "key ",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=", input: "key "}),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("POST Keyword");
+  yield check_autocomplete({
+    search: "post foo",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=foo", input: "post foo", postData: "post_search=foo"}),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Bug 420328: no-param keyword with a param");
+  yield check_autocomplete({
+    search: "noparam foo",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("noparam foo", { heuristic: true }) ]
+  });
+  yield check_autocomplete({
+    search: "post_noparam foo",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("post_noparam foo", { heuristic: true }) ]
+  });
+
+  do_print("escaping with default UTF-8 charset");
+  yield check_autocomplete({
+    search: "encoded foé",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=fo%C3%A9&raw=foé", input: "encoded foé" }),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("escaping with forced ISO-8859-1 charset");
+  yield check_autocomplete({
+    search: "charset foé",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=fo%E9&raw=foé", input: "charset foé" }),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Bug 359809: escaping +, / and @ with default UTF-8 charset");
+  yield check_autocomplete({
+    search: "encoded +/@",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=%2B%2F%40&raw=+/@", input: "encoded +/@" }),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  do_print("Bug 359809: escaping +, / and @ with forced ISO-8859-1 charset");
+  yield check_autocomplete({
+    search: "charset +/@",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("keyword", {url: "http://abc/?search=%2B%2F%40&raw=+/@", input: "charset +/@" }),
+                 title: "abc", style: [ "action", "keyword", "heuristic" ] } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_keywords.js b/toolkit/components/places/tests/unifiedcomplete/test_keywords.js
new file mode 100644
index 000000000..93e8d7a6f
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_keywords.js
@@ -0,0 +1,78 @@
+/* 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/. */
+
+add_task(function* test_non_keyword() {
+  do_print("Searching for non-keyworded entry should autoFill it");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield addBookmark({ uri: NetUtil.newURI("http://mozilla.org/test/") });
+  yield check_autocomplete({
+    search: "moz",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_keyword() {
+  do_print("Searching for keyworded entry should not autoFill it");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield addBookmark({ uri: NetUtil.newURI("http://mozilla.org/test/"), keyword: "moz" });
+  yield check_autocomplete({
+    search: "moz",
+    autofilled: "moz",
+    completed: "moz",
+  });
+  yield cleanup();
+});
+
+add_task(function* test_more_than_keyword() {
+  do_print("Searching for more than keyworded entry should autoFill it");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield addBookmark({ uri: NetUtil.newURI("http://mozilla.org/test/"), keyword: "moz" });
+  yield check_autocomplete({
+    search: "mozi",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_less_than_keyword() {
+  do_print("Searching for less than keyworded entry should autoFill it");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield addBookmark({ uri: NetUtil.newURI("http://mozilla.org/test/"), keyword: "moz" });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/",
+  });
+  yield cleanup();
+});
+
+add_task(function* test_keyword_casing() {
+  do_print("Searching for keyworded entry is case-insensitive");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield addBookmark({ uri: NetUtil.newURI("http://mozilla.org/test/"), keyword: "moz" });
+  yield check_autocomplete({
+    search: "MoZ",
+    autofilled: "MoZ",
+    completed: "MoZ"
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_match_beginning.js b/toolkit/components/places/tests/unifiedcomplete/test_match_beginning.js
new file mode 100644
index 000000000..57a1efaeb
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_match_beginning.js
@@ -0,0 +1,54 @@
+/* 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/. */
+
+/**
+ * Test bug 451760 which allows matching only at the beginning of urls or
+ * titles to simulate Firefox 2 functionality.
+ */
+
+add_task(function* test_match_beginning() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", false);
+
+  let uri1 = NetUtil.newURI("http://x.com/y");
+  let uri2 = NetUtil.newURI("https://y.com/x");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "a b" },
+    { uri: uri2, title: "b a" }
+  ]);
+
+  do_print("Match at the beginning of titles");
+  Services.prefs.setIntPref("browser.urlbar.matchBehavior", 3);
+  yield check_autocomplete({
+    search: "a",
+    matches: [ { uri: uri1, title: "a b" } ]
+  });
+
+  do_print("Match at the beginning of titles");
+  yield check_autocomplete({
+    search: "b",
+    matches: [ { uri: uri2, title: "b a" } ]
+  });
+
+  do_print("Match at the beginning of urls");
+  yield check_autocomplete({
+    search: "x",
+    matches: [ { uri: uri1, title: "a b" } ]
+  });
+
+  do_print("Match at the beginning of urls");
+  yield check_autocomplete({
+    search: "y",
+    matches: [ { uri: uri2, title: "b a" } ]
+  });
+
+  do_print("Sanity check that matching anywhere finds more");
+  Services.prefs.setIntPref("browser.urlbar.matchBehavior", 1);
+  yield check_autocomplete({
+    search: "a",
+    matches: [ { uri: uri1, title: "a b" },
+               { uri: uri2, title: "b a" } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_multi_word_search.js b/toolkit/components/places/tests/unifiedcomplete/test_multi_word_search.js
new file mode 100644
index 000000000..c6c9e952e
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_multi_word_search.js
@@ -0,0 +1,68 @@
+/* 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/. */
+
+/**
+ * Test for bug 401869 to allow multiple words separated by spaces to match in
+ * the page title, page url, or bookmark title to be considered a match. All
+ * terms must match but not all terms need to be in the title, etc.
+ *
+ * Test bug 424216 by making sure bookmark titles are always shown if one is
+ * available. Also bug 425056 makes sure matches aren't found partially in the
+ * page title and partially in the bookmark.
+ */
+
+add_task(function* test_match_beginning() {
+  let uri1 = NetUtil.newURI("http://a.b.c/d-e_f/h/t/p");
+  let uri2 = NetUtil.newURI("http://d.e.f/g-h_i/h/t/p");
+  let uri3 = NetUtil.newURI("http://g.h.i/j-k_l/h/t/p");
+  let uri4 = NetUtil.newURI("http://j.k.l/m-n_o/h/t/p");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "f(o)o b<a>r" },
+    { uri: uri2, title: "b(a)r b<a>z" },
+    { uri: uri3, title: "f(o)o b<a>r" },
+    { uri: uri4, title: "f(o)o b<a>r" }
+  ]);
+  yield addBookmark({ uri: uri3, title: "f(o)o b<a>r" });
+  yield addBookmark({ uri: uri4, title: "b(a)r b<a>z" });
+
+  do_print("Match 2 terms all in url");
+  yield check_autocomplete({
+    search: "c d",
+    matches: [ { uri: uri1, title: "f(o)o b<a>r" } ]
+  });
+
+  do_print("Match 1 term in url and 1 term in title");
+  yield check_autocomplete({
+    search: "b e",
+    matches: [ { uri: uri1, title: "f(o)o b<a>r" },
+               { uri: uri2, title: "b(a)r b<a>z" } ]
+  });
+
+  do_print("Match 3 terms all in title; display bookmark title if matched");
+  yield check_autocomplete({
+    search: "b a z",
+    matches: [ { uri: uri2, title: "b(a)r b<a>z" },
+               { uri: uri4, title: "b(a)r b<a>z", style: [ "bookmark" ] } ]
+  });
+
+  do_print("Match 2 terms in url and 1 in title; make sure bookmark title is used for search");
+  yield check_autocomplete({
+    search: "k f t",
+    matches: [ { uri: uri3, title: "f(o)o b<a>r", style: [ "bookmark" ] } ]
+  });
+
+  do_print("Match 3 terms in url and 1 in title");
+  yield check_autocomplete({
+    search: "d i g z",
+    matches: [ { uri: uri2, title: "b(a)r b<a>z" } ]
+  });
+
+  do_print("Match nothing");
+  yield check_autocomplete({
+    search: "m o z i",
+    matches: [ ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_query_url.js b/toolkit/components/places/tests/unifiedcomplete/test_query_url.js
new file mode 100644
index 000000000..915ba770e
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_query_url.js
@@ -0,0 +1,68 @@
+/* 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/. */
+
+add_task(function* test_no_slash() {
+  do_print("Searching for host match without slash should match host");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://file.org/test/"),
+    transition: TRANSITION_TYPED
+  }, {
+    uri: NetUtil.newURI("file:///c:/test.html"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "file",
+    autofilled: "file.org/",
+    completed: "file.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_w_slash() {
+  do_print("Searching match with slash at the end should do nothing");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://file.org/test/"),
+    transition: TRANSITION_TYPED
+  }, {
+    uri: NetUtil.newURI("file:///c:/test.html"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "file.org/",
+    autofilled: "file.org/",
+    completed: "file.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_middle() {
+  do_print("Searching match with slash in the middle should match url");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://file.org/test/"),
+    transition: TRANSITION_TYPED
+  }, {
+    uri: NetUtil.newURI("file:///c:/test.html"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "file.org/t",
+    autofilled: "file.org/test/",
+    completed: "http://file.org/test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_nonhost() {
+  do_print("Searching for non-host match without slash should not match url");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("file:///c:/test.html"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "file",
+    autofilled: "file",
+    completed: "file"
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_remote_tab_matches.js b/toolkit/components/places/tests/unifiedcomplete/test_remote_tab_matches.js
new file mode 100644
index 000000000..56998d4d6
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_remote_tab_matches.js
@@ -0,0 +1,203 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim:set ts=2 sw=2 sts=2 et:
+*/
+"use strict";
+
+Cu.import("resource://services-sync/main.js");
+
+Services.prefs.setCharPref("services.sync.username", "someone@somewhere.com");
+
+// A mock "Tabs" engine which autocomplete will use instead of the real
+// engine. We pass a constructor that Sync creates.
+function MockTabsEngine() {
+  this.clients = null; // We'll set this dynamically
+}
+
+MockTabsEngine.prototype = {
+  name: "tabs",
+
+  getAllClients() {
+    return this.clients;
+  },
+}
+
+// A clients engine that doesn't need to be a constructor.
+let MockClientsEngine = {
+  isMobile(guid) {
+    Assert.ok(guid.endsWith("desktop") || guid.endsWith("mobile"));
+    return guid.endsWith("mobile");
+  },
+}
+
+// Tell Sync about the mocks.
+Weave.Service.engineManager.register(MockTabsEngine);
+Weave.Service.clientsEngine = MockClientsEngine;
+
+// Tell the Sync XPCOM service it is initialized.
+let weaveXPCService = Cc["@mozilla.org/weave/service;1"]
+                        .getService(Ci.nsISupports)
+                        .wrappedJSObject;
+weaveXPCService.ready = true;
+
+// Configure the singleton engine for a test.
+function configureEngine(clients) {
+  // Configure the instance Sync created.
+  let engine = Weave.Service.engineManager.get("tabs");
+  engine.clients = clients;
+  // Send an observer that pretends the engine just finished a sync.
+  Services.obs.notifyObservers(null, "weave:engine:sync:finish", "tabs");
+}
+
+// Make a match object suitable for passing to check_autocomplete.
+function makeRemoteTabMatch(url, deviceName, extra = {}) {
+  return {
+    uri: makeActionURI("remotetab", {url, deviceName}),
+    title: extra.title || url,
+    style: [ "action", "remotetab" ],
+    icon: extra.icon,
+  }
+}
+
+// The tests.
+add_task(function* test_nomatch() {
+  // Nothing matches.
+  configureEngine({
+    guid_desktop: {
+      clientName: "My Desktop",
+      tabs: [{
+        urlHistory: ["http://foo.com/"],
+      }],
+    }
+  });
+
+  // No remote tabs match here, so we only expect search results.
+  yield check_autocomplete({
+    search: "ex",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("ex", { heuristic: true }) ],
+  });
+});
+
+add_task(function* test_minimal() {
+  // The minimal client and tabs info we can get away with.
+  configureEngine({
+    guid_desktop: {
+      clientName: "My Desktop",
+      tabs: [{
+        urlHistory: ["http://example.com/"],
+      }],
+    }
+  });
+
+  yield check_autocomplete({
+    search: "ex",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("ex", { heuristic: true }),
+               makeRemoteTabMatch("http://example.com/", "My Desktop") ],
+  });
+});
+
+add_task(function* test_maximal() {
+  // Every field that could possibly exist on a remote record.
+  configureEngine({
+    guid_mobile: {
+      clientName: "My Phone",
+      tabs: [{
+        urlHistory: ["http://example.com/"],
+        title: "An Example",
+        icon: "http://favicon",
+      }],
+    }
+  });
+
+  yield check_autocomplete({
+    search: "ex",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("ex", { heuristic: true }),
+               makeRemoteTabMatch("http://example.com/", "My Phone",
+                                  { title: "An Example",
+                                    icon: "moz-anno:favicon:http://favicon/"
+                                  }),
+             ],
+  });
+});
+
+add_task(function* test_noShowIcons() {
+  Services.prefs.setBoolPref("services.sync.syncedTabs.showRemoteIcons", false);
+  configureEngine({
+    guid_mobile: {
+      clientName: "My Phone",
+      tabs: [{
+        urlHistory: ["http://example.com/"],
+        title: "An Example",
+        icon: "http://favicon",
+      }],
+    }
+  });
+
+  yield check_autocomplete({
+    search: "ex",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("ex", { heuristic: true }),
+               makeRemoteTabMatch("http://example.com/", "My Phone",
+                                  { title: "An Example",
+                                    // expecting the default favicon due to that pref.
+                                    icon: "",
+                                  }),
+             ],
+  });
+  Services.prefs.clearUserPref("services.sync.syncedTabs.showRemoteIcons");
+});
+
+add_task(function* test_matches_title() {
+  // URL doesn't match search expression, should still match the title.
+  configureEngine({
+    guid_mobile: {
+      clientName: "My Phone",
+      tabs: [{
+        urlHistory: ["http://foo.com/"],
+        title: "An Example",
+      }],
+    }
+  });
+
+  yield check_autocomplete({
+    search: "ex",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("ex", { heuristic: true }),
+               makeRemoteTabMatch("http://foo.com/", "My Phone",
+                                  { title: "An Example" }),
+             ],
+  });
+});
+
+add_task(function* test_localtab_matches_override() {
+  // We have an open tab to the same page on a remote device, only "switch to
+  // tab" should appear as duplicate detection removed the remote one.
+
+  // First setup Sync to have the page as a remote tab.
+  configureEngine({
+    guid_mobile: {
+      clientName: "My Phone",
+      tabs: [{
+        urlHistory: ["http://foo.com/"],
+        title: "An Example",
+      }],
+    }
+  });
+
+  // Setup Places to think the tab is open locally.
+  let uri = NetUtil.newURI("http://foo.com/");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri, title: "An Example" },
+  ]);
+  addOpenPages(uri, 1);
+
+  yield check_autocomplete({
+    search: "ex",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("ex", { heuristic: true }),
+               makeSwitchToTabMatch("http://foo.com/", { title: "An Example" }),
+             ],
+  });
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_search_engine_alias.js b/toolkit/components/places/tests/unifiedcomplete/test_search_engine_alias.js
new file mode 100644
index 000000000..f35242e21
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_search_engine_alias.js
@@ -0,0 +1,51 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+
+add_task(function*() {
+  // Note that head_autocomplete.js has already added a MozSearch engine.
+  // Here we add another engine with a search alias.
+  Services.search.addEngineWithDetails("AliasedGETMozSearch", "", "get", "",
+                                       "GET", "http://s.example.com/search");
+  Services.search.addEngineWithDetails("AliasedPOSTMozSearch", "", "post", "",
+                                       "POST", "http://s.example.com/search");
+
+  for (let alias of ["get", "post"]) {
+    yield check_autocomplete({
+      search: alias,
+      searchParam: "enable-actions",
+      matches: [ makeSearchMatch(alias, { engineName: `Aliased${alias.toUpperCase()}MozSearch`,
+                                          searchQuery: "", alias, heuristic: true }) ]
+    });
+
+    yield check_autocomplete({
+      search: `${alias} `,
+      searchParam: "enable-actions",
+      matches: [ makeSearchMatch(`${alias} `, { engineName: `Aliased${alias.toUpperCase()}MozSearch`,
+                                                searchQuery: "", alias, heuristic: true }) ]
+    });
+
+    yield check_autocomplete({
+      search: `${alias} mozilla`,
+      searchParam: "enable-actions",
+          matches: [ makeSearchMatch(`${alias} mozilla`, { engineName: `Aliased${alias.toUpperCase()}MozSearch`,
+                                                           searchQuery: "mozilla", alias, heuristic: true }) ]
+    });
+
+    yield check_autocomplete({
+      search: `${alias} MoZiLlA`,
+      searchParam: "enable-actions",
+          matches: [ makeSearchMatch(`${alias} MoZiLlA`, { engineName: `Aliased${alias.toUpperCase()}MozSearch`,
+                                                           searchQuery: "MoZiLlA", alias, heuristic: true }) ]
+    });
+
+    yield check_autocomplete({
+      search: `${alias} mozzarella mozilla`,
+      searchParam: "enable-actions",
+          matches: [ makeSearchMatch(`${alias} mozzarella mozilla`, { engineName: `Aliased${alias.toUpperCase()}MozSearch`,
+                                                                      searchQuery: "mozzarella mozilla", alias, heuristic: true }) ]
+    });
+  }
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_search_engine_current.js b/toolkit/components/places/tests/unifiedcomplete/test_search_engine_current.js
new file mode 100644
index 000000000..b41d9884b
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_search_engine_current.js
@@ -0,0 +1,45 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+
+add_task(function*() {
+  // Note that head_autocomplete.js has already added a MozSearch engine.
+  // Here we add another engine with a search alias.
+  Services.search.addEngineWithDetails("AliasedMozSearch", "", "doit", "",
+                                       "GET", "http://s.example.com/search");
+
+  do_print("search engine");
+  yield check_autocomplete({
+    search: "mozilla",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("mozilla", { heuristic: true }) ]
+  });
+
+  do_print("search engine, uri-like input");
+  yield check_autocomplete({
+    search: "http:///",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("http:///", { heuristic: true }) ]
+  });
+
+  do_print("search engine, multiple words");
+  yield check_autocomplete({
+    search: "mozzarella cheese",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("mozzarella cheese", { heuristic: true }) ]
+  });
+
+  do_print("search engine, after current engine has changed");
+  Services.search.addEngineWithDetails("MozSearch2", "", "", "", "GET",
+                                       "http://s.example.com/search2");
+  engine = Services.search.getEngineByName("MozSearch2");
+  notEqual(Services.search.currentEngine, engine, "New engine shouldn't be the current engine yet");
+  Services.search.currentEngine = engine;
+  yield check_autocomplete({
+    search: "mozilla",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("mozilla", { engineName: "MozSearch2", heuristic: true }) ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_search_engine_host.js b/toolkit/components/places/tests/unifiedcomplete/test_search_engine_host.js
new file mode 100644
index 000000000..61b9826f7
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_search_engine_host.js
@@ -0,0 +1,49 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(function* test_searchEngine_autoFill() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", true);
+  Services.search.addEngineWithDetails("MySearchEngine", "", "", "",
+                                       "GET", "http://my.search.com/");
+  let engine = Services.search.getEngineByName("MySearchEngine");
+  do_register_cleanup(() => Services.search.removeEngine(engine));
+
+  // Add an uri that matches the search string with high frecency.
+  let uri = NetUtil.newURI("http://www.example.com/my/");
+  let visits = [];
+  for (let i = 0; i < 100; ++i) {
+    visits.push({ uri, title: "Terms - SearchEngine Search" });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+  yield addBookmark({ uri: uri, title: "Example bookmark" });
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  ok(frecencyForUrl(uri) > 10000, "Added URI should have expected high frecency");
+
+  do_print("Check search domain is autoFilled even if there's an higher frecency match");
+  yield check_autocomplete({
+    search: "my",
+    autofilled: "my.search.com",
+    completed: "http://my.search.com"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_searchEngine_noautoFill() {
+  let engineName = "engine-rel-searchform.xml";
+  let engine = yield addTestEngine(engineName);
+  equal(engine.searchForm, "http://example.com/?search");
+
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://example.com/my/"));
+
+  do_print("Check search domain is not autoFilled if it matches a visited domain");
+  yield check_autocomplete({
+    search: "example",
+    autofilled: "example.com/",
+    completed: "example.com/"
+  });
+
+  yield cleanup();
+});
+
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_search_engine_restyle.js b/toolkit/components/places/tests/unifiedcomplete/test_search_engine_restyle.js
new file mode 100644
index 000000000..2a5f2d78e
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_search_engine_restyle.js
@@ -0,0 +1,43 @@
+/* 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/. */
+
+add_task(function* test_searchEngine() {
+  Services.search.addEngineWithDetails("SearchEngine", "", "", "",
+                                       "GET", "http://s.example.com/search");
+  let engine = Services.search.getEngineByName("SearchEngine");
+  engine.addParam("q", "{searchTerms}", null);
+  do_register_cleanup(() => Services.search.removeEngine(engine));
+
+  let uri1 = NetUtil.newURI("http://s.example.com/search?q=Terms&client=1");
+  let uri2 = NetUtil.newURI("http://s.example.com/search?q=Terms&client=2");
+  yield PlacesTestUtils.addVisits({ uri: uri1, title: "Terms - SearchEngine Search" });
+  yield addBookmark({ uri: uri2, title: "Terms - SearchEngine Search" });
+
+  do_print("Past search terms should be styled, unless bookmarked");
+  Services.prefs.setBoolPref("browser.urlbar.restyleSearches", true);
+  yield check_autocomplete({
+    search: "term",
+    matches: [
+      makeSearchMatch("Terms", {
+        engineName: "SearchEngine",
+        style: ["favicon"]
+      }),
+      {
+        uri: uri2,
+        title: "Terms - SearchEngine Search",
+        style: ["bookmark"]
+      }
+    ]
+  });
+
+  do_print("Past search terms should not be styled if restyling is disabled");
+  Services.prefs.setBoolPref("browser.urlbar.restyleSearches", false);
+  yield check_autocomplete({
+    search: "term",
+    matches: [ { uri: uri1, title: "Terms - SearchEngine Search" },
+               { uri: uri2, title: "Terms - SearchEngine Search", style: ["bookmark"] } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_search_suggestions.js b/toolkit/components/places/tests/unifiedcomplete/test_search_suggestions.js
new file mode 100644
index 000000000..63b428cd4
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_search_suggestions.js
@@ -0,0 +1,651 @@
+Cu.import("resource://gre/modules/FormHistory.jsm");
+
+const ENGINE_NAME = "engine-suggestions.xml";
+const SERVER_PORT = 9000;
+const SUGGEST_PREF = "browser.urlbar.suggest.searches";
+const SUGGEST_ENABLED_PREF = "browser.search.suggest.enabled";
+const SUGGEST_RESTRICT_TOKEN = "$";
+
+var suggestionsFn;
+var previousSuggestionsFn;
+
+function setSuggestionsFn(fn) {
+  previousSuggestionsFn = suggestionsFn;
+  suggestionsFn = fn;
+}
+
+function* cleanUpSuggestions() {
+  yield cleanup();
+  if (previousSuggestionsFn) {
+    suggestionsFn = previousSuggestionsFn;
+    previousSuggestionsFn = null;
+  }
+}
+
+add_task(function* setUp() {
+  // Set up a server that provides some suggestions by appending strings onto
+  // the search query.
+  let server = makeTestServer(SERVER_PORT);
+  server.registerPathHandler("/suggest", (req, resp) => {
+    // URL query params are x-www-form-urlencoded, which converts spaces into
+    // plus signs, so un-convert any plus signs back to spaces.
+    let searchStr = decodeURIComponent(req.queryString.replace(/\+/g, " "));
+    let suggestions = suggestionsFn(searchStr);
+    let data = [searchStr, suggestions];
+    resp.setHeader("Content-Type", "application/json", false);
+    resp.write(JSON.stringify(data));
+  });
+  setSuggestionsFn(searchStr => {
+    let suffixes = ["foo", "bar"];
+    return suffixes.map(s => searchStr + " " + s);
+  });
+
+  // Install the test engine.
+  let oldCurrentEngine = Services.search.currentEngine;
+  do_register_cleanup(() => Services.search.currentEngine = oldCurrentEngine);
+  let engine = yield addTestEngine(ENGINE_NAME, server);
+  Services.search.currentEngine = engine;
+});
+
+add_task(function* disabled_urlbarSuggestions() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, false);
+  Services.prefs.setBoolPref(SUGGEST_ENABLED_PREF, true);
+  yield check_autocomplete({
+    search: "hello",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("hello", { engineName: ENGINE_NAME, heuristic: true }),
+    ],
+  });
+  yield cleanUpSuggestions();
+});
+
+add_task(function* disabled_allSuggestions() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+  Services.prefs.setBoolPref(SUGGEST_ENABLED_PREF, false);
+  yield check_autocomplete({
+    search: "hello",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("hello", { engineName: ENGINE_NAME, heuristic: true }),
+    ],
+  });
+  yield cleanUpSuggestions();
+});
+
+add_task(function* disabled_privateWindow() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+  Services.prefs.setBoolPref(SUGGEST_ENABLED_PREF, true);
+  yield check_autocomplete({
+    search: "hello",
+    searchParam: "private-window enable-actions",
+    matches: [
+      makeSearchMatch("hello", { engineName: ENGINE_NAME, heuristic: true }),
+    ],
+  });
+  yield cleanUpSuggestions();
+});
+
+add_task(function* singleWordQuery() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+  Services.prefs.setBoolPref(SUGGEST_ENABLED_PREF, true);
+
+  yield check_autocomplete({
+    search: "hello",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("hello", { engineName: ENGINE_NAME, heuristic: true }),
+      { uri: makeActionURI(("searchengine"), {
+        engineName: ENGINE_NAME,
+        input: "hello foo",
+        searchQuery: "hello",
+        searchSuggestion: "hello foo",
+      }),
+      title: ENGINE_NAME,
+      style: ["action", "searchengine"],
+      icon: "",
+    }, {
+      uri: makeActionURI(("searchengine"), {
+        engineName: ENGINE_NAME,
+        input: "hello bar",
+        searchQuery: "hello",
+        searchSuggestion: "hello bar",
+      }),
+      title: ENGINE_NAME,
+      style: ["action", "searchengine"],
+      icon: "",
+    }],
+  });
+
+  yield cleanUpSuggestions();
+});
+
+add_task(function* multiWordQuery() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+  Services.prefs.setBoolPref(SUGGEST_ENABLED_PREF, true);
+
+  yield check_autocomplete({
+    search: "hello world",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("hello world", { engineName: ENGINE_NAME, heuristic: true }),
+      { uri: makeActionURI(("searchengine"), {
+        engineName: ENGINE_NAME,
+        input: "hello world foo",
+        searchQuery: "hello world",
+        searchSuggestion: "hello world foo",
+      }),
+      title: ENGINE_NAME,
+      style: ["action", "searchengine"],
+      icon: "",
+    }, {
+      uri: makeActionURI(("searchengine"), {
+        engineName: ENGINE_NAME,
+        input: "hello world bar",
+        searchQuery: "hello world",
+        searchSuggestion: "hello world bar",
+      }),
+      title: ENGINE_NAME,
+      style: ["action", "searchengine"],
+      icon: "",
+    }],
+  });
+
+  yield cleanUpSuggestions();
+});
+
+add_task(function* suffixMatch() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+  Services.prefs.setBoolPref(SUGGEST_ENABLED_PREF, true);
+
+  setSuggestionsFn(searchStr => {
+    let prefixes = ["baz", "quux"];
+    return prefixes.map(p => p + " " + searchStr);
+  });
+
+  yield check_autocomplete({
+    search: "hello",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("hello", { engineName: ENGINE_NAME, heuristic: true }),
+      { uri: makeActionURI(("searchengine"), {
+        engineName: ENGINE_NAME,
+        input: "baz hello",
+        searchQuery: "hello",
+        searchSuggestion: "baz hello",
+      }),
+      title: ENGINE_NAME,
+      style: ["action", "searchengine"],
+      icon: "",
+    }, {
+      uri: makeActionURI(("searchengine"), {
+        engineName: ENGINE_NAME,
+        input: "quux hello",
+        searchQuery: "hello",
+        searchSuggestion: "quux hello",
+      }),
+      title: ENGINE_NAME,
+      style: ["action", "searchengine"],
+      icon: "",
+    }],
+  });
+
+  yield cleanUpSuggestions();
+});
+
+add_task(function* queryIsNotASubstring() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+
+  setSuggestionsFn(searchStr => {
+    return ["aaa", "bbb"];
+  });
+
+  yield check_autocomplete({
+    search: "hello",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("hello", { engineName: ENGINE_NAME, heuristic: true }),
+      { uri: makeActionURI(("searchengine"), {
+        engineName: ENGINE_NAME,
+        input: "aaa",
+        searchQuery: "hello",
+        searchSuggestion: "aaa",
+      }),
+      title: ENGINE_NAME,
+      style: ["action", "searchengine"],
+      icon: "",
+    }, {
+      uri: makeActionURI(("searchengine"), {
+        engineName: ENGINE_NAME,
+        input: "bbb",
+        searchQuery: "hello",
+        searchSuggestion: "bbb",
+      }),
+      title: ENGINE_NAME,
+      style: ["action", "searchengine"],
+      icon: "",
+    }],
+  });
+
+  yield cleanUpSuggestions();
+});
+
+add_task(function* restrictToken() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+  Services.prefs.setBoolPref(SUGGEST_ENABLED_PREF, true);
+
+  // Add a visit and a bookmark.  Actually, make the bookmark visited too so
+  // that it's guaranteed, with its higher frecency, to appear above the search
+  // suggestions.
+  yield PlacesTestUtils.addVisits([
+    {
+      uri: NetUtil.newURI("http://example.com/hello-visit"),
+      title: "hello visit",
+    },
+    {
+      uri: NetUtil.newURI("http://example.com/hello-bookmark"),
+      title: "hello bookmark",
+    },
+  ]);
+
+  yield addBookmark({
+    uri: NetUtil.newURI("http://example.com/hello-bookmark"),
+    title: "hello bookmark",
+  });
+
+  // Do an unrestricted search to make sure everything appears in it, including
+  // the visit and bookmark.
+  yield check_autocomplete({
+    search: "hello",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("hello", { engineName: ENGINE_NAME, heuristic: true }),
+      {
+        uri: NetUtil.newURI("http://example.com/hello-visit"),
+        title: "hello visit",
+      },
+      {
+        uri: NetUtil.newURI("http://example.com/hello-bookmark"),
+        title: "hello bookmark",
+        style: ["bookmark"],
+      },
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "hello foo",
+          searchQuery: "hello",
+          searchSuggestion: "hello foo",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "hello bar",
+          searchQuery: "hello",
+          searchSuggestion: "hello bar",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+    ],
+  });
+
+  // Now do a restricted search to make sure only suggestions appear.
+  yield check_autocomplete({
+    search: SUGGEST_RESTRICT_TOKEN + " hello",
+    searchParam: "enable-actions",
+    matches: [
+      // TODO (bug 1177895) This is wrong.
+      makeSearchMatch(SUGGEST_RESTRICT_TOKEN + " hello", { engineName: ENGINE_NAME, heuristic: true }),
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "hello foo",
+          searchQuery: "hello",
+          searchSuggestion: "hello foo",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "hello bar",
+          searchQuery: "hello",
+          searchSuggestion: "hello bar",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      }
+    ],
+  });
+
+  yield cleanUpSuggestions();
+});
+
+add_task(function* mixup_frecency() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+
+  // Add a visit and a bookmark.  Actually, make the bookmark visited too so
+  // that it's guaranteed, with its higher frecency, to appear above the search
+  // suggestions.
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("http://example.com/lo0"),
+      title: "low frecency 0" },
+    { uri: NetUtil.newURI("http://example.com/lo1"),
+      title: "low frecency 1" },
+    { uri: NetUtil.newURI("http://example.com/lo2"),
+      title: "low frecency 2" },
+    { uri: NetUtil.newURI("http://example.com/lo3"),
+      title: "low frecency 3" },
+    { uri: NetUtil.newURI("http://example.com/lo4"),
+      title: "low frecency 4" },
+  ]);
+
+  for (let i = 0; i < 4; i++) {
+    let href = `http://example.com/lo${i}`;
+    let frecency = frecencyForUrl(href);
+    Assert.ok(frecency < FRECENCY_DEFAULT,
+              `frecency for ${href}: ${frecency}, should be lower than ${FRECENCY_DEFAULT}`);
+  }
+
+  for (let i = 0; i < 5; i++) {
+    yield PlacesTestUtils.addVisits([
+      { uri: NetUtil.newURI("http://example.com/hi0"),
+        title: "high frecency 0",
+        transition: TRANSITION_TYPED },
+      { uri: NetUtil.newURI("http://example.com/hi1"),
+        title: "high frecency 1",
+        transition: TRANSITION_TYPED },
+      { uri: NetUtil.newURI("http://example.com/hi2"),
+        title: "high frecency 2",
+        transition: TRANSITION_TYPED },
+      { uri: NetUtil.newURI("http://example.com/hi3"),
+        title: "high frecency 3",
+        transition: TRANSITION_TYPED },
+    ]);
+  }
+
+  for (let i = 0; i < 4; i++) {
+    let href = `http://example.com/hi${i}`;
+    yield addBookmark({ uri: href, title: `high frecency ${i}` });
+    let frecency = frecencyForUrl(href);
+    Assert.ok(frecency > FRECENCY_DEFAULT,
+              `frecency for ${href}: ${frecency}, should be higher than ${FRECENCY_DEFAULT}`);
+  }
+
+  // Do an unrestricted search to make sure everything appears in it, including
+  // the visit and bookmark.
+  yield check_autocomplete({
+    checkSorting: true,
+    search: "frecency",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("frecency", { engineName: ENGINE_NAME, heuristic: true }),
+      { uri: NetUtil.newURI("http://example.com/hi3"),
+        title: "high frecency 3",
+        style: [ "bookmark" ] },
+      { uri: NetUtil.newURI("http://example.com/hi2"),
+        title: "high frecency 2",
+        style: [ "bookmark" ] },
+      { uri: NetUtil.newURI("http://example.com/hi1"),
+        title: "high frecency 1",
+        style: [ "bookmark" ] },
+      { uri: NetUtil.newURI("http://example.com/hi0"),
+        title: "high frecency 0",
+        style: [ "bookmark" ] },
+      { uri: NetUtil.newURI("http://example.com/lo4"),
+        title: "low frecency 4" },
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "frecency foo",
+          searchQuery: "frecency",
+          searchSuggestion: "frecency foo",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "frecency bar",
+          searchQuery: "frecency",
+          searchSuggestion: "frecency bar",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+      { uri: NetUtil.newURI("http://example.com/lo3"),
+        title: "low frecency 3" },
+      { uri: NetUtil.newURI("http://example.com/lo2"),
+        title: "low frecency 2" },
+      { uri: NetUtil.newURI("http://example.com/lo1"),
+        title: "low frecency 1" },
+      { uri: NetUtil.newURI("http://example.com/lo0"),
+        title: "low frecency 0" },
+    ],
+  });
+
+  yield cleanUpSuggestions();
+});
+
+add_task(function* prohibit_suggestions() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+
+  yield check_autocomplete({
+    search: "localhost",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("localhost", { engineName: ENGINE_NAME, heuristic: true }),
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "localhost foo",
+          searchQuery: "localhost",
+          searchSuggestion: "localhost foo",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "localhost bar",
+          searchQuery: "localhost",
+          searchSuggestion: "localhost bar",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+    ],
+  });
+  Services.prefs.setBoolPref("browser.fixup.domainwhitelist.localhost", true);
+  do_register_cleanup(() => {
+    Services.prefs.clearUserPref("browser.fixup.domainwhitelist.localhost");
+  });
+  yield check_autocomplete({
+    search: "localhost",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("localhost", "http://localhost/", { heuristic: true }),
+      makeSearchMatch("localhost", { engineName: ENGINE_NAME, heuristic: false })
+    ],
+  });
+
+  // When using multiple words, we should still get suggestions:
+  yield check_autocomplete({
+    search: "localhost other",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("localhost other", { engineName: ENGINE_NAME, heuristic: true }),
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "localhost other foo",
+          searchQuery: "localhost other",
+          searchSuggestion: "localhost other foo",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "localhost other bar",
+          searchQuery: "localhost other",
+          searchSuggestion: "localhost other bar",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+    ],
+  });
+
+  // Clear the whitelist for localhost, and try preferring DNS for any single
+  // word instead:
+  Services.prefs.clearUserPref("browser.fixup.domainwhitelist.localhost");
+  Services.prefs.setBoolPref("browser.fixup.dns_first_for_single_words", true);
+  do_register_cleanup(() => {
+    Services.prefs.clearUserPref("browser.fixup.dns_first_for_single_words");
+  });
+
+  yield check_autocomplete({
+    search: "localhost",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("localhost", "http://localhost/", { heuristic: true }),
+      makeSearchMatch("localhost", { engineName: ENGINE_NAME, heuristic: false })
+    ],
+  });
+
+  yield check_autocomplete({
+    search: "somethingelse",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("somethingelse", "http://somethingelse/", { heuristic: true }),
+      makeSearchMatch("somethingelse", { engineName: ENGINE_NAME, heuristic: false })
+    ],
+  });
+
+  // When using multiple words, we should still get suggestions:
+  yield check_autocomplete({
+    search: "localhost other",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("localhost other", { engineName: ENGINE_NAME, heuristic: true }),
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "localhost other foo",
+          searchQuery: "localhost other",
+          searchSuggestion: "localhost other foo",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "localhost other bar",
+          searchQuery: "localhost other",
+          searchSuggestion: "localhost other bar",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+    ],
+  });
+
+  Services.prefs.clearUserPref("browser.fixup.dns_first_for_single_words");
+
+  yield check_autocomplete({
+    search: "1.2.3.4",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("1.2.3.4", "http://1.2.3.4/", { heuristic: true }),
+    ],
+  });
+  yield check_autocomplete({
+    search: "[2001::1]:30",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("[2001::1]:30", "http://[2001::1]:30/", { heuristic: true }),
+    ],
+  });
+  yield check_autocomplete({
+    search: "user:pass@test",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("user:pass@test", "http://user:pass@test/", { heuristic: true }),
+    ],
+  });
+  yield check_autocomplete({
+    search: "test/test",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("test/test", "http://test/test", { heuristic: true }),
+    ],
+  });
+  yield check_autocomplete({
+    search: "data:text/plain,Content",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("data:text/plain,Content", "data:text/plain,Content", { heuristic: true }),
+    ],
+  });
+
+  yield check_autocomplete({
+    search: "a",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("a", { engineName: ENGINE_NAME, heuristic: true }),
+    ],
+  });
+
+  yield cleanUpSuggestions();
+});
+
+add_task(function* avoid_url_suggestions() {
+  Services.prefs.setBoolPref(SUGGEST_PREF, true);
+
+  setSuggestionsFn(searchStr => {
+    let suffixes = [".com", "/test", ":1]", "@test", ". com"];
+    return suffixes.map(s => searchStr + s);
+  });
+
+  yield check_autocomplete({
+    search: "test",
+    searchParam: "enable-actions",
+    matches: [
+      makeSearchMatch("test", { engineName: ENGINE_NAME, heuristic: true }),
+      {
+        uri: makeActionURI(("searchengine"), {
+          engineName: ENGINE_NAME,
+          input: "test. com",
+          searchQuery: "test",
+          searchSuggestion: "test. com",
+        }),
+        title: ENGINE_NAME,
+        style: ["action", "searchengine"],
+        icon: "",
+      },
+    ],
+  });
+
+  yield cleanUpSuggestions();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_special_search.js b/toolkit/components/places/tests/unifiedcomplete/test_special_search.js
new file mode 100644
index 000000000..21df7046c
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_special_search.js
@@ -0,0 +1,447 @@
+/* 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/. */
+
+/**
+ * Test for bug 395161 that allows special searches that restrict results to
+ * history/bookmark/tagged items and title/url matches.
+ *
+ * Test 485122 by making sure results don't have tags when restricting result
+ * to just history either by default behavior or dynamic query restrict.
+ */
+
+function setSuggestPrefsToFalse() {
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", false);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history.onlyTyped", false);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", false);
+}
+
+add_task(function* test_special_searches() {
+  let uri1 = NetUtil.newURI("http://url/");
+  let uri2 = NetUtil.newURI("http://url/2");
+  let uri3 = NetUtil.newURI("http://foo.bar/");
+  let uri4 = NetUtil.newURI("http://foo.bar/2");
+  let uri5 = NetUtil.newURI("http://url/star");
+  let uri6 = NetUtil.newURI("http://url/star/2");
+  let uri7 = NetUtil.newURI("http://foo.bar/star");
+  let uri8 = NetUtil.newURI("http://foo.bar/star/2");
+  let uri9 = NetUtil.newURI("http://url/tag");
+  let uri10 = NetUtil.newURI("http://url/tag/2");
+  let uri11 = NetUtil.newURI("http://foo.bar/tag");
+  let uri12 = NetUtil.newURI("http://foo.bar/tag/2");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "title", transition: TRANSITION_TYPED },
+    { uri: uri2, title: "foo.bar" },
+    { uri: uri3, title: "title" },
+    { uri: uri4, title: "foo.bar", transition: TRANSITION_TYPED },
+    { uri: uri6, title: "foo.bar" },
+    { uri: uri11, title: "title", transition: TRANSITION_TYPED }
+  ]);
+  yield addBookmark( { uri: uri5, title: "title" } );
+  yield addBookmark( { uri: uri6, title: "foo.bar" } );
+  yield addBookmark( { uri: uri7, title: "title" } );
+  yield addBookmark( { uri: uri8, title: "foo.bar" } );
+  yield addBookmark( { uri: uri9, title: "title", tags: [ "foo.bar" ] } );
+  yield addBookmark( { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ] } );
+  yield addBookmark( { uri: uri11, title: "title", tags: [ "foo.bar" ] } );
+  yield addBookmark( { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ] } );
+
+  // Test restricting searches
+  do_print("History restrict");
+  yield check_autocomplete({
+    search: "^",
+    matches: [ { uri: uri1, title: "title" },
+               { uri: uri2, title: "foo.bar" },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("Star restrict");
+  yield check_autocomplete({
+    search: "*",
+    matches: [ { uri: uri5, title: "title", style: [ "bookmark" ] },
+               { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar"], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("Tag restrict");
+  yield check_autocomplete({
+    search: "+",
+    matches: [ { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  // Test specials as any word position
+  do_print("Special as first word");
+  yield check_autocomplete({
+    search: "^ foo bar",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("Special as middle word");
+  yield check_autocomplete({
+    search: "foo ^ bar",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("Special as last word");
+  yield check_autocomplete({
+    search: "foo bar ^",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  // Test restricting and matching searches with a term
+  do_print("foo ^ -> history");
+  yield check_autocomplete({
+    search: "foo ^",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo | -> history (change pref)");
+  changeRestrict("history", "|");
+  yield check_autocomplete({
+    search: "foo |",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo * -> is star");
+  resetRestrict("history");
+  yield check_autocomplete({
+    search: "foo *",
+    matches: [ { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo | -> is star (change pref)");
+  changeRestrict("bookmark", "|");
+  yield check_autocomplete({
+    search: "foo |",
+    matches: [ { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo # -> in title");
+  resetRestrict("bookmark");
+  yield check_autocomplete({
+    search: "foo #",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo | -> in title (change pref)");
+  changeRestrict("title", "|");
+  yield check_autocomplete({
+    search: "foo |",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo @ -> in url");
+  resetRestrict("title");
+  yield check_autocomplete({
+    search: "foo @",
+    matches: [ { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo | -> in url (change pref)");
+  changeRestrict("url", "|");
+  yield check_autocomplete({
+    search: "foo |",
+    matches: [ { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo + -> is tag");
+  resetRestrict("url");
+  yield check_autocomplete({
+    search: "foo +",
+    matches: [ { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo | -> is tag (change pref)");
+  changeRestrict("tag", "|");
+  yield check_autocomplete({
+    search: "foo |",
+    matches: [ { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo ~ -> is typed");
+  resetRestrict("tag");
+  yield check_autocomplete({
+    search: "foo ~",
+    matches: [ { uri: uri4, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo | -> is typed (change pref)");
+  changeRestrict("typed", "|");
+  yield check_autocomplete({
+    search: "foo |",
+    matches: [ { uri: uri4, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  // Test various pairs of special searches
+  do_print("foo ^ * -> history, is star");
+  resetRestrict("typed");
+  yield check_autocomplete({
+    search: "foo ^ *",
+    matches: [ { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo ^ # -> history, in title");
+  yield check_autocomplete({
+    search: "foo ^ #",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo ^ @ -> history, in url");
+  yield check_autocomplete({
+    search: "foo ^ @",
+    matches: [ { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo ^ + -> history, is tag");
+  yield check_autocomplete({
+    search: "foo ^ +",
+    matches: [ { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo ^ ~ -> history, is typed");
+  yield check_autocomplete({
+    search: "foo ^ ~",
+    matches: [ { uri: uri4, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo * # -> is star, in title");
+  yield check_autocomplete({
+    search: "foo * #",
+    matches: [ { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo * @ -> is star, in url");
+  yield check_autocomplete({
+    search: "foo * @",
+    matches: [ { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo * + -> same as +");
+  yield check_autocomplete({
+    search: "foo * +",
+    matches: [ { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo * ~ -> is star, is typed");
+  yield check_autocomplete({
+    search: "foo * ~",
+    matches: [ { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo # @ -> in title, in url");
+  yield check_autocomplete({
+    search: "foo # @",
+    matches: [ { uri: uri4, title: "foo.bar" },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo # + -> in title, is tag");
+  yield check_autocomplete({
+    search: "foo # +",
+    matches: [ { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo # ~ -> in title, is typed");
+  yield check_autocomplete({
+    search: "foo # ~",
+    matches: [ { uri: uri4, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo @ + -> in url, is tag");
+  yield check_autocomplete({
+    search: "foo @ +",
+    matches: [ { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo @ ~ -> in url, is typed");
+  yield check_autocomplete({
+    search: "foo @ ~",
+    matches: [ { uri: uri4, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  do_print("foo + ~ -> is tag, is typed");
+  yield check_autocomplete({
+    search: "foo + ~",
+    matches: [ { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "tag" ] } ]
+  });
+
+  // Disable autoFill for the next tests, see test_autoFill_default_behavior.js
+  // for specific tests.
+  Services.prefs.setBoolPref("browser.urlbar.autoFill", false);
+
+  // Test default usage by setting certain browser.urlbar.suggest.* prefs
+  do_print("foo -> default history");
+  setSuggestPrefsToFalse();
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", true);
+  yield check_autocomplete({
+    search: "foo",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: ["foo.bar"], style: [ "tag" ] } ]
+  });
+
+  do_print("foo -> default history, is star");
+  setSuggestPrefsToFalse();
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", true);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", true);
+  yield check_autocomplete({
+    search: "foo",
+    matches: [ { uri: uri2, title: "foo.bar" },
+               { uri: uri3, title: "title" },
+               { uri: uri4, title: "foo.bar" },
+               { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar"], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo -> default history, is star, is typed");
+  setSuggestPrefsToFalse();
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", true);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history.onlyTyped", true);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", true);
+  yield check_autocomplete({
+    search: "foo",
+    matches: [ { uri: uri4, title: "foo.bar" },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo -> is star");
+  setSuggestPrefsToFalse();
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history", false);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", true);
+  yield check_autocomplete({
+    search: "foo",
+    matches: [ { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("foo -> is star, is typed");
+  setSuggestPrefsToFalse();
+  // only typed should be ignored
+  Services.prefs.setBoolPref("browser.urlbar.suggest.history.onlyTyped", true);
+  Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", true);
+  yield check_autocomplete({
+    search: "foo",
+    matches: [ { uri: uri6, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri7, title: "title", style: [ "bookmark" ] },
+               { uri: uri8, title: "foo.bar", style: [ "bookmark" ] },
+               { uri: uri9, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri11, title: "title", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] },
+               { uri: uri12, title: "foo.bar", tags: [ "foo.bar" ], style: [ "bookmark-tag" ] }  ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_swap_protocol.js b/toolkit/components/places/tests/unifiedcomplete/test_swap_protocol.js
new file mode 100644
index 000000000..89ccc3206
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_swap_protocol.js
@@ -0,0 +1,153 @@
+/* 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/. */
+
+/**
+ * Test bug 424717 to make sure searching with an existing location like
+ * http://site/ also matches https://site/ or ftp://site/. Same thing for
+ * ftp://site/ and https://site/.
+ *
+ * Test bug 461483 to make sure a search for "w" doesn't match the "www." from
+ * site subdomains.
+ */
+
+add_task(function* test_swap_protocol() {
+  let uri1 = NetUtil.newURI("http://www.site/");
+  let uri2 = NetUtil.newURI("http://site/");
+  let uri3 = NetUtil.newURI("ftp://ftp.site/");
+  let uri4 = NetUtil.newURI("ftp://site/");
+  let uri5 = NetUtil.newURI("https://www.site/");
+  let uri6 = NetUtil.newURI("https://site/");
+  let uri7 = NetUtil.newURI("http://woohoo/");
+  let uri8 = NetUtil.newURI("http://wwwwwwacko/");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "title" },
+    { uri: uri2, title: "title" },
+    { uri: uri3, title: "title" },
+    { uri: uri4, title: "title" },
+    { uri: uri5, title: "title" },
+    { uri: uri6, title: "title" },
+    { uri: uri7, title: "title" },
+    { uri: uri8, title: "title" }
+  ]);
+
+  let allMatches = [
+    { uri: uri1, title: "title" },
+    { uri: uri2, title: "title" },
+    { uri: uri3, title: "title" },
+    { uri: uri4, title: "title" },
+    { uri: uri5, title: "title" },
+    { uri: uri6, title: "title" }
+  ];
+
+  // Disable autoFill to avoid handling the first result.
+  Services.prefs.setBoolPref("browser.urlbar.autoFill", "false");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", false);
+
+  do_print("http://www.site matches all site");
+  yield check_autocomplete({
+    search: "http://www.site",
+    matches: allMatches
+  });
+
+  do_print("http://site matches all site");
+  yield check_autocomplete({
+    search: "http://site",
+    matches: allMatches
+  });
+
+  do_print("ftp://ftp.site matches itself");
+  yield check_autocomplete({
+    search: "ftp://ftp.site",
+    matches: [ { uri: uri3, title: "title" } ]
+  });
+
+  do_print("ftp://site matches all site");
+  yield check_autocomplete({
+    search: "ftp://site",
+    matches: allMatches
+  });
+
+  do_print("https://www.site matches all site");
+  yield check_autocomplete({
+    search: "https://www.site",
+    matches: allMatches
+  });
+
+  do_print("https://site matches all site");
+  yield check_autocomplete({
+    search: "https://site",
+    matches: allMatches
+  });
+
+  do_print("www.site matches all site");
+  yield check_autocomplete({
+    search: "www.site",
+    matches: allMatches
+  });
+
+  do_print("w matches none of www.");
+  yield check_autocomplete({
+    search: "w",
+    matches: [ { uri: uri7, title: "title" },
+               { uri: uri8, title: "title" } ]
+  });
+
+  do_print("http://w matches none of www.");
+  yield check_autocomplete({
+    search: "http://w",
+    matches: [ { uri: uri7, title: "title" },
+               { uri: uri8, title: "title" } ]
+  });
+
+  do_print("http://w matches none of www.");
+  yield check_autocomplete({
+    search: "http://www.w",
+    matches: [ { uri: uri7, title: "title" },
+               { uri: uri8, title: "title" } ]
+  });
+
+  do_print("ww matches none of www.");
+  yield check_autocomplete({
+    search: "ww",
+    matches: [ { uri: uri8, title: "title" } ]
+  });
+
+  do_print("ww matches none of www.");
+  yield check_autocomplete({
+    search: "ww",
+    matches: [ { uri: uri8, title: "title" } ]
+  });
+
+  do_print("http://ww matches none of www.");
+  yield check_autocomplete({
+    search: "http://ww",
+    matches: [ { uri: uri8, title: "title" } ]
+  });
+
+  do_print("http://www.ww matches none of www.");
+  yield check_autocomplete({
+    search: "http://www.ww",
+    matches: [ { uri: uri8, title: "title" } ]
+  });
+
+  do_print("www matches none of www.");
+  yield check_autocomplete({
+    search: "www",
+    matches: [ { uri: uri8, title: "title" } ]
+  });
+
+  do_print("http://www matches none of www.");
+  yield check_autocomplete({
+    search: "http://www",
+    matches: [ { uri: uri8, title: "title" } ]
+  });
+
+  do_print("http://www.www matches none of www.");
+  yield check_autocomplete({
+    search: "http://www.www",
+    matches: [ { uri: uri8, title: "title" } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_tab_matches.js b/toolkit/components/places/tests/unifiedcomplete/test_tab_matches.js
new file mode 100644
index 000000000..740b8d8ed
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_tab_matches.js
@@ -0,0 +1,164 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim:set ts=2 sw=2 sts=2 et:
+ * 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/. */
+
+var gTabRestrictChar = "%";
+
+add_task(function* test_tab_matches() {
+  let uri1 = NetUtil.newURI("http://abc.com/");
+  let uri2 = NetUtil.newURI("http://xyz.net/");
+  let uri3 = NetUtil.newURI("about:mozilla");
+  let uri4 = NetUtil.newURI("data:text/html,test");
+  let uri5 = NetUtil.newURI("http://foobar.org");
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "ABC rocks" },
+    { uri: uri2, title: "xyz.net - we're better than ABC" },
+    { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ" }
+  ]);
+  addOpenPages(uri1, 1);
+  // Pages that cannot be registered in history.
+  addOpenPages(uri3, 1);
+  addOpenPages(uri4, 1);
+
+  do_print("two results, normal result is a tab match");
+  yield check_autocomplete({
+    search: "abc.com",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("abc.com", "http://abc.com/", { heuristic: true }),
+               makeSwitchToTabMatch("http://abc.com/", { title: "ABC rocks" }),
+               makeSearchMatch("abc.com", { heuristic: false }) ]
+  });
+
+  do_print("three results, one tab match");
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("abc", { heuristic: true }),
+               makeSwitchToTabMatch("http://abc.com/", { title: "ABC rocks" }),
+               { uri: uri2, title: "xyz.net - we're better than ABC", style: [ "favicon" ] },
+               { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ", style: [ "favicon" ] } ]
+  });
+
+  do_print("three results, both normal results are tab matches");
+  addOpenPages(uri2, 1);
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("abc", { heuristic: true }),
+               makeSwitchToTabMatch("http://abc.com/", { title: "ABC rocks" }),
+               makeSwitchToTabMatch("http://xyz.net/", { title: "xyz.net - we're better than ABC" }),
+               { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ", style: [ "favicon" ] } ]
+  });
+
+  do_print("a container tab is not visible in 'switch to tab'");
+  addOpenPages(uri5, 1, /* userContextId: */ 3);
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("abc", { heuristic: true }),
+               makeSwitchToTabMatch("http://abc.com/", { title: "ABC rocks" }),
+               makeSwitchToTabMatch("http://xyz.net/", { title: "xyz.net - we're better than ABC" }),
+               { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ", style: [ "favicon" ] } ]
+  });
+
+  do_print("a container tab should not see 'switch to tab' for other container tabs");
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "enable-actions user-context-id:3",
+    matches: [ makeSearchMatch("abc", { heuristic: true }),
+               makeSwitchToTabMatch("http://foobar.org/", { title: "foobar.org - much better than ABC, definitely better than XYZ" }),
+               { uri: uri1, title: "ABC rocks", style: [ "favicon" ] },
+               { uri: uri2, title: "xyz.net - we're better than ABC", style: [ "favicon" ] } ]
+  });
+
+  do_print("a different container tab should not see any 'switch to tab'");
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "enable-actions user-context-id:2",
+    matches: [ makeSearchMatch("abc", { heuristic: true }),
+               { uri: uri1, title: "ABC rocks", style: [ "favicon" ] },
+               { uri: uri2, title: "xyz.net - we're better than ABC", style: [ "favicon" ] },
+               { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ", style: [ "favicon" ] } ]
+  });
+
+  do_print("three results, both normal results are tab matches, one has multiple tabs");
+  addOpenPages(uri2, 5);
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("abc", { heuristic: true }),
+               makeSwitchToTabMatch("http://abc.com/", { title: "ABC rocks" }),
+               makeSwitchToTabMatch("http://xyz.net/", { title: "xyz.net - we're better than ABC" }),
+               { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ", style: [ "favicon" ] } ]
+  });
+
+  do_print("three results, no tab matches (disable-private-actions)");
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "enable-actions disable-private-actions",
+    matches: [ makeSearchMatch("abc", { heuristic: true }),
+               { uri: uri1, title: "ABC rocks", style: [ "favicon" ] },
+               { uri: uri2, title: "xyz.net - we're better than ABC", style: [ "favicon" ] },
+               { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ", style: [ "favicon" ] } ]
+  });
+
+  do_print("two results (actions disabled)");
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "",
+    matches: [ { uri: uri1, title: "ABC rocks", style: [ "favicon" ] },
+               { uri: uri2, title: "xyz.net - we're better than ABC", style: [ "favicon" ] },
+               { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ", style: [ "favicon" ] } ]
+  });
+
+  do_print("three results, no tab matches");
+  removeOpenPages(uri1, 1);
+  removeOpenPages(uri2, 6);
+  yield check_autocomplete({
+    search: "abc",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("abc", { heuristic: true }),
+               { uri: uri1, title: "ABC rocks", style: [ "favicon" ] },
+               { uri: uri2, title: "xyz.net - we're better than ABC", style: [ "favicon" ] },
+               { uri: uri5, title: "foobar.org - much better than ABC, definitely better than XYZ", style: [ "favicon" ] } ]
+  });
+
+  do_print("tab match search with restriction character");
+  addOpenPages(uri1, 1);
+  yield check_autocomplete({
+    search: gTabRestrictChar + " abc",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch(gTabRestrictChar + " abc", { heuristic: true }),
+               makeSwitchToTabMatch("http://abc.com/", { title: "ABC rocks" }) ]
+  });
+
+  do_print("tab match with not-addable pages");
+  yield check_autocomplete({
+    search: "mozilla",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("mozilla", { heuristic: true }),
+               makeSwitchToTabMatch("about:mozilla") ]
+  });
+
+  do_print("tab match with not-addable pages and restriction character");
+  yield check_autocomplete({
+    search: gTabRestrictChar + " mozilla",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch(gTabRestrictChar + " mozilla", { heuristic: true }),
+               makeSwitchToTabMatch("about:mozilla") ]
+  });
+
+  do_print("tab match with not-addable pages and only restriction character");
+  yield check_autocomplete({
+    search: gTabRestrictChar,
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch(gTabRestrictChar, { heuristic: true }),
+               makeSwitchToTabMatch("http://abc.com/", { title: "ABC rocks" }),
+               makeSwitchToTabMatch("about:mozilla"),
+               makeSwitchToTabMatch("data:text/html,test") ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_trimming.js b/toolkit/components/places/tests/unifiedcomplete/test_trimming.js
new file mode 100644
index 000000000..e55b009ff
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_trimming.js
@@ -0,0 +1,313 @@
+/* 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/. */
+
+add_task(function* test_untrimmed_secure_www() {
+  do_print("Searching for untrimmed https://www entry");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("https://www.mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "https://www.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_secure_www_path() {
+  do_print("Searching for untrimmed https://www entry with path");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("https://www.mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/t",
+    autofilled: "mozilla.org/test/",
+    completed: "https://www.mozilla.org/test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_secure() {
+  do_print("Searching for untrimmed https:// entry");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("https://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "https://mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_secure_path() {
+  do_print("Searching for untrimmed https:// entry with path");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("https://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/t",
+    autofilled: "mozilla.org/test/",
+    completed: "https://mozilla.org/test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_www() {
+  do_print("Searching for untrimmed http://www entry");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://www.mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "www.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_www_path() {
+  do_print("Searching for untrimmed http://www entry with path");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://www.mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/t",
+    autofilled: "mozilla.org/test/",
+    completed: "http://www.mozilla.org/test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_ftp() {
+  do_print("Searching for untrimmed ftp:// entry");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("ftp://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "ftp://mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untrimmed_ftp_path() {
+  do_print("Searching for untrimmed ftp:// entry with path");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("ftp://mozilla.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/t",
+    autofilled: "mozilla.org/test/",
+    completed: "ftp://mozilla.org/test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_priority_1() {
+  do_print("Ensuring correct priority 1");
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("https://www.mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("https://mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("ftp://mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://www.mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://mozilla.org/test/"), transition: TRANSITION_TYPED }
+  ]);
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_periority_2() {
+  do_print( "Ensuring correct priority 2");
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("https://mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("ftp://mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://www.mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://mozilla.org/test/"), transition: TRANSITION_TYPED }
+  ]);
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_periority_3() {
+  do_print("Ensuring correct priority 3");
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("ftp://mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://www.mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://mozilla.org/test/"), transition: TRANSITION_TYPED }
+  ]);
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_periority_4() {
+  do_print("Ensuring correct priority 4");
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("http://www.mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://mozilla.org/test/"), transition: TRANSITION_TYPED }
+  ]);
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_priority_5() {
+  do_print("Ensuring correct priority 5");
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("ftp://mozilla.org/test/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("ftp://www.mozilla.org/test/"), transition: TRANSITION_TYPED }
+  ]);
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "ftp://mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_priority_6() {
+  do_print("Ensuring correct priority 6");
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("http://www.mozilla.org/test1/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://www.mozilla.org/test2/"), transition: TRANSITION_TYPED }
+  ]);
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.org/",
+    completed: "www.mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_longer_domain() {
+  do_print("Ensuring longer domain can't match");
+  // The .co should be preferred, but should not get the https from the .com.
+  // The .co domain must be added later to activate the trigger bug.
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("https://mozilla.com/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://mozilla.co/"), transition: TRANSITION_TYPED },
+    { uri: NetUtil.newURI("http://mozilla.co/"), transition: TRANSITION_TYPED }
+  ]);
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "mozilla.co/",
+    completed: "mozilla.co/"
+  });
+
+  yield cleanup();
+});
+
+add_task(function* test_escaped_chars() {
+  do_print("Searching for URL with characters that are normally escaped");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("https://www.mozilla.org/啊-test"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "https://www.mozilla.org/啊-test",
+    autofilled: "https://www.mozilla.org/啊-test",
+    completed: "https://www.mozilla.org/啊-test"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_unsecure_secure() {
+  do_print("Don't return unsecure URL when searching for secure ones");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://test.moz.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "https://test.moz.org/t",
+    autofilled: "https://test.moz.org/test/",
+    completed: "https://test.moz.org/test/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_unsecure_secure_domain() {
+  do_print("Don't return unsecure domain when searching for secure ones");
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://test.moz.org/test/"),
+    transition: TRANSITION_TYPED
+  });
+  yield check_autocomplete({
+    search: "https://test.moz",
+    autofilled: "https://test.moz.org/",
+    completed: "https://test.moz.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untyped_www() {
+  do_print("Untyped is not accounted for www");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits({ uri: NetUtil.newURI("http://www.moz.org/test/") });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "moz.org/",
+    completed: "moz.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untyped_ftp() {
+  do_print("Untyped is not accounted for ftp");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits({ uri: NetUtil.newURI("ftp://moz.org/test/") });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "moz.org/",
+    completed: "moz.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untyped_secure() {
+  do_print("Untyped is not accounted for https");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits({ uri: NetUtil.newURI("https://moz.org/test/") });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "moz.org/",
+    completed: "moz.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untyped_secure_www() {
+  do_print("Untyped is not accounted for https://www");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits({ uri: NetUtil.newURI("https://www.moz.org/test/") });
+  yield check_autocomplete({
+    search: "mo",
+    autofilled: "moz.org/",
+    completed: "moz.org/"
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_typed.js b/toolkit/components/places/tests/unifiedcomplete/test_typed.js
new file mode 100644
index 000000000..72f76159c
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_typed.js
@@ -0,0 +1,84 @@
+/* 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/. */
+
+// First do searches with typed behavior forced to false, so later tests will
+// ensure autocomplete is able to dinamically switch behavior.
+
+const FAVICON_HREF = NetUtil.newURI(do_get_file("../favicons/favicon-normal16.png")).spec;
+
+add_task(function* test_domain() {
+  do_print("Searching for domain should autoFill it");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://mozilla.org/link/"));
+  yield setFaviconForHref("http://mozilla.org/link/", FAVICON_HREF);
+  yield check_autocomplete({
+    search: "moz",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/",
+    icon: "moz-anno:favicon:" + FAVICON_HREF
+  });
+  yield cleanup();
+});
+
+add_task(function* test_url() {
+  do_print("Searching for url should autoFill it");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://mozilla.org/link/"));
+  yield setFaviconForHref("http://mozilla.org/link/", FAVICON_HREF);
+  yield check_autocomplete({
+    search: "mozilla.org/li",
+    autofilled: "mozilla.org/link/",
+    completed: "http://mozilla.org/link/",
+    icon: "moz-anno:favicon:" + FAVICON_HREF
+  });
+  yield cleanup();
+});
+
+// Now do searches with typed behavior forced to true.
+
+add_task(function* test_untyped_domain() {
+  do_print("Searching for non-typed domain should not autoFill it");
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://mozilla.org/link/"));
+  yield check_autocomplete({
+    search: "moz",
+    autofilled: "moz",
+    completed: "moz"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_typed_domain() {
+  do_print("Searching for typed domain should autoFill it");
+  yield PlacesTestUtils.addVisits({ uri: NetUtil.newURI("http://mozilla.org/typed/"),
+                           transition: TRANSITION_TYPED });
+  yield check_autocomplete({
+    search: "moz",
+    autofilled: "mozilla.org/",
+    completed: "mozilla.org/"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_untyped_url() {
+  do_print("Searching for non-typed url should not autoFill it");
+  yield PlacesTestUtils.addVisits(NetUtil.newURI("http://mozilla.org/link/"));
+  yield check_autocomplete({
+    search: "mozilla.org/li",
+    autofilled: "mozilla.org/li",
+    completed: "mozilla.org/li"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_typed_url() {
+  do_print("Searching for typed url should autoFill it");
+  yield PlacesTestUtils.addVisits({ uri: NetUtil.newURI("http://mozilla.org/link/"),
+                           transition: TRANSITION_TYPED });
+  yield check_autocomplete({
+    search: "mozilla.org/li",
+    autofilled: "mozilla.org/link/",
+    completed: "http://mozilla.org/link/"
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_visit_url.js b/toolkit/components/places/tests/unifiedcomplete/test_visit_url.js
new file mode 100644
index 000000000..eaccb23e5
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_visit_url.js
@@ -0,0 +1,186 @@
+add_task(function*() {
+  do_print("visit url, no protocol");
+  yield check_autocomplete({
+    search: "mozilla.org",
+    searchParam: "enable-actions",
+    matches: [
+      { uri: makeActionURI("visiturl", {url: "http://mozilla.org/", input: "mozilla.org"}), title: "http://mozilla.org/", style: [ "action", "visiturl", "heuristic" ] },
+      { uri: makeActionURI("searchengine", {engineName: "MozSearch", input: "mozilla.org", searchQuery: "mozilla.org"}), title: "MozSearch", style: ["action", "searchengine"] }
+    ]
+  });
+
+  do_print("visit url, no protocol but with 2 dots");
+  yield check_autocomplete({
+    search: "www.mozilla.org",
+    searchParam: "enable-actions",
+    matches: [
+      { uri: makeActionURI("visiturl", {url: "http://www.mozilla.org/", input: "www.mozilla.org"}), title: "http://www.mozilla.org/", style: [ "action", "visiturl", "heuristic" ] },
+      { uri: makeActionURI("searchengine", {engineName: "MozSearch", input: "www.mozilla.org", searchQuery: "www.mozilla.org"}), title: "MozSearch", style: ["action", "searchengine"] }
+    ]
+  });
+
+  do_print("visit url, no protocol but with 3 dots");
+  yield check_autocomplete({
+    search: "www.mozilla.org.tw",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("visiturl", {url: "http://www.mozilla.org.tw/", input: "www.mozilla.org.tw"}), title: "http://www.mozilla.org.tw/", style: [ "action", "visiturl", "heuristic" ] } ]
+  });
+
+  do_print("visit url, with protocol but with 2 dots");
+  yield check_autocomplete({
+    search: "https://www.mozilla.org",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("visiturl", {url: "https://www.mozilla.org/", input: "https://www.mozilla.org"}), title: "https://www.mozilla.org/", style: [ "action", "visiturl", "heuristic" ] } ]
+  });
+
+  do_print("visit url, with protocol but with 3 dots");
+  yield check_autocomplete({
+    search: "https://www.mozilla.org.tw",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("visiturl", {url: "https://www.mozilla.org.tw/", input: "https://www.mozilla.org.tw"}), title: "https://www.mozilla.org.tw/", style: [ "action", "visiturl", "heuristic" ] } ]
+  });
+
+  do_print("visit url, with protocol");
+  yield check_autocomplete({
+    search: "https://mozilla.org",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("visiturl", {url: "https://mozilla.org/", input: "https://mozilla.org"}), title: "https://mozilla.org/", style: [ "action", "visiturl", "heuristic" ] } ]
+  });
+
+  do_print("visit url, about: protocol (no host)");
+  yield check_autocomplete({
+    search: "about:config",
+    searchParam: "enable-actions",
+    matches: [ { uri: makeActionURI("visiturl", {url: "about:config", input: "about:config"}), title: "about:config", style: [ "action", "visiturl", "heuristic" ] } ]
+  });
+
+  // This is distinct because of how we predict being able to url autofill via
+  // host lookups.
+  do_print("visit url, host matching visited host but not visited url");
+  yield PlacesTestUtils.addVisits([
+    { uri: NetUtil.newURI("http://mozilla.org/wine/"), title: "Mozilla Wine", transition: TRANSITION_TYPED },
+  ]);
+  yield check_autocomplete({
+    search: "mozilla.org/rum",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("mozilla.org/rum", "http://mozilla.org/rum", { heuristic: true }) ]
+  });
+
+  // And hosts with no dot in them are special, due to requiring whitelisting.
+  do_print("non-whitelisted host");
+  yield check_autocomplete({
+    search: "firefox",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("firefox", { heuristic: true }) ]
+  });
+
+  do_print("url with non-whitelisted host");
+  yield check_autocomplete({
+    search: "firefox/get",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("firefox/get", "http://firefox/get", { heuristic: true }) ]
+  });
+
+  Services.prefs.setBoolPref("browser.fixup.domainwhitelist.firefox", true);
+  do_register_cleanup(() => {
+    Services.prefs.clearUserPref("browser.fixup.domainwhitelist.firefox");
+  });
+
+  do_print("whitelisted host");
+  yield check_autocomplete({
+    search: "firefox",
+    searchParam: "enable-actions",
+    matches: [
+      makeVisitMatch("firefox", "http://firefox/", { heuristic: true }),
+      makeSearchMatch("firefox", { heuristic: false })
+    ]
+  });
+
+  do_print("url with whitelisted host");
+  yield check_autocomplete({
+    search: "firefox/get",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("firefox/get", "http://firefox/get", { heuristic: true }) ]
+  });
+
+  do_print("visit url, host matching visited host but not visited url, whitelisted host");
+  Services.prefs.setBoolPref("browser.fixup.domainwhitelist.mozilla", true);
+  do_register_cleanup(() => {
+    Services.prefs.clearUserPref("browser.fixup.domainwhitelist.mozilla");
+  });
+  yield check_autocomplete({
+    search: "mozilla/rum",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("mozilla/rum", "http://mozilla/rum", { heuristic: true }) ]
+  });
+
+  // ipv4 and ipv6 literal addresses should offer to visit.
+  do_print("visit url, ipv4 literal");
+  yield check_autocomplete({
+    search: "127.0.0.1",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("127.0.0.1", "http://127.0.0.1/", { heuristic: true }) ]
+  });
+
+  do_print("visit url, ipv6 literal");
+  yield check_autocomplete({
+    search: "[2001:db8::1]",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("[2001:db8::1]", "http://[2001:db8::1]/", { heuristic: true }) ]
+  });
+
+  // Setting keyword.enabled to false should always try to visit.
+  let keywordEnabled = Services.prefs.getBoolPref("keyword.enabled");
+  Services.prefs.setBoolPref("keyword.enabled", false);
+  do_register_cleanup(() => {
+    Services.prefs.clearUserPref("keyword.enabled");
+  });
+  do_print("visit url, keyword.enabled = false");
+  yield check_autocomplete({
+    search: "bacon",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("bacon", "http://bacon/", { heuristic: true }) ]
+  });
+  do_print("visit two word query, keyword.enabled = false");
+  yield check_autocomplete({
+    search: "bacon lovers",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("bacon lovers", "bacon lovers", { heuristic: true }) ]
+  });
+  Services.prefs.setBoolPref("keyword.enabled", keywordEnabled);
+
+  do_print("visit url, scheme+host");
+  yield check_autocomplete({
+    search: "http://example",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("http://example", "http://example/", { heuristic: true }) ]
+  });
+
+  do_print("visit url, scheme+host");
+  yield check_autocomplete({
+    search: "ftp://example",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("ftp://example", "ftp://example/", { heuristic: true }) ]
+  });
+
+  do_print("visit url, host+port");
+  yield check_autocomplete({
+    search: "example:8080",
+    searchParam: "enable-actions",
+    matches: [ makeVisitMatch("example:8080", "http://example:8080/", { heuristic: true }) ]
+  });
+
+  do_print("numerical operations that look like urls should search");
+  yield check_autocomplete({
+    search: "123/12",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("123/12", { heuristic: true }) ]
+  });
+
+  do_print("numerical operations that look like urls should search");
+  yield check_autocomplete({
+    search: "123.12/12.1",
+    searchParam: "enable-actions",
+    matches: [ makeSearchMatch("123.12/12.1", { heuristic: true }) ]
+  });
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_word_boundary_search.js b/toolkit/components/places/tests/unifiedcomplete/test_word_boundary_search.js
new file mode 100644
index 000000000..f79573ae6
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_word_boundary_search.js
@@ -0,0 +1,175 @@
+/* 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/. */
+
+/**
+ * Test bug 393678 to make sure matches against the url, title, tags are only
+ * made on word boundaries instead of in the middle of words.
+ *
+ * Make sure we don't try matching one after a CamelCase because the upper-case
+ * isn't really a word boundary. (bug 429498)
+ *
+ * Bug 429531 provides switching between "must match on word boundary" and "can
+ * match," so leverage "must match" pref for checking word boundary logic and
+ * make sure "can match" matches anywhere.
+ */
+
+var katakana = ["\u30a8", "\u30c9"]; // E, Do
+var ideograph = ["\u4efb", "\u5929", "\u5802"]; // Nin Ten Do
+
+add_task(function* test_escape() {
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.searchEngines", false);
+
+  let uri1 = NetUtil.newURI("http://matchme/");
+  let uri2 = NetUtil.newURI("http://dontmatchme/");
+  let uri3 = NetUtil.newURI("http://title/1");
+  let uri4 = NetUtil.newURI("http://title/2");
+  let uri5 = NetUtil.newURI("http://tag/1");
+  let uri6 = NetUtil.newURI("http://tag/2");
+  let uri7 = NetUtil.newURI("http://crazytitle/");
+  let uri8 = NetUtil.newURI("http://katakana/");
+  let uri9 = NetUtil.newURI("http://ideograph/");
+  let uri10 = NetUtil.newURI("http://camel/pleaseMatchMe/");
+
+  yield PlacesTestUtils.addVisits([
+    { uri: uri1, title: "title1" },
+    { uri: uri2, title: "title1" },
+    { uri: uri3, title: "matchme2" },
+    { uri: uri4, title: "dontmatchme3" },
+    { uri: uri5, title: "title1" },
+    { uri: uri6, title: "title1" },
+    { uri: uri7, title: "!@#$%^&*()_+{}|:<>?word" },
+    { uri: uri8, title: katakana.join("") },
+    { uri: uri9, title: ideograph.join("") },
+    { uri: uri10, title: "title1" }
+  ]);
+  yield addBookmark( { uri: uri5, title: "title1", tags: [ "matchme2" ] } );
+  yield addBookmark( { uri: uri6, title: "title1", tags: [ "dontmatchme3" ] } );
+
+  // match only on word boundaries
+  Services.prefs.setIntPref("browser.urlbar.matchBehavior", 2);
+
+  do_print("Match 'match' at the beginning or after / or on a CamelCase");
+  yield check_autocomplete({
+    search: "match",
+    matches: [ { uri: uri1, title: "title1" },
+               { uri: uri3, title: "matchme2" },
+               { uri: uri5, title: "title1", tags: [ "matchme2" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "title1" } ]
+  });
+
+  do_print("Match 'dont' at the beginning or after /");
+  yield check_autocomplete({
+    search: "dont",
+    matches: [ { uri: uri2, title: "title1" },
+               { uri: uri4, title: "dontmatchme3" },
+               { uri: uri6, title: "title1", tags: [ "dontmatchme3" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("Match 'match' at the beginning or after / or on a CamelCase");
+  yield check_autocomplete({
+    search: "2",
+    matches: [ { uri: uri3, title: "matchme2" },
+               { uri: uri4, title: "dontmatchme3" },
+               { uri: uri5, title: "title1", tags: [ "matchme2" ], style: [ "bookmark-tag" ] },
+               { uri: uri6, title: "title1", tags: [ "dontmatchme3" ], style: [ "bookmark-tag" ] } ]
+  });
+
+  do_print("Match 't' at the beginning or after /");
+  yield check_autocomplete({
+    search: "t",
+    matches: [ { uri: uri1, title: "title1" },
+               { uri: uri2, title: "title1" },
+               { uri: uri3, title: "matchme2" },
+               { uri: uri4, title: "dontmatchme3" },
+               { uri: uri5, title: "title1", tags: [ "matchme2" ], style: [ "bookmark-tag" ] },
+               { uri: uri6, title: "title1", tags: [ "dontmatchme3" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "title1" } ]
+  });
+
+  do_print("Match 'word' after many consecutive word boundaries");
+  yield check_autocomplete({
+    search: "word",
+    matches: [ { uri: uri7, title: "!@#$%^&*()_+{}|:<>?word" } ]
+  });
+
+  do_print("Match a word boundary '/' for everything");
+  yield check_autocomplete({
+    search: "/",
+    matches: [ { uri: uri1, title: "title1" },
+               { uri: uri2, title: "title1" },
+               { uri: uri3, title: "matchme2" },
+               { uri: uri4, title: "dontmatchme3" },
+               { uri: uri5, title: "title1", tags: [ "matchme2" ], style: [ "bookmark-tag" ] },
+               { uri: uri6, title: "title1", tags: [ "dontmatchme3" ], style: [ "bookmark-tag" ] },
+               { uri: uri7, title: "!@#$%^&*()_+{}|:<>?word" },
+               { uri: uri8, title: katakana.join("") },
+               { uri: uri9, title: ideograph.join("") },
+               { uri: uri10, title: "title1" } ]
+  });
+
+  do_print("Match word boundaries '()_+' that are among word boundaries");
+  yield check_autocomplete({
+    search: "()_+",
+    matches: [ { uri: uri7, title: "!@#$%^&*()_+{}|:<>?word" } ]
+  });
+
+  do_print("Katakana characters form a string, so match the beginning");
+  yield check_autocomplete({
+    search: katakana[0],
+    matches: [ { uri: uri8, title: katakana.join("") } ]
+  });
+
+/*
+  do_print("Middle of a katakana word shouldn't be matched");
+  yield check_autocomplete({
+    search: katakana[1],
+    matches: [ ]
+  });
+*/
+ do_print("Ideographs are treated as words so 'nin' is one word");
+  yield check_autocomplete({
+    search: ideograph[0],
+    matches: [ { uri: uri9, title: ideograph.join("") } ]
+  });
+
+ do_print("Ideographs are treated as words so 'ten' is another word");
+  yield check_autocomplete({
+    search: ideograph[1],
+    matches: [ { uri: uri9, title: ideograph.join("") } ]
+  });
+
+ do_print("Ideographs are treated as words so 'do' is yet another word");
+  yield check_autocomplete({
+    search: ideograph[2],
+    matches: [ { uri: uri9, title: ideograph.join("") } ]
+  });
+
+ do_print("Extra negative assert that we don't match in the middle");
+  yield check_autocomplete({
+    search: "ch",
+    matches: [ ]
+  });
+
+ do_print("Don't match one character after a camel-case word boundary (bug 429498)");
+  yield check_autocomplete({
+    search: "atch",
+    matches: [ ]
+  });
+
+  // match against word boundaries and anywhere
+  Services.prefs.setIntPref("browser.urlbar.matchBehavior", 1);
+
+  yield check_autocomplete({
+    search: "tch",
+    matches: [ { uri: uri1, title: "title1" },
+               { uri: uri2, title: "title1" },
+               { uri: uri3, title: "matchme2" },
+               { uri: uri4, title: "dontmatchme3" },
+               { uri: uri5, title: "title1", tags: [ "matchme2" ], style: [ "bookmark-tag" ] },
+               { uri: uri6, title: "title1", tags: [ "dontmatchme3" ], style: [ "bookmark-tag" ] },
+               { uri: uri10, title: "title1" } ]
+  });
+
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/test_zero_frecency.js b/toolkit/components/places/tests/unifiedcomplete/test_zero_frecency.js
new file mode 100644
index 000000000..adf638886
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/test_zero_frecency.js
@@ -0,0 +1,35 @@
+/* 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/. */
+
+// Ensure inline autocomplete doesn't return zero frecency pages.
+
+add_task(function* test_zzero_frec_domain() {
+  do_print("Searching for zero frecency domain should not autoFill it");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/framed_link/"),
+    transition: TRANSITION_FRAMED_LINK
+  });
+  yield check_autocomplete({
+    search: "moz",
+    autofilled: "moz",
+    completed:  "moz"
+  });
+  yield cleanup();
+});
+
+add_task(function* test_zzero_frec_url() {
+  do_print("Searching for zero frecency url should not autoFill it");
+  Services.prefs.setBoolPref("browser.urlbar.autoFill.typed", false);
+  yield PlacesTestUtils.addVisits({
+    uri: NetUtil.newURI("http://mozilla.org/framed_link/"),
+    transition: TRANSITION_FRAMED_LINK
+  });
+  yield check_autocomplete({
+    search: "mozilla.org/f",
+    autofilled: "mozilla.org/f",
+    completed:  "mozilla.org/f"
+  });
+  yield cleanup();
+});
diff --git a/toolkit/components/places/tests/unifiedcomplete/xpcshell.ini b/toolkit/components/places/tests/unifiedcomplete/xpcshell.ini
new file mode 100644
index 000000000..60ef8c48a
--- /dev/null
+++ b/toolkit/components/places/tests/unifiedcomplete/xpcshell.ini
@@ -0,0 +1,49 @@
+[DEFAULT]
+head = head_autocomplete.js
+tail =
+skip-if = toolkit == 'android'
+support-files =
+  data/engine-rel-searchform.xml
+  data/engine-suggestions.xml
+  !/toolkit/components/places/tests/favicons/favicon-normal16.png
+
+[test_416211.js]
+[test_416214.js]
+[test_417798.js]
+[test_418257.js]
+[test_422277.js]
+[test_autocomplete_functional.js]
+[test_autocomplete_on_value_removed_479089.js]
+[test_autofill_default_behavior.js]
+[test_avoid_middle_complete.js]
+[test_avoid_stripping_to_empty_tokens.js]
+[test_casing.js]
+[test_do_not_trim.js]
+[test_download_embed_bookmarks.js]
+[test_dupe_urls.js]
+[test_empty_search.js]
+[test_enabled.js]
+[test_escape_self.js]
+[test_extension_matches.js]
+[test_ignore_protocol.js]
+[test_keyword_search.js]
+[test_keyword_search_actions.js]
+[test_keywords.js]
+[test_match_beginning.js]
+[test_multi_word_search.js]
+[test_query_url.js]
+[test_remote_tab_matches.js]
+skip-if = !sync
+[test_search_engine_alias.js]
+[test_search_engine_current.js]
+[test_search_engine_host.js]
+[test_search_engine_restyle.js]
+[test_search_suggestions.js]
+[test_special_search.js]
+[test_swap_protocol.js]
+[test_tab_matches.js]
+[test_trimming.js]
+[test_typed.js]
+[test_visit_url.js]
+[test_word_boundary_search.js]
+[test_zero_frecency.js]
diff --git a/toolkit/components/places/tests/unit/.eslintrc.js b/toolkit/components/places/tests/unit/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/places/tests/unit/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/places/tests/unit/bookmarks.corrupt.html b/toolkit/components/places/tests/unit/bookmarks.corrupt.html
new file mode 100644
index 000000000..3cf43367f
--- /dev/null
+++ b/toolkit/components/places/tests/unit/bookmarks.corrupt.html
@@ -0,0 +1,36 @@
+<!DOCTYPE NETSCAPE-Bookmark-file-1>
+<!-- This is an automatically generated file.
+     It will be read and overwritten.
+     DO NOT EDIT! -->
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
+<TITLE>Bookmarks</TITLE>
+<H1 LAST_MODIFIED="1177541029">Bookmarks</H1>
+
+<DL><p>
+    <DT><H3 ID="rdf:#$ZvPhC3">Mozilla Firefox</H3>
+    <DL><p>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/firefox/help/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$22iCK1">Help and Tutorials</A>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/firefox/customize/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$32iCK1">Customize Firefox</A>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/firefox/community/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$42iCK1">Get Involved</A>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/about/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$52iCK1">About Us</A>
+        <DT><A HREF="b0rked" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$52iCK1">About Us</A>
+    </DL><p>
+    <DT><H3 ADD_DATE="1177541020" LAST_MODIFIED="1177541050" ID="rdf:#$74Gpx2">test</H3>
+<DD>folder test comment
+    <DL><p>
+        <DT><A HREF="http://test/post" ADD_DATE="1177375336" LAST_MODIFIED="1177375423" SHORTCUTURL="test" WEB_PANEL="true" POST_DATA="hidden1%3Dbar&amp;text1%3D%25s" LAST_CHARSET="ISO-8859-1" ID="rdf:#$pYFe7">test post keyword</A>
+<DD>item description
+    </DL>
+    <DT><H3 UNFILED_BOOKMARKS_FOLDER="true">Unsorted Bookmarks</H3>
+    <DL><p>
+        <DT><A HREF="http://example.tld">Example.tld</A>
+    </DL><p>
+    <DT><H3 LAST_MODIFIED="1177541040" PERSONAL_TOOLBAR_FOLDER="true" ID="rdf:#$FvPhC3">Bookmarks Toolbar Folder</H3>
+<DD>Add bookmarks to this folder to see them displayed on the Bookmarks Toolbar
+    <DL><p>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/firefox/central/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$GvPhC3">Getting Started</A>
+        <DT><A HREF="http://en-US.fxfeeds.mozilla.com/en-US/firefox/livebookmarks/" LAST_MODIFIED="1177541035" FEEDURL="http://en-US.fxfeeds.mozilla.com/en-US/firefox/headlines.xml" ID="rdf:#$HvPhC3">Latest Headlines</A>
+        <DT><A HREF="http://bogus-icon.mozilla.com/" ICON="b0rked" ID="rdf:#$GvPhC3">Getting Started</A>
+<DD>Livemark test comment
+    </DL><p>
+</DL><p>
diff --git a/toolkit/components/places/tests/unit/bookmarks.json b/toolkit/components/places/tests/unit/bookmarks.json
new file mode 100644
index 000000000..afe62abae
--- /dev/null
+++ b/toolkit/components/places/tests/unit/bookmarks.json
@@ -0,0 +1 @@
+{"guid":"root________","title":"","id":1,"dateAdded":1361551978957783,"lastModified":1361551978957783,"type":"text/x-moz-place-container","root":"placesRoot","children":[{"guid":"menu________","title":"Bookmarks Menu","id":2,"parent":1,"dateAdded":1361551978957783,"lastModified":1361551979382837,"type":"text/x-moz-place-container","root":"bookmarksMenuFolder","children":[{"guid":"OCyeUO5uu9FF","title":"Mozilla Firefox","id":6,"parent":2,"dateAdded":1361551979350273,"lastModified":1361551979376699,"type":"text/x-moz-place-container","children":[{"guid":"OCyeUO5uu9FG","title":"Help and Tutorials","id":7,"parent":6,"dateAdded":1361551979356436,"lastModified":1361551979362718,"type":"text/x-moz-place","uri":"http://en-us.www.mozilla.com/en-US/firefox/help/", "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="},{"guid":"OCyeUO5uu9FH","index":1,"title":"Customize Firefox","id":8,"parent":6,"dateAdded":1361551979365662,"lastModified":1361551979368077,"type":"text/x-moz-place","uri":"http://en-us.www.mozilla.com/en-US/firefox/customize/", "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="},{"guid":"OCyeUO5uu9FI","index":2,"title":"Get Involved","id":9,"parent":6,"dateAdded":1361551979371071,"lastModified":1361551979373745,"type":"text/x-moz-place","uri":"http://en-us.www.mozilla.com/en-US/firefox/community/", "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="},{"guid":"OCyeUO5uu9FJ","index":3,"title":"About Us","id":10,"parent":6,"dateAdded":1361551979376699,"lastModified":1361551979379060,"type":"text/x-moz-place","uri":"http://en-us.www.mozilla.com/en-US/about/", "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="}]},{"guid":"OCyeUO5uu9FK","index":1,"title":"","id":11,"parent":2,"dateAdded":1361551979380988,"lastModified":1361551979380988,"type":"text/x-moz-place-separator"},{"guid":"OCyeUO5uu9FL","index":2,"title":"test","id":12,"parent":2,"dateAdded":1177541020000000,"lastModified":1177541050000000,"annos":[{"name":"bookmarkProperties/description","flags":0,"expires":4,"mimeType":null,"type":3,"value":"folder test comment"}],"type":"text/x-moz-place-container","children":[{"guid":"OCyeUO5uu9GX","title":"test post keyword","id":13,"parent":12,"dateAdded":1177375336000000,"lastModified":1177375423000000,"annos":[{"name":"bookmarkProperties/description","flags":0,"expires":4,"mimeType":null,"type":3,"value":"item description"},{"name":"bookmarkProperties/POSTData","flags":0,"expires":4,"mimeType":null,"type":3,"value":"hidden1%3Dbar&text1%3D%25s"},{"name":"bookmarkProperties/loadInSidebar","flags":0,"expires":4,"mimeType":null,"type":1,"value":1}],"type":"text/x-moz-place","uri":"http://test/post","keyword":"test","charset":"ISO-8859-1"}]}]},{"index":1,"title":"Bookmarks Toolbar","id":3,"parent":1,"dateAdded":1361551978957783,"lastModified":1177541050000000,"annos":[{"name":"bookmarkProperties/description","flags":0,"expires":4,"mimeType":null,"type":3,"value":"Add bookmarks to this folder to see them displayed on the Bookmarks Toolbar"}],"type":"text/x-moz-place-container","root":"toolbarFolder","children":[{"guid":"OCyeUO5uu9FB","title":"Getting Started","id":15,"parent":3,"dateAdded":1361551979409695,"lastModified":1361551979412080,"type":"text/x-moz-place","uri":"http://en-us.www.mozilla.com/en-US/firefox/central/", "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="},{"guid":"OCyeUO5uu9FR","index":1,"title":"Latest Headlines","id":16,"parent":3,"dateAdded":1361551979451584,"lastModified":1361551979457086,"livemark":1,"annos":[{"name":"placesInternal/READ_ONLY","flags":0,"expires":4,"mimeType":null,"type":1,"value":1},{"name":"livemark/feedURI","flags":0,"expires":4,"mimeType":null,"type":3,"value":"http://en-us.fxfeeds.mozilla.com/en-US/firefox/headlines.xml"},{"name":"livemark/siteURI","flags":0,"expires":4,"mimeType":null,"type":3,"value":"http://en-us.fxfeeds.mozilla.com/en-US/firefox/livebookmarks/"}],"type":"text/x-moz-place-container","children":[]}]},{"index":2,"title":"Tags","id":4,"parent":1,"dateAdded":1361551978957783,"lastModified":1361551978957783,"type":"text/x-moz-place-container","root":"tagsFolder","children":[]},{"index":3,"title":"Unsorted Bookmarks","id":5,"parent":1,"dateAdded":1361551978957783,"lastModified":1177541050000000,"type":"text/x-moz-place-container","root":"unfiledBookmarksFolder","children":[{"guid":"OCyeUO5uu9FW","title":"Example.tld","id":14,"parent":5,"dateAdded":1361551979401846,"lastModified":1361551979402952,"type":"text/x-moz-place","uri":"http://example.tld/"}]}]}
diff --git a/toolkit/components/places/tests/unit/bookmarks.preplaces.html b/toolkit/components/places/tests/unit/bookmarks.preplaces.html
new file mode 100644
index 000000000..2e5a1baf0
--- /dev/null
+++ b/toolkit/components/places/tests/unit/bookmarks.preplaces.html
@@ -0,0 +1,35 @@
+<!DOCTYPE NETSCAPE-Bookmark-file-1>
+<!-- This is an automatically generated file.
+     It will be read and overwritten.
+     DO NOT EDIT! -->
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
+<TITLE>Bookmarks</TITLE>
+<H1 LAST_MODIFIED="1177541029">Bookmarks</H1>
+
+<DL><p>
+    <DT><H3 ID="rdf:#$ZvPhC3">Mozilla Firefox</H3>
+    <DL><p>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/firefox/help/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$22iCK1">Help and Tutorials</A>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/firefox/customize/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$32iCK1">Customize Firefox</A>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/firefox/community/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$42iCK1">Get Involved</A>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/about/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$52iCK1">About Us</A>
+    </DL><p>
+    <HR>
+    <DT><H3 ADD_DATE="1177541020" LAST_MODIFIED="1177541050" ID="rdf:#$74Gpx2">test</H3>
+<DD>folder test comment
+    <DL><p>
+        <DT><A HREF="http://test/post" ADD_DATE="1177375336" LAST_MODIFIED="1177375423" SHORTCUTURL="test" WEB_PANEL="true" POST_DATA="hidden1%3Dbar&amp;text1%3D%25s" LAST_CHARSET="ISO-8859-1" ID="rdf:#$pYFe7">test post keyword</A>
+<DD>item description
+    </DL>
+    <DT><H3 UNFILED_BOOKMARKS_FOLDER="true">Unsorted Bookmarks</H3>
+    <DL><p>
+        <DT><A HREF="http://example.tld">Example.tld</A>
+    </DL><p>
+    <DT><H3 LAST_MODIFIED="1177541040" PERSONAL_TOOLBAR_FOLDER="true" ID="rdf:#$FvPhC3">Bookmarks Toolbar Folder</H3>
+<DD>Add bookmarks to this folder to see them displayed on the Bookmarks Toolbar
+    <DL><p>
+        <DT><A HREF="http://en-US.www.mozilla.com/en-US/firefox/central/" ICON="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg==" ID="rdf:#$GvPhC3">Getting Started</A>
+        <DT><A HREF="http://en-US.fxfeeds.mozilla.com/en-US/firefox/livebookmarks/" LAST_MODIFIED="1177541035" FEEDURL="http://en-US.fxfeeds.mozilla.com/en-US/firefox/headlines.xml" ID="rdf:#$HvPhC3">Latest Headlines</A>
+<DD>Livemark test comment
+    </DL><p>
+</DL><p>
diff --git a/toolkit/components/places/tests/unit/bookmarks_html_singleframe.html b/toolkit/components/places/tests/unit/bookmarks_html_singleframe.html
new file mode 100644
index 000000000..9fe662f32
--- /dev/null
+++ b/toolkit/components/places/tests/unit/bookmarks_html_singleframe.html
@@ -0,0 +1,10 @@
+<!DOCTYPE NETSCAPE-Bookmark-file-1>
+	<HTML>
+	<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
+	<Title>Bookmarks</Title>
+	<H1>Bookmarks</H1>
+    <DT><H3>Subtitle</H3>
+	<DL><p>
+		<DT><A HREF="http://www.mozilla.org/">Mozilla</A>
+    </DL><p>
+</HTML>
diff --git a/toolkit/components/places/tests/unit/bug476292.sqlite b/toolkit/components/places/tests/unit/bug476292.sqlite
new file mode 100644
index 000000000..43130cb51
--- /dev/null
+++ b/toolkit/components/places/tests/unit/bug476292.sqlite
diff --git a/toolkit/components/places/tests/unit/corruptDB.sqlite b/toolkit/components/places/tests/unit/corruptDB.sqlite
new file mode 100644
index 000000000..b234246ca
--- /dev/null
+++ b/toolkit/components/places/tests/unit/corruptDB.sqlite
diff --git a/toolkit/components/places/tests/unit/default.sqlite b/toolkit/components/places/tests/unit/default.sqlite
new file mode 100644
index 000000000..8fbd3bc9a
--- /dev/null
+++ b/toolkit/components/places/tests/unit/default.sqlite
diff --git a/toolkit/components/places/tests/unit/head_bookmarks.js b/toolkit/components/places/tests/unit/head_bookmarks.js
new file mode 100644
index 000000000..842a66b31
--- /dev/null
+++ b/toolkit/components/places/tests/unit/head_bookmarks.js
@@ -0,0 +1,20 @@
+/* -*- 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/. */
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+// Import common head.
+{
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
+
+// Put any other stuff relative to this test folder below.
diff --git a/toolkit/components/places/tests/unit/livemark.xml b/toolkit/components/places/tests/unit/livemark.xml
new file mode 100644
index 000000000..db2ea9023
--- /dev/null
+++ b/toolkit/components/places/tests/unit/livemark.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>Livemark Feed</title>
+  <link href="https://example.com/"/>
+  <updated>2016-08-09T19:51:45.147Z</updated>
+  <author>
+    <name>John Doe</name>
+  </author>
+  <id>urn:uuid:e7947414-6ee0-4009-ae75-8b0ad3c6894b</id>
+  <entry>
+    <title>Some awesome article</title>
+    <link href="https://example.com/some-article"/>
+    <id>urn:uuid:d72ce019-0a56-4a0b-ac03-f66117d78141</id>
+    <updated>2016-08-09T19:57:22.178Z</updated>
+    <summary>My great article summary.</summary>
+  </entry>
+</feed>
diff --git a/toolkit/components/places/tests/unit/mobile_bookmarks_folder_import.json b/toolkit/components/places/tests/unit/mobile_bookmarks_folder_import.json
new file mode 100644
index 000000000..38762b3f1
--- /dev/null
+++ b/toolkit/components/places/tests/unit/mobile_bookmarks_folder_import.json
@@ -0,0 +1 @@
+{"guid":"root________","title":"","index":0,"dateAdded":1475084731479000,"lastModified":1475084731479000,"id":1,"type":"text/x-moz-place-container","root":"placesRoot","children":[{"guid":"menu________","title":"Bookmarks Menu","index":0,"dateAdded":1475084731479000,"lastModified":1475084731768000,"id":2,"type":"text/x-moz-place-container","root":"bookmarksMenuFolder","children":[{"guid":"X6lUyOspVYwi","title":"Test Pilot","index":0,"dateAdded":1475084731768000,"lastModified":1475084731768000,"id":3,"type":"text/x-moz-place","uri":"https://testpilot.firefox.com/"},{"guid":"XF4yRP6bTuil","title":"Mobile bookmarks query","index":1,"dateAdded":1475084731768000,"lastModified":1475084731768000,"id":11,"type":"text/x-moz-place","uri":"place:folder=101"}]},{"guid":"toolbar_____","title":"Bookmarks Toolbar","index":1,"dateAdded":1475084731479000,"lastModified":1475084731742000,"id":4,"type":"text/x-moz-place-container","root":"toolbarFolder","children":[{"guid":"buy7711R3ZgE","title":"MDN","index":0,"dateAdded":1475084731769000,"lastModified":1475084731769000,"id":5,"type":"text/x-moz-place","uri":"https://developer.mozilla.org"}]},{"guid":"3qmd_imziEBE","title":"Mobile Bookmarks","index":5,"dateAdded":1475084731479000,"lastModified":1475084731770000,"id":101,"annos":[{"name":"mobile/bookmarksRoot","flags":0,"expires":4,"value":1},{"name":"bookmarkProperties/description","flags":0,"expires":4,"mimeType":null,"type":3,"value":"A description of the mobile folder that should be ignored on import"}],"type":"text/x-moz-place-container","children":[{"guid":"_o8e1_zxTJFg","title":"Get Firefox!","index":0,"dateAdded":1475084731769000,"lastModified":1475084731769000,"id":7,"type":"text/x-moz-place","uri":"http://getfirefox.com/"},{"guid":"QCtSqkVYUbXB","title":"Get Thunderbird!","index":1,"dateAdded":1475084731770000,"lastModified":1475084731770000,"id":8,"type":"text/x-moz-place","uri":"http://getthunderbird.com/"}]},{"guid":"unfiled_____","title":"Other Bookmarks","index":3,"dateAdded":1475084731479000,"lastModified":1475084731742000,"id":9,"type":"text/x-moz-place-container","root":"unfiledBookmarksFolder","children":[{"guid":"KIa9iKZab2Z5","title":"Add-ons","index":0,"dateAdded":1475084731769000,"lastModified":1475084731769000,"id":10,"type":"text/x-moz-place","uri":"https://addons.mozilla.org"}]}]}
\ No newline at end of file
diff --git a/toolkit/components/places/tests/unit/mobile_bookmarks_folder_merge.json b/toolkit/components/places/tests/unit/mobile_bookmarks_folder_merge.json
new file mode 100644
index 000000000..7319a3a52
--- /dev/null
+++ b/toolkit/components/places/tests/unit/mobile_bookmarks_folder_merge.json
@@ -0,0 +1 @@
+{"guid":"root________","title":"","index":0,"dateAdded":1475084731479000,"lastModified":1475084731479000,"id":1,"type":"text/x-moz-place-container","root":"placesRoot","children":[{"guid":"menu________","title":"Bookmarks Menu","index":0,"dateAdded":1475084731479000,"lastModified":1475084731768000,"id":2,"type":"text/x-moz-place-container","root":"bookmarksMenuFolder","children":[{"guid":"Utodo9b0oVws","title":"Firefox Accounts","index":0,"dateAdded":1475084731955000,"lastModified":1475084731955000,"id":3,"type":"text/x-moz-place","uri":"https://accounts.firefox.com/"}]},{"guid":"toolbar_____","title":"Bookmarks Toolbar","index":1,"dateAdded":1475084731479000,"lastModified":1475084731742000,"id":4,"type":"text/x-moz-place-container","root":"toolbarFolder"},{"guid":"3qmd_imziEBE","title":"Mobile Bookmarks","index":5,"dateAdded":1475084731479000,"lastModified":1475084731770000,"id":5,"annos":[{"name":"mobile/bookmarksRoot","flags":0,"expires":4,"value":1},{"name":"bookmarkProperties/description","flags":0,"expires":4,"mimeType":null,"type":3,"value":"A description of the mobile folder that should be ignored on import"}],"type":"text/x-moz-place-container","children":[{"guid":"a17yW6-nTxEJ","title":"Mozilla","index":0,"dateAdded":1475084731959000,"lastModified":1475084731959000,"id":6,"type":"text/x-moz-place","uri":"https://mozilla.org/"},{"guid":"xV10h9Wi3FBM","title":"Bugzilla","index":1,"dateAdded":1475084731961000,"lastModified":1475084731961000,"id":7,"type":"text/x-moz-place","uri":"https://bugzilla.mozilla.org/"}]},{"guid":"unfiled_____","title":"Other Bookmarks","index":3,"dateAdded":1475084731479000,"lastModified":1475084731742000,"id":8,"type":"text/x-moz-place-container","root":"unfiledBookmarksFolder"}]}
\ No newline at end of file
diff --git a/toolkit/components/places/tests/unit/mobile_bookmarks_multiple_folders.json b/toolkit/components/places/tests/unit/mobile_bookmarks_multiple_folders.json
new file mode 100644
index 000000000..afe13c975
--- /dev/null
+++ b/toolkit/components/places/tests/unit/mobile_bookmarks_multiple_folders.json
@@ -0,0 +1 @@
+{"guid":"root________","title":"","index":0,"dateAdded":1475084731479000,"lastModified":1475084731479000,"id":1,"type":"text/x-moz-place-container","root":"placesRoot","children":[{"guid":"menu________","title":"Bookmarks Menu","index":0,"dateAdded":1475084731479000,"lastModified":1475084731768000,"id":2,"type":"text/x-moz-place-container","root":"bookmarksMenuFolder","children":[{"guid":"buy7711R3ZgE","title":"MDN","index":0,"dateAdded":1475084731769000,"lastModified":1475084731769000,"id":3,"type":"text/x-moz-place","uri":"https://developer.mozilla.org"},{"guid":"F_LBgd1fS_uQ","title":"Mobile bookmarks query for first folder","index":1,"dateAdded":1475084731768000,"lastModified":1475084731768000,"id":11,"type":"text/x-moz-place","uri":"place:folder=101"},{"guid":"oIpmQXMWsXvY","title":"Mobile bookmarks query for second folder","index":2,"dateAdded":1475084731768000,"lastModified":1475084731768000,"id":12,"type":"text/x-moz-place","uri":"place:folder=102"}]},{"guid":"3qmd_imziEBE","title":"Mobile Bookmarks","index":5,"dateAdded":1475084731479000,"lastModified":1475084731770000,"id":101,"annos":[{"name":"mobile/bookmarksRoot","flags":0,"expires":4,"value":1},{"name":"bookmarkProperties/description","flags":0,"expires":4,"mimeType":null,"type":3,"value":"A description of the mobile folder that should be ignored on import"}],"type":"text/x-moz-place-container","children":[{"guid":"a17yW6-nTxEJ","title":"Mozilla","index":0,"dateAdded":1475084731959000,"lastModified":1475084731959000,"id":5,"type":"text/x-moz-place","uri":"https://mozilla.org/"}]},{"guid":"toolbar_____","title":"Bookmarks Toolbar","index":1,"dateAdded":1475084731479000,"lastModified":1475084731742000,"id":6,"type":"text/x-moz-place-container","root":"toolbarFolder","children":[{"guid":"Utodo9b0oVws","title":"Firefox Accounts","index":0,"dateAdded":1475084731955000,"lastModified":1475084731955000,"id":7,"type":"text/x-moz-place","uri":"https://accounts.firefox.com/"}]},{"guid":"o4YjJpgsufU-","title":"Mobile Bookmarks","index":7,"dateAdded":1475084731479000,"lastModified":1475084731770000,"id":102,"annos":[{"name":"mobile/bookmarksRoot","flags":0,"expires":4,"value":1}],"type":"text/x-moz-place-container","children":[{"guid":"sSZ86WT9WbN3","title":"DXR","index":0,"dateAdded":1475084731769000,"lastModified":1475084731769000,"id":9,"type":"text/x-moz-place","uri":"https://dxr.mozilla.org"}]},{"guid":"unfiled_____","title":"Other Bookmarks","index":3,"dateAdded":1475084731479000,"lastModified":1475084731742000,"id":10,"type":"text/x-moz-place-container","root":"unfiledBookmarksFolder","children":[{"guid":"xV10h9Wi3FBM","title":"Bugzilla","index":1,"dateAdded":1475084731961000,"lastModified":1475084731961000,"id":11,"type":"text/x-moz-place","uri":"https://bugzilla.mozilla.org/"}]}]}
\ No newline at end of file
diff --git a/toolkit/components/places/tests/unit/mobile_bookmarks_root_import.json b/toolkit/components/places/tests/unit/mobile_bookmarks_root_import.json
new file mode 100644
index 000000000..27f5825ec
--- /dev/null
+++ b/toolkit/components/places/tests/unit/mobile_bookmarks_root_import.json
@@ -0,0 +1 @@
+{"guid":"root________","title":"","index":0,"dateAdded":1475084731479000,"lastModified":1475084731479000,"id":1,"type":"text/x-moz-place-container","root":"placesRoot","children":[{"guid":"menu________","title":"Bookmarks Menu","index":0,"dateAdded":1475084731479000,"lastModified":1475084731768000,"id":2,"type":"text/x-moz-place-container","root":"bookmarksMenuFolder","children":[{"guid":"X6lUyOspVYwi","title":"Test Pilot","index":0,"dateAdded":1475084731768000,"lastModified":1475084731768000,"id":3,"type":"text/x-moz-place","uri":"https://testpilot.firefox.com/"}]},{"guid":"toolbar_____","title":"Bookmarks Toolbar","index":1,"dateAdded":1475084731479000,"lastModified":1475084731742000,"id":4,"type":"text/x-moz-place-container","root":"toolbarFolder"},{"guid":"unfiled_____","title":"Other Bookmarks","index":3,"dateAdded":1475084731479000,"lastModified":1475084731742000,"id":5,"type":"text/x-moz-place-container","root":"unfiledBookmarksFolder"},{"guid":"mobile______","title":"Mobile Bookmarks","index":4,"dateAdded":1475084731479000,"lastModified":1475084731770000,"id":6,"annos":[{"name":"mobile/bookmarksRoot","flags":0,"expires":4,"value":1}],"type":"text/x-moz-place-container","root":"mobileFolder","children":[{"guid":"_o8e1_zxTJFg","title":"Get Firefox!","index":0,"dateAdded":1475084731769000,"lastModified":1475084731769000,"id":7,"type":"text/x-moz-place","uri":"http://getfirefox.com/"},{"guid":"QCtSqkVYUbXB","title":"Get Thunderbird!","index":1,"dateAdded":1475084731770000,"lastModified":1475084731770000,"id":8,"type":"text/x-moz-place","uri":"http://getthunderbird.com/"}]}]}
\ No newline at end of file
diff --git a/toolkit/components/places/tests/unit/mobile_bookmarks_root_merge.json b/toolkit/components/places/tests/unit/mobile_bookmarks_root_merge.json
new file mode 100644
index 000000000..85721f2fa
--- /dev/null
+++ b/toolkit/components/places/tests/unit/mobile_bookmarks_root_merge.json
@@ -0,0 +1 @@
+{"guid":"root________","title":"","index":0,"dateAdded":1475084731479000,"lastModified":1475084731479000,"id":1,"type":"text/x-moz-place-container","root":"placesRoot","children":[{"guid":"menu________","title":"Bookmarks Menu","index":0,"dateAdded":1475084731479000,"lastModified":1475084731955000,"id":2,"type":"text/x-moz-place-container","root":"bookmarksMenuFolder","children":[{"guid":"Utodo9b0oVws","title":"Firefox Accounts","index":0,"dateAdded":1475084731955000,"lastModified":1475084731955000,"id":3,"type":"text/x-moz-place","uri":"https://accounts.firefox.com/"}]},{"guid":"toolbar_____","title":"Bookmarks Toolbar","index":1,"dateAdded":1475084731479000,"lastModified":1475084731938000,"id":4,"type":"text/x-moz-place-container","root":"toolbarFolder"},{"guid":"unfiled_____","title":"Other Bookmarks","index":3,"dateAdded":1475084731479000,"lastModified":1475084731938000,"id":5,"type":"text/x-moz-place-container","root":"unfiledBookmarksFolder"},{"guid":"mobile______","title":"Mobile Bookmarks","index":4,"dateAdded":1475084731479000,"lastModified":1475084731961000,"id":6,"annos":[{"name":"mobile/bookmarksRoot","flags":0,"expires":4,"value":1}],"type":"text/x-moz-place-container","root":"mobileFolder","children":[{"guid":"a17yW6-nTxEJ","title":"Mozilla","index":0,"dateAdded":1475084731959000,"lastModified":1475084731959000,"id":7,"type":"text/x-moz-place","uri":"https://mozilla.org/"},{"guid":"xV10h9Wi3FBM","title":"Bugzilla","index":1,"dateAdded":1475084731961000,"lastModified":1475084731961000,"id":8,"type":"text/x-moz-place","uri":"https://bugzilla.mozilla.org/"}]}]}
\ No newline at end of file
diff --git a/toolkit/components/places/tests/unit/nsDummyObserver.js b/toolkit/components/places/tests/unit/nsDummyObserver.js
new file mode 100644
index 000000000..9049d04b3
--- /dev/null
+++ b/toolkit/components/places/tests/unit/nsDummyObserver.js
@@ -0,0 +1,48 @@
+/* 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/. */
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+
+// Dummy boomark/history observer
+function DummyObserver() {
+  Services.obs.notifyObservers(null, "dummy-observer-created", null);
+}
+
+DummyObserver.prototype = {
+  // history observer
+  onBeginUpdateBatch: function () {},
+  onEndUpdateBatch: function () {},
+  onVisit: function (aURI, aVisitID, aTime, aSessionID, aReferringID, aTransitionType) {
+    Services.obs.notifyObservers(null, "dummy-observer-visited", null);
+  },
+  onTitleChanged: function () {},
+  onDeleteURI: function () {},
+  onClearHistory: function () {},
+  onPageChanged: function () {},
+  onDeleteVisits: function () {},
+
+  // bookmark observer
+  // onBeginUpdateBatch: function() {},
+  // onEndUpdateBatch: function() {},
+  onItemAdded: function(aItemId, aParentId, aIndex, aItemType, aURI) {
+    Services.obs.notifyObservers(null, "dummy-observer-item-added", null);
+  },
+  onItemChanged: function () {},
+  onItemRemoved: function() {},
+  onItemVisited: function() {},
+  onItemMoved: function() {},
+
+  classID: Components.ID("62e221d3-68c3-4e1a-8943-a27beb5005fe"),
+
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsINavBookmarkObserver,
+    Ci.nsINavHistoryObserver,
+  ])
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([DummyObserver]);
diff --git a/toolkit/components/places/tests/unit/nsDummyObserver.manifest b/toolkit/components/places/tests/unit/nsDummyObserver.manifest
new file mode 100644
index 000000000..ed4d87fff
--- /dev/null
+++ b/toolkit/components/places/tests/unit/nsDummyObserver.manifest
@@ -0,0 +1,4 @@
+component 62e221d3-68c3-4e1a-8943-a27beb5005fe nsDummyObserver.js
+contract @mozilla.org/places/test/dummy-observer;1 62e221d3-68c3-4e1a-8943-a27beb5005fe
+category bookmark-observers nsDummyObserver @mozilla.org/places/test/dummy-observer;1
+category history-observers nsDummyObserver @mozilla.org/places/test/dummy-observer;1
diff --git a/toolkit/components/places/tests/unit/places.sparse.sqlite b/toolkit/components/places/tests/unit/places.sparse.sqlite
new file mode 100644
index 000000000..915089021
--- /dev/null
+++ b/toolkit/components/places/tests/unit/places.sparse.sqlite
diff --git a/toolkit/components/places/tests/unit/test_000_frecency.js b/toolkit/components/places/tests/unit/test_000_frecency.js
new file mode 100644
index 000000000..0a7347a02
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_000_frecency.js
@@ -0,0 +1,273 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/*
+
+Autocomplete Frecency Tests
+
+- add a visit for each score permutation
+- search
+- test number of matches
+- test each item's location in results
+
+*/
+
+try {
+  var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+                getService(Ci.nsINavHistoryService);
+  var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+              getService(Ci.nsINavBookmarksService);
+  var prefs = Cc["@mozilla.org/preferences-service;1"].
+              getService(Ci.nsIPrefBranch);
+} catch (ex) {
+  do_throw("Could not get services\n");
+}
+
+var bucketPrefs = [
+  [ "firstBucketCutoff", "firstBucketWeight"],
+  [ "secondBucketCutoff", "secondBucketWeight"],
+  [ "thirdBucketCutoff", "thirdBucketWeight"],
+  [ "fourthBucketCutoff", "fourthBucketWeight"],
+  [ null, "defaultBucketWeight"]
+];
+
+var bonusPrefs = {
+  embedVisitBonus: Ci.nsINavHistoryService.TRANSITION_EMBED,
+  framedLinkVisitBonus: Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK,
+  linkVisitBonus: Ci.nsINavHistoryService.TRANSITION_LINK,
+  typedVisitBonus: Ci.nsINavHistoryService.TRANSITION_TYPED,
+  bookmarkVisitBonus: Ci.nsINavHistoryService.TRANSITION_BOOKMARK,
+  downloadVisitBonus: Ci.nsINavHistoryService.TRANSITION_DOWNLOAD,
+  permRedirectVisitBonus: Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT,
+  tempRedirectVisitBonus: Ci.nsINavHistoryService.TRANSITION_REDIRECT_TEMPORARY,
+  reloadVisitBonus: Ci.nsINavHistoryService.TRANSITION_RELOAD,
+};
+
+// create test data
+var searchTerm = "frecency";
+var results = [];
+var matchCount = 0;
+var now = Date.now();
+var prefPrefix = "places.frecency.";
+
+function* task_initializeBucket(bucket) {
+  let [cutoffName, weightName] = bucket;
+  // get pref values
+  var weight = 0, cutoff = 0;
+  try {
+    weight = prefs.getIntPref(prefPrefix + weightName);
+  } catch (ex) {}
+  try {
+    cutoff = prefs.getIntPref(prefPrefix + cutoffName);
+  } catch (ex) {}
+
+  if (cutoff < 1)
+    return;
+
+  // generate a date within the cutoff period
+  var dateInPeriod = (now - ((cutoff - 1) * 86400 * 1000)) * 1000;
+
+  for (let [bonusName, visitType] of Object.entries(bonusPrefs)) {
+    var frecency = -1;
+    var calculatedURI = null;
+    var matchTitle = "";
+    var bonusValue = prefs.getIntPref(prefPrefix + bonusName);
+    // unvisited (only for first cutoff date bucket)
+    if (bonusName == "unvisitedBookmarkBonus" || bonusName == "unvisitedTypedBonus") {
+      if (cutoffName == "firstBucketCutoff") {
+        let points = Math.ceil(bonusValue / parseFloat(100.0) * weight);
+        var visitCount = 1; // bonusName == "unvisitedBookmarkBonus" ? 1 : 0;
+        frecency = Math.ceil(visitCount * points);
+        calculatedURI = uri("http://" + searchTerm + ".com/" +
+          bonusName + ":" + bonusValue + "/cutoff:" + cutoff +
+          "/weight:" + weight + "/frecency:" + frecency);
+        if (bonusName == "unvisitedBookmarkBonus") {
+          matchTitle = searchTerm + "UnvisitedBookmark";
+          bmsvc.insertBookmark(bmsvc.unfiledBookmarksFolder, calculatedURI, bmsvc.DEFAULT_INDEX, matchTitle);
+        }
+        else {
+          matchTitle = searchTerm + "UnvisitedTyped";
+          yield PlacesTestUtils.addVisits({
+            uri: calculatedURI,
+            title: matchTitle,
+            transition: visitType,
+            visitDate: now
+          });
+          histsvc.markPageAsTyped(calculatedURI);
+        }
+      }
+    }
+    else {
+      // visited
+      // visited bookmarks get the visited bookmark bonus twice
+      if (visitType == Ci.nsINavHistoryService.TRANSITION_BOOKMARK)
+        bonusValue = bonusValue * 2;
+
+      let points = Math.ceil(1 * ((bonusValue / parseFloat(100.000000)).toFixed(6) * weight) / 1);
+      if (!points) {
+        if (visitType == Ci.nsINavHistoryService.TRANSITION_EMBED ||
+            visitType == Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK ||
+            visitType == Ci.nsINavHistoryService.TRANSITION_DOWNLOAD ||
+            visitType == Ci.nsINavHistoryService.TRANSITION_RELOAD ||
+            bonusName == "defaultVisitBonus")
+          frecency = 0;
+        else
+          frecency = -1;
+      }
+      else
+        frecency = points;
+      calculatedURI = uri("http://" + searchTerm + ".com/" +
+        bonusName + ":" + bonusValue + "/cutoff:" + cutoff +
+        "/weight:" + weight + "/frecency:" + frecency);
+      if (visitType == Ci.nsINavHistoryService.TRANSITION_BOOKMARK) {
+        matchTitle = searchTerm + "Bookmarked";
+        bmsvc.insertBookmark(bmsvc.unfiledBookmarksFolder, calculatedURI, bmsvc.DEFAULT_INDEX, matchTitle);
+      }
+      else
+        matchTitle = calculatedURI.spec.substr(calculatedURI.spec.lastIndexOf("/")+1);
+      yield PlacesTestUtils.addVisits({
+        uri: calculatedURI,
+        transition: visitType,
+        visitDate: dateInPeriod
+      });
+    }
+
+    if (calculatedURI && frecency) {
+      results.push([calculatedURI, frecency, matchTitle]);
+      yield PlacesTestUtils.addVisits({
+        uri: calculatedURI,
+        title: matchTitle,
+        transition: visitType,
+        visitDate: dateInPeriod
+      });
+    }
+  }
+}
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+add_task(function* test_frecency()
+{
+  // Disable autoFill for this test.
+  Services.prefs.setBoolPref("browser.urlbar.autoFill", false);
+  do_register_cleanup(() => Services.prefs.clearUserPref("browser.urlbar.autoFill"));
+  for (let bucket of bucketPrefs) {
+    yield task_initializeBucket(bucket);
+  }
+
+  // sort results by frecency
+  results.sort((a, b) => b[1] - a[1]);
+  // Make sure there's enough results returned
+  prefs.setIntPref("browser.urlbar.maxRichResults", results.length);
+
+  // DEBUG
+  // results.every(function(el) { dump("result: " + el[1] + ": " + el[0].spec + " (" + el[2] + ")\n"); return true; })
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput(["unifiedcomplete"]);
+
+  controller.input = input;
+
+  // always search in history + bookmarks, no matter what the default is
+  prefs.setIntPref("browser.urlbar.search.sources", 3);
+  prefs.setIntPref("browser.urlbar.default.behavior", 0);
+
+  var numSearchesStarted = 0;
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  let deferred = Promise.defer();
+  input.onSearchComplete = function() {
+    do_check_eq(numSearchesStarted, 1);
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+
+    // test that all records with non-zero frecency were matched
+    do_check_eq(controller.matchCount, results.length);
+
+    // test that matches are sorted by frecency
+    for (var i = 0; i < controller.matchCount; i++) {
+      let searchURL = controller.getValueAt(i);
+      let expectURL = results[i][0].spec;
+      if (searchURL == expectURL) {
+        do_check_eq(controller.getValueAt(i), results[i][0].spec);
+        do_check_eq(controller.getCommentAt(i), results[i][2]);
+      } else {
+        // If the results didn't match exactly, perhaps it's still the right
+        // frecency just in the wrong "order" (order of same frecency is
+        // undefined), so check if frecency matches. This is okay because we
+        // can still ensure the correct number of expected frecencies.
+        let getFrecency = aURL => aURL.match(/frecency:(-?\d+)$/)[1];
+        print("### checking for same frecency between '" + searchURL +
+              "' and '" + expectURL + "'");
+        do_check_eq(getFrecency(searchURL), getFrecency(expectURL));
+      }
+    }
+    deferred.resolve();
+  };
+
+  controller.startSearch(searchTerm);
+
+  yield deferred.promise;
+});
diff --git a/toolkit/components/places/tests/unit/test_1085291.js b/toolkit/components/places/tests/unit/test_1085291.js
new file mode 100644
index 000000000..3159ff8bc
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_1085291.js
@@ -0,0 +1,42 @@
+add_task(function* () {
+  // test that nodes inserted by incremental update for bookmarks of all types
+  // have the extra bookmark properties (bookmarkGuid, dateAdded, lastModified).
+
+  // getFolderContents opens the root node.
+  let root = PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId).root;
+
+  function* insertAndTest(bmInfo) {
+    bmInfo = yield PlacesUtils.bookmarks.insert(bmInfo);
+    let node = root.getChild(root.childCount - 1);
+    Assert.equal(node.bookmarkGuid, bmInfo.guid);
+    Assert.equal(node.dateAdded, bmInfo.dateAdded * 1000);
+    Assert.equal(node.lastModified, bmInfo.lastModified * 1000);
+  }
+
+  // Normal bookmark.
+  yield insertAndTest({ parentGuid: root.bookmarkGuid
+                      , type: PlacesUtils.bookmarks.TYPE_BOOKMARK
+                      , title: "Test Bookmark"
+                      , url: "http://test.url.tld" });
+
+  // place: query
+  yield insertAndTest({ parentGuid: root.bookmarkGuid
+                      , type: PlacesUtils.bookmarks.TYPE_BOOKMARK
+                      , title: "Test Query"
+                      , url: "place:folder=BOOKMARKS_MENU" });
+
+  // folder
+  yield insertAndTest({ parentGuid: root.bookmarkGuid
+                      , type: PlacesUtils.bookmarks.TYPE_FOLDER
+                      , title: "Test Folder" });
+
+  // separator
+  yield insertAndTest({ parentGuid: root.bookmarkGuid
+                      , type: PlacesUtils.bookmarks.TYPE_SEPARATOR });
+
+  root.containerOpen = false;
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_1105208.js b/toolkit/components/places/tests/unit/test_1105208.js
new file mode 100644
index 000000000..39a27c95f
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_1105208.js
@@ -0,0 +1,24 @@
+// Test that result node for folder shortcuts get the target folder title if
+// the shortcut itself has no title set.
+add_task(function* () {
+  let shortcutInfo = yield PlacesUtils.bookmarks.insert({
+    type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: "place:folder=TOOLBAR"
+  });
+
+  let unfiledRoot =
+    PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+  let shortcutNode = unfiledRoot.getChild(unfiledRoot.childCount - 1);
+  Assert.equal(shortcutNode.bookmarkGuid, shortcutInfo.guid);
+
+  let toolbarInfo =
+    yield PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.toolbarGuid);
+  Assert.equal(shortcutNode.title, toolbarInfo.title);
+
+  unfiledRoot.containerOpen = false;
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_1105866.js b/toolkit/components/places/tests/unit/test_1105866.js
new file mode 100644
index 000000000..eb376bbe2
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_1105866.js
@@ -0,0 +1,63 @@
+add_task(function* test_folder_shortcuts() {
+  let shortcutInfo = yield PlacesUtils.bookmarks.insert({
+    type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: "place:folder=TOOLBAR"
+  });
+
+  let unfiledRoot =
+    PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+  let shortcutNode = unfiledRoot.getChild(unfiledRoot.childCount - 1);
+  Assert.strictEqual(shortcutNode.itemId,
+                     yield PlacesUtils.promiseItemId(shortcutInfo.guid));
+  Assert.strictEqual(PlacesUtils.asQuery(shortcutNode).folderItemId,
+                     PlacesUtils.toolbarFolderId);
+  Assert.strictEqual(shortcutNode.bookmarkGuid, shortcutInfo.guid);
+  Assert.strictEqual(PlacesUtils.asQuery(shortcutNode).targetFolderGuid,
+                     PlacesUtils.bookmarks.toolbarGuid);
+
+  // test that a node added incrementally also behaves just as well.
+  shortcutInfo = yield PlacesUtils.bookmarks.insert({
+    type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: "place:folder=BOOKMARKS_MENU"
+  });
+  shortcutNode = unfiledRoot.getChild(unfiledRoot.childCount - 1);
+  Assert.strictEqual(shortcutNode.itemId,
+                     yield PlacesUtils.promiseItemId(shortcutInfo.guid));
+  Assert.strictEqual(PlacesUtils.asQuery(shortcutNode).folderItemId,
+                     PlacesUtils.bookmarksMenuFolderId);
+  Assert.strictEqual(shortcutNode.bookmarkGuid, shortcutInfo.guid);
+  Assert.strictEqual(PlacesUtils.asQuery(shortcutNode).targetFolderGuid,
+                     PlacesUtils.bookmarks.menuGuid);
+
+  unfiledRoot.containerOpen = false;
+});
+
+add_task(function* test_plain_folder() {
+  let folderInfo = yield PlacesUtils.bookmarks.insert({
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid
+  });
+
+  let unfiledRoot =
+    PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+  let lastChild = unfiledRoot.getChild(unfiledRoot.childCount - 1);
+  Assert.strictEqual(lastChild.bookmarkGuid, folderInfo.guid);
+  Assert.strictEqual(PlacesUtils.asQuery(lastChild).targetFolderGuid,
+                     folderInfo.guid);
+});
+
+add_task(function* test_non_item_query() {
+  let options = PlacesUtils.history.getNewQueryOptions();
+  let root = PlacesUtils.history.executeQuery(
+    PlacesUtils.history.getNewQuery(), options).root;
+  Assert.strictEqual(root.itemId, -1);
+  Assert.strictEqual(PlacesUtils.asQuery(root).folderItemId, -1);
+  Assert.strictEqual(root.bookmarkGuid, "");
+  Assert.strictEqual(PlacesUtils.asQuery(root).targetFolderGuid, "");
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_317472.js b/toolkit/components/places/tests/unit/test_317472.js
new file mode 100644
index 000000000..a08651916
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_317472.js
@@ -0,0 +1,65 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const charset = "UTF-8";
+const CHARSET_ANNO = "URIProperties/characterSet";
+
+const TEST_URI = uri("http://foo.com");
+const TEST_BOOKMARKED_URI = uri("http://bar.com");
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  // add pages to history
+  yield PlacesTestUtils.addVisits(TEST_URI);
+  yield PlacesTestUtils.addVisits(TEST_BOOKMARKED_URI);
+
+  // create bookmarks on TEST_BOOKMARKED_URI
+  PlacesUtils.bookmarks.insertBookmark(
+              PlacesUtils.unfiledBookmarksFolderId,
+              TEST_BOOKMARKED_URI, PlacesUtils.bookmarks.DEFAULT_INDEX,
+              TEST_BOOKMARKED_URI.spec);
+  PlacesUtils.bookmarks.insertBookmark(
+              PlacesUtils.toolbarFolderId,
+              TEST_BOOKMARKED_URI, PlacesUtils.bookmarks.DEFAULT_INDEX,
+              TEST_BOOKMARKED_URI.spec);
+
+  // set charset on not-bookmarked page
+  yield PlacesUtils.setCharsetForURI(TEST_URI, charset);
+  // set charset on bookmarked page
+  yield PlacesUtils.setCharsetForURI(TEST_BOOKMARKED_URI, charset);
+
+  // check that we have created a page annotation
+  do_check_eq(PlacesUtils.annotations.getPageAnnotation(TEST_URI, CHARSET_ANNO), charset);
+
+  // get charset from not-bookmarked page
+  do_check_eq((yield PlacesUtils.getCharsetForURI(TEST_URI)), charset);
+
+  // get charset from bookmarked page
+  do_check_eq((yield PlacesUtils.getCharsetForURI(TEST_BOOKMARKED_URI)), charset);
+
+  yield PlacesTestUtils.clearHistory();
+
+  // ensure that charset has gone for not-bookmarked page
+  do_check_neq((yield PlacesUtils.getCharsetForURI(TEST_URI)), charset);
+
+  // check that page annotation has been removed
+  try {
+    PlacesUtils.annotations.getPageAnnotation(TEST_URI, CHARSET_ANNO);
+    do_throw("Charset page annotation has not been removed correctly");
+  } catch (e) {}
+
+  // ensure that charset still exists for bookmarked page
+  do_check_eq((yield PlacesUtils.getCharsetForURI(TEST_BOOKMARKED_URI)), charset);
+
+  // remove charset from bookmark and check that has gone
+  yield PlacesUtils.setCharsetForURI(TEST_BOOKMARKED_URI, "");
+  do_check_neq((yield PlacesUtils.getCharsetForURI(TEST_BOOKMARKED_URI)), charset);
+});
diff --git a/toolkit/components/places/tests/unit/test_331487.js b/toolkit/components/places/tests/unit/test_331487.js
new file mode 100644
index 000000000..55d41aebf
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_331487.js
@@ -0,0 +1,95 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get history service
+try {
+  var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].getService(Ci.nsINavHistoryService);
+} catch (ex) {
+  do_throw("Could not get history service\n");
+}
+
+var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+            getService(Ci.nsINavBookmarksService);
+
+// main
+function run_test() {
+  // add a folder
+  var folder = bmsvc.createFolder(bmsvc.placesRoot, "test folder", bmsvc.DEFAULT_INDEX);
+
+  // add a bookmark to the folder
+  var b1 = bmsvc.insertBookmark(folder, uri("http://a1.com/"),
+                                bmsvc.DEFAULT_INDEX, "1 title");
+  // add a subfolder
+  var sf1 = bmsvc.createFolder(folder, "subfolder 1", bmsvc.DEFAULT_INDEX);
+
+  // add a bookmark to the subfolder
+  var b2 = bmsvc.insertBookmark(sf1, uri("http://a2.com/"),
+                                bmsvc.DEFAULT_INDEX, "2 title");
+
+  // add a subfolder to the subfolder
+  var sf2 = bmsvc.createFolder(sf1, "subfolder 2", bmsvc.DEFAULT_INDEX);
+
+  // add a bookmark to the subfolder of the subfolder
+  var b3 = bmsvc.insertBookmark(sf2, uri("http://a3.com/"),
+                                bmsvc.DEFAULT_INDEX, "3 title");
+
+  // bookmark query that should result in the "hierarchical" result
+  // because there is one query, one folder,
+  // no begin time, no end time, no domain, no uri, no search term
+  // and no max results.  See GetSimpleBookmarksQueryFolder()
+  // for more details.
+  var options = histsvc.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  var query = histsvc.getNewQuery();
+  query.setFolders([folder], 1);
+  var result = histsvc.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 2);
+  do_check_eq(root.getChild(0).itemId, b1);
+  do_check_eq(root.getChild(1).itemId, sf1);
+
+  // check the contents of the subfolder
+  var sf1Node = root.getChild(1);
+  sf1Node = sf1Node.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  sf1Node.containerOpen = true;
+  do_check_eq(sf1Node.childCount, 2);
+  do_check_eq(sf1Node.getChild(0).itemId, b2);
+  do_check_eq(sf1Node.getChild(1).itemId, sf2);
+
+  // check the contents of the subfolder's subfolder
+  var sf2Node = sf1Node.getChild(1);
+  sf2Node = sf2Node.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  sf2Node.containerOpen = true;
+  do_check_eq(sf2Node.childCount, 1);
+  do_check_eq(sf2Node.getChild(0).itemId, b3);
+
+  sf2Node.containerOpen = false;
+  sf1Node.containerOpen = false;
+  root.containerOpen = false;
+
+  // bookmark query that should result in a flat list
+  // because we specified max results
+  options = histsvc.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  options.maxResults = 10;
+  query = histsvc.getNewQuery();
+  query.setFolders([folder], 1);
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 3);
+  do_check_eq(root.getChild(0).itemId, b1);
+  do_check_eq(root.getChild(1).itemId, b2);
+  do_check_eq(root.getChild(2).itemId, b3);
+  root.containerOpen = false;
+
+  // XXX TODO
+  // test that if we have: more than one query,
+  // multiple folders, a begin time, an end time, a domain, a uri
+  // or a search term, that we get the (correct) flat list results
+  // (like we do when specified maxResults)
+}
diff --git a/toolkit/components/places/tests/unit/test_384370.js b/toolkit/components/places/tests/unit/test_384370.js
new file mode 100644
index 000000000..ec6f43683
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_384370.js
@@ -0,0 +1,173 @@
+const LOAD_IN_SIDEBAR_ANNO = "bookmarkProperties/loadInSidebar";
+const DESCRIPTION_ANNO = "bookmarkProperties/description";
+
+var tagData = [
+  { uri: uri("http://slint.us"), tags: ["indie", "kentucky", "music"] },
+  { uri: uri("http://en.wikipedia.org/wiki/Diplodocus"), tags: ["dinosaur", "dj", "rad word"] }
+];
+
+var bookmarkData = [
+  { uri: uri("http://slint.us"), title: "indie, kentucky, music" },
+  { uri: uri("http://en.wikipedia.org/wiki/Diplodocus"), title: "dinosaur, dj, rad word" }
+];
+
+function run_test() {
+  run_next_test();
+}
+
+/*
+  HTML+FEATURES SUMMARY:
+  - import legacy bookmarks
+  - export as json, import, test (tests integrity of html > json)
+  - export as html, import, test (tests integrity of json > html)
+
+  BACKUP/RESTORE SUMMARY:
+  - create a bookmark in each root
+  - tag multiple URIs with multiple tags
+  - export as json, import, test
+*/
+add_task(function* () {
+  // Remove eventual bookmarks.exported.json.
+  let jsonFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.exported.json");
+  if ((yield OS.File.exists(jsonFile)))
+    yield OS.File.remove(jsonFile);
+
+  // Test importing a pre-Places canonical bookmarks file.
+  // Note: we do not empty the db before this import to catch bugs like 380999
+  let htmlFile = OS.Path.join(do_get_cwd().path, "bookmarks.preplaces.html");
+  yield BookmarkHTMLUtils.importFromFile(htmlFile, true);
+
+  // Populate the database.
+  for (let { uri, tags } of tagData) {
+    PlacesUtils.tagging.tagURI(uri, tags);
+  }
+  for (let { uri, title } of bookmarkData) {
+    yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                         url: uri,
+                                         title });
+  }
+  for (let { uri, title } of bookmarkData) {
+    yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+                                         url: uri,
+                                         title });
+  }
+
+  yield validate();
+
+  // Test exporting a Places canonical json file.
+  // 1. export to bookmarks.exported.json
+  yield BookmarkJSONUtils.exportToFile(jsonFile);
+  do_print("exported json");
+
+  // 2. empty bookmarks db
+  // 3. import bookmarks.exported.json
+  yield BookmarkJSONUtils.importFromFile(jsonFile, true);
+  do_print("imported json");
+
+  // 4. run the test-suite
+  yield validate();
+  do_print("validated import");
+});
+
+function* validate() {
+  yield testMenuBookmarks();
+  yield testToolbarBookmarks();
+  testUnfiledBookmarks();
+  testTags();
+  yield PlacesTestUtils.promiseAsyncUpdates();
+}
+
+// Tests a bookmarks datastore that has a set of bookmarks, etc
+// that flex each supported field and feature.
+function* testMenuBookmarks() {
+  let root = PlacesUtils.getFolderContents(PlacesUtils.bookmarksMenuFolderId).root;
+  Assert.equal(root.childCount, 3);
+
+  let separatorNode = root.getChild(1);
+  Assert.equal(separatorNode.type, separatorNode.RESULT_TYPE_SEPARATOR);
+
+  let folderNode = root.getChild(2);
+  Assert.equal(folderNode.type, folderNode.RESULT_TYPE_FOLDER);
+  Assert.equal(folderNode.title, "test");
+  let folder = yield PlacesUtils.bookmarks.fetch(folderNode.bookmarkGuid);
+  Assert.equal(folder.dateAdded.getTime(), 1177541020000);
+
+  Assert.equal(PlacesUtils.asQuery(folderNode).hasChildren, true);
+
+  Assert.equal("folder test comment",
+              PlacesUtils.annotations.getItemAnnotation(folderNode.itemId,
+                                                        DESCRIPTION_ANNO));
+
+  // open test folder, and test the children
+  folderNode.containerOpen = true;
+  Assert.equal(folderNode.childCount, 1);
+
+  let bookmarkNode = folderNode.getChild(0);
+  Assert.equal("http://test/post", bookmarkNode.uri);
+  Assert.equal("test post keyword", bookmarkNode.title);
+  Assert.ok(PlacesUtils.annotations.itemHasAnnotation(bookmarkNode.itemId,
+                                                      LOAD_IN_SIDEBAR_ANNO));
+  Assert.equal(bookmarkNode.dateAdded, 1177375336000000);
+
+  let entry = yield PlacesUtils.keywords.fetch({ url: bookmarkNode.uri });
+  Assert.equal("test", entry.keyword);
+  Assert.equal("hidden1%3Dbar&text1%3D%25s", entry.postData);
+
+  Assert.equal("ISO-8859-1",
+               (yield PlacesUtils.getCharsetForURI(NetUtil.newURI(bookmarkNode.uri))));
+  Assert.equal("item description",
+              PlacesUtils.annotations.getItemAnnotation(bookmarkNode.itemId,
+                                                        DESCRIPTION_ANNO));
+
+  folderNode.containerOpen = false;
+  root.containerOpen = false;
+}
+
+function* testToolbarBookmarks() {
+  let root = PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId).root;
+
+  // child count (add 2 for pre-existing items)
+  Assert.equal(root.childCount, bookmarkData.length + 2);
+
+  let livemarkNode = root.getChild(1);
+  Assert.equal("Latest Headlines", livemarkNode.title);
+
+  let livemark = yield PlacesUtils.livemarks.getLivemark({ id: livemarkNode.itemId });
+  Assert.equal("http://en-us.fxfeeds.mozilla.com/en-US/firefox/livebookmarks/",
+               livemark.siteURI.spec);
+  Assert.equal("http://en-us.fxfeeds.mozilla.com/en-US/firefox/headlines.xml",
+               livemark.feedURI.spec);
+
+  // test added bookmark data
+  let bookmarkNode = root.getChild(2);
+  Assert.equal(bookmarkNode.uri, bookmarkData[0].uri.spec);
+  Assert.equal(bookmarkNode.title, bookmarkData[0].title);
+  bookmarkNode = root.getChild(3);
+  Assert.equal(bookmarkNode.uri, bookmarkData[1].uri.spec);
+  Assert.equal(bookmarkNode.title, bookmarkData[1].title);
+
+  root.containerOpen = false;
+}
+
+function testUnfiledBookmarks() {
+  let root = PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+  // child count (add 1 for pre-existing item)
+  Assert.equal(root.childCount, bookmarkData.length + 1);
+  for (let i = 1; i < root.childCount; ++i) {
+    let child = root.getChild(i);
+    Assert.equal(child.uri, bookmarkData[i - 1].uri.spec);
+    Assert.equal(child.title, bookmarkData[i - 1].title);
+    if (child.tags)
+      Assert.equal(child.tags, bookmarkData[i - 1].title);
+  }
+  root.containerOpen = false;
+}
+
+function testTags() {
+  for (let { uri, tags } of tagData) {
+    do_print("Test tags for " + uri.spec + ": " + tags + "\n");
+    let foundTags = PlacesUtils.tagging.getTagsForURI(uri);
+    Assert.equal(foundTags.length, tags.length);
+    Assert.ok(tags.every(tag => foundTags.includes(tag)));
+  }
+}
diff --git a/toolkit/components/places/tests/unit/test_385397.js b/toolkit/components/places/tests/unit/test_385397.js
new file mode 100644
index 000000000..4b60d4768
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_385397.js
@@ -0,0 +1,142 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const TOTAL_SITES = 20;
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  let now = (Date.now() - 10000) * 1000;
+
+  for (let i = 0; i < TOTAL_SITES; i++) {
+    let site = "http://www.test-" + i + ".com/";
+    let testURI = uri(site);
+    let testImageURI = uri(site + "blank.gif");
+    let when = now + (i * TOTAL_SITES * 1000);
+    yield PlacesTestUtils.addVisits([
+      { uri: testURI, visitDate: when, transition: TRANSITION_TYPED },
+      { uri: testImageURI, visitDate: when + 1000, transition: TRANSITION_EMBED },
+      { uri: testImageURI, visitDate: when + 2000, transition: TRANSITION_FRAMED_LINK },
+      { uri: testURI, visitDate: when + 3000, transition: TRANSITION_LINK },
+    ]);
+  }
+
+  // verify our visits AS_VISIT, ordered by date descending
+  // including hidden
+  // we should get 80 visits:
+  // http://www.test-19.com/
+  // http://www.test-19.com/blank.gif
+  // http://www.test-19.com/
+  // http://www.test-19.com/
+  // ...
+  // http://www.test-0.com/
+  // http://www.test-0.com/blank.gif
+  // http://www.test-0.com/
+  // http://www.test-0.com/
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  options.resultType = options.RESULTS_AS_VISIT;
+  options.includeHidden = true;
+  let root = PlacesUtils.history.executeQuery(PlacesUtils.history.getNewQuery(),
+                                              options).root;
+  root.containerOpen = true;
+  let cc = root.childCount;
+  // Embed visits are not added to the database, thus they won't appear.
+  do_check_eq(cc, 3 * TOTAL_SITES);
+  for (let i = 0; i < TOTAL_SITES; i++) {
+    let index = i * 3;
+    let node = root.getChild(index);
+    let site = "http://www.test-" + (TOTAL_SITES - 1 - i) + ".com/";
+    do_check_eq(node.uri, site);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+    node = root.getChild(++index);
+    do_check_eq(node.uri, site + "blank.gif");
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+    node = root.getChild(++index);
+    do_check_eq(node.uri, site);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+  }
+  root.containerOpen = false;
+
+  // verify our visits AS_VISIT, ordered by date descending
+  // we should get 40 visits:
+  // http://www.test-19.com/
+  // http://www.test-19.com/
+  // ...
+  // http://www.test-0.com/
+  // http://www.test-0.com/
+  options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  options.resultType = options.RESULTS_AS_VISIT;
+  root = PlacesUtils.history.executeQuery(PlacesUtils.history.getNewQuery(),
+                                              options).root;
+  root.containerOpen = true;
+  cc = root.childCount;
+  // 2 * TOTAL_SITES because we count the TYPED and LINK, but not EMBED or FRAMED
+  do_check_eq(cc, 2 * TOTAL_SITES);
+  for (let i=0; i < TOTAL_SITES; i++) {
+    let index = i * 2;
+    let node = root.getChild(index);
+    let site = "http://www.test-" + (TOTAL_SITES - 1 - i) + ".com/";
+    do_check_eq(node.uri, site);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+    node = root.getChild(++index);
+    do_check_eq(node.uri, site);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+  }
+  root.containerOpen = false;
+
+  // test our optimized query for the places menu
+  // place:type=0&sort=4&maxResults=10
+  // verify our visits AS_URI, ordered by date descending
+  // we should get 10 visits:
+  // http://www.test-19.com/
+  // ...
+  // http://www.test-10.com/
+  options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  options.maxResults = 10;
+  options.resultType = options.RESULTS_AS_URI;
+  root = PlacesUtils.history.executeQuery(PlacesUtils.history.getNewQuery(),
+                                              options).root;
+  root.containerOpen = true;
+  cc = root.childCount;
+  do_check_eq(cc, options.maxResults);
+  for (let i=0; i < cc; i++) {
+    let node = root.getChild(i);
+    let site = "http://www.test-" + (TOTAL_SITES - 1 - i) + ".com/";
+    do_check_eq(node.uri, site);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+  }
+  root.containerOpen = false;
+
+  // test without a maxResults, which executes a different query
+  // but the first 10 results should be the same.
+  // verify our visits AS_URI, ordered by date descending
+  // we should get 20 visits, but the first 10 should be
+  // http://www.test-19.com/
+  // ...
+  // http://www.test-10.com/
+  options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  options.resultType = options.RESULTS_AS_URI;
+  root = PlacesUtils.history.executeQuery(PlacesUtils.history.getNewQuery(),
+                                              options).root;
+  root.containerOpen = true;
+  cc = root.childCount;
+  do_check_eq(cc, TOTAL_SITES);
+  for (let i=0; i < 10; i++) {
+    let node = root.getChild(i);
+    let site = "http://www.test-" + (TOTAL_SITES - 1 - i) + ".com/";
+    do_check_eq(node.uri, site);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+  }
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_399264_query_to_string.js b/toolkit/components/places/tests/unit/test_399264_query_to_string.js
new file mode 100644
index 000000000..6e6cc279c
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_399264_query_to_string.js
@@ -0,0 +1,51 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Obtains the id of the folder obtained from the query.
+ *
+ * @param aFolderID
+ *        The id of the folder we want to generate a query for.
+ * @returns the string representation of the query for the given folder.
+ */
+function query_string(aFolderID)
+{
+  var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+           getService(Ci.nsINavHistoryService);
+
+  var query = hs.getNewQuery();
+  query.setFolders([aFolderID], 1);
+  var options = hs.getNewQueryOptions();
+  return hs.queriesToQueryString([query], 1, options);
+}
+
+function run_test()
+{
+  var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+           getService(Ci.nsINavBookmarksService);
+
+  const QUERIES = [
+      "folder=PLACES_ROOT"
+    , "folder=BOOKMARKS_MENU"
+    , "folder=TAGS"
+    , "folder=UNFILED_BOOKMARKS"
+    , "folder=TOOLBAR"
+  ];
+  const FOLDER_IDS = [
+      bs.placesRoot
+    , bs.bookmarksMenuFolder
+    , bs.tagsFolder
+    , bs.unfiledBookmarksFolder
+    , bs.toolbarFolder
+  ];
+
+
+  for (var i = 0; i < QUERIES.length; i++) {
+    var result = query_string(FOLDER_IDS[i]);
+    dump("Looking for '" + QUERIES[i] + "' in '" + result + "'\n");
+    do_check_neq(-1, result.indexOf(QUERIES[i]));
+  }
+}
diff --git a/toolkit/components/places/tests/unit/test_399264_string_to_query.js b/toolkit/components/places/tests/unit/test_399264_string_to_query.js
new file mode 100644
index 000000000..bd29316d9
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_399264_string_to_query.js
@@ -0,0 +1,75 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Obtains the id of the folder obtained from the query.
+ *
+ * @param aQuery
+ *        The query to obtain the folder id from.
+ * @returns the folder id of the folder of the root node of the query.
+ */
+function folder_id(aQuery)
+{
+  var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+           getService(Ci.nsINavHistoryService);
+
+  dump("Checking query '" + aQuery + "'\n");
+  var options = { };
+  var queries = { };
+  var size = { };
+  hs.queryStringToQueries(aQuery, queries, size, options);
+  var result = hs.executeQueries(queries.value, size.value, options.value);
+  var root = result.root;
+  root.containerOpen = true;
+  do_check_true(root.hasChildren);
+  var folderID = root.getChild(0).parent.itemId;
+  root.containerOpen = false;
+  return folderID;
+}
+
+function run_test()
+{
+  var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+           getService(Ci.nsINavBookmarksService);
+
+  const QUERIES = [
+      "place:folder=PLACES_ROOT"
+    , "place:folder=BOOKMARKS_MENU"
+    , "place:folder=TAGS"
+    , "place:folder=UNFILED_BOOKMARKS"
+    , "place:folder=TOOLBAR"
+  ];
+  const FOLDER_IDS = [
+      bs.placesRoot
+    , bs.bookmarksMenuFolder
+    , bs.tagsFolder
+    , bs.unfiledBookmarksFolder
+    , bs.toolbarFolder
+  ];
+
+  // add something in the bookmarks menu folder so a query to it returns results
+  bs.insertBookmark(bs.bookmarksMenuFolder, uri("http://example.com/bmf/"),
+                    Ci.nsINavBookmarksService.DEFAULT_INDEX, "bmf");
+
+  // add something to the tags folder
+  var ts = Cc["@mozilla.org/browser/tagging-service;1"].
+           getService(Ci.nsITaggingService);
+  ts.tagURI(uri("http://www.example.com/"), ["tag"]);
+
+  // add something to the unfiled bookmarks folder
+  bs.insertBookmark(bs.unfiledBookmarksFolder, uri("http://example.com/ubf/"),
+                    Ci.nsINavBookmarksService.DEFAULT_INDEX, "ubf");
+
+  // add something to the toolbar folder
+  bs.insertBookmark(bs.toolbarFolder, uri("http://example.com/tf/"),
+                    Ci.nsINavBookmarksService.DEFAULT_INDEX, "tf");
+
+  for (var i = 0; i < QUERIES.length; i++) {
+    var result = folder_id(QUERIES[i]);
+    dump("expected " + FOLDER_IDS[i] + ", got " + result + "\n");
+    do_check_eq(FOLDER_IDS[i], result);
+  }
+}
diff --git a/toolkit/components/places/tests/unit/test_399266.js b/toolkit/components/places/tests/unit/test_399266.js
new file mode 100644
index 000000000..296d69414
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_399266.js
@@ -0,0 +1,78 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const TOTAL_SITES = 20;
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  let places = [];
+  for (let i = 0; i < TOTAL_SITES; i++) {
+    for (let j = 0; j <= i; j++) {
+      places.push({ uri: uri("http://www.test-" + i + ".com/"),
+                    transition: TRANSITION_TYPED });
+        // because these are embedded visits, they should not show up on our
+        // query results.  If they do, we have a problem.
+      places.push({ uri: uri("http://www.hidden.com/hidden.gif"),
+                    transition: TRANSITION_EMBED });
+      places.push({ uri: uri("http://www.alsohidden.com/hidden.gif"),
+                    transition: TRANSITION_FRAMED_LINK });
+    }
+  }
+  yield PlacesTestUtils.addVisits(places);
+
+  // test our optimized query for the "Most Visited" item
+  // in the "Smart Bookmarks" folder
+  // place:queryType=0&sort=8&maxResults=10
+  // verify our visits AS_URI, ordered by visit count descending
+  // we should get 10 visits:
+  // http://www.test-19.com/
+  // ...
+  // http://www.test-10.com/
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_VISITCOUNT_DESCENDING;
+  options.maxResults = 10;
+  options.resultType = options.RESULTS_AS_URI;
+  let root = PlacesUtils.history.executeQuery(PlacesUtils.history.getNewQuery(),
+                                              options).root;
+  root.containerOpen = true;
+  let cc = root.childCount;
+  do_check_eq(cc, options.maxResults);
+  for (let i = 0; i < cc; i++) {
+    let node = root.getChild(i);
+    let site = "http://www.test-" + (TOTAL_SITES - 1 - i) + ".com/";
+    do_check_eq(node.uri, site);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+  }
+  root.containerOpen = false;
+
+  // test without a maxResults, which executes a different query
+  // but the first 10 results should be the same.
+  // verify our visits AS_URI, ordered by visit count descending
+  // we should get 20 visits, but the first 10 should be
+  // http://www.test-19.com/
+  // ...
+  // http://www.test-10.com/
+  options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_VISITCOUNT_DESCENDING;
+  options.resultType = options.RESULTS_AS_URI;
+  root = PlacesUtils.history.executeQuery(PlacesUtils.history.getNewQuery(),
+                                              options).root;
+  root.containerOpen = true;
+  cc = root.childCount;
+  do_check_eq(cc, TOTAL_SITES);
+  for (let i = 0; i < 10; i++) {
+    let node = root.getChild(i);
+    let site = "http://www.test-" + (TOTAL_SITES - 1 - i) + ".com/";
+    do_check_eq(node.uri, site);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+  }
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_402799.js b/toolkit/components/places/tests/unit/test_402799.js
new file mode 100644
index 000000000..263e20aa5
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_402799.js
@@ -0,0 +1,62 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get history services
+try {
+  var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+                getService(Ci.nsINavHistoryService);
+  var bhist = histsvc.QueryInterface(Ci.nsIBrowserHistory);
+} catch (ex) {
+  do_throw("Could not get history services\n");
+}
+
+// Get bookmark service
+try {
+  var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+              getService(Ci.nsINavBookmarksService);
+}
+catch (ex) {
+  do_throw("Could not get the nav-bookmarks-service\n");
+}
+
+// Get tagging service
+try {
+  var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+                getService(Ci.nsITaggingService);
+} catch (ex) {
+  do_throw("Could not get tagging service\n");
+}
+
+
+// main
+function run_test() {
+  var uri1 = uri("http://foo.bar/");
+
+  // create 2 bookmarks on the same uri
+  bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri1,
+                       bmsvc.DEFAULT_INDEX, "title 1");
+  bmsvc.insertBookmark(bmsvc.toolbarFolder, uri1,
+                       bmsvc.DEFAULT_INDEX, "title 2");
+  // add some tags
+  tagssvc.tagURI(uri1, ["foo", "bar", "foobar", "foo bar"]);
+
+  // check that a generic bookmark query returns only real bookmarks
+  var options = histsvc.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+
+  var query = histsvc.getNewQuery();
+  var result = histsvc.executeQuery(query, options);
+  var root = result.root;
+
+  root.containerOpen = true;
+  var cc = root.childCount;
+  do_check_eq(cc, 2);
+  var node1 = root.getChild(0);
+  do_check_eq(bmsvc.getFolderIdForItem(node1.itemId), bmsvc.bookmarksMenuFolder);
+  var node2 = root.getChild(1);
+  do_check_eq(bmsvc.getFolderIdForItem(node2.itemId), bmsvc.toolbarFolder);
+  root.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/unit/test_405497.js b/toolkit/components/places/tests/unit/test_405497.js
new file mode 100644
index 000000000..951302b84
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_405497.js
@@ -0,0 +1,57 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+         getService(Ci.nsINavBookmarksService);
+
+/**
+ * The callback object for runInBatchMode.
+ *
+ * @param aService
+ *        Takes a reference to the history service or the bookmark service.
+ *        This determines which service should be called when calling the second
+ *        runInBatchMode the second time.
+ */
+function callback(aService)
+{
+  this.callCount = 0;
+  this.service = aService;
+}
+callback.prototype = {
+  // nsINavHistoryBatchCallback
+
+  runBatched: function(aUserData)
+  {
+    this.callCount++;
+
+    if (this.callCount == 1) {
+      // We want to call run in batched once more.
+      this.service.runInBatchMode(this, null);
+      return;
+    }
+
+    do_check_eq(this.callCount, 2);
+    do_test_finished();
+  },
+
+  // nsISupports
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryBatchCallback])
+};
+
+function run_test() {
+  // checking the history service
+  do_test_pending();
+  hs.runInBatchMode(new callback(hs), null);
+
+  // checking the bookmark service
+  do_test_pending();
+  bs.runInBatchMode(new callback(bs), null);
+}
diff --git a/toolkit/components/places/tests/unit/test_408221.js b/toolkit/components/places/tests/unit/test_408221.js
new file mode 100644
index 000000000..2b41ce1a2
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_408221.js
@@ -0,0 +1,165 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var current_test = 0;
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+// Get tagging service
+try {
+  var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+                getService(Ci.nsITaggingService);
+} catch (ex) {
+  do_throw("Could not get tagging service\n");
+}
+
+function ensure_tag_results(uris, searchTerm)
+{
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput(["unifiedcomplete"]);
+
+  controller.input = input;
+
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  var numSearchesStarted = 0;
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  input.onSearchComplete = function() {
+    do_check_eq(numSearchesStarted, 1);
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+    do_check_eq(controller.matchCount, uris.length);
+    let vals = [];
+    for (let i=0; i<controller.matchCount; i++) {
+      // Keep the URL for later because order of tag results is undefined
+      vals.push(controller.getValueAt(i));
+      do_check_eq(controller.getStyleAt(i), "bookmark-tag");
+    }
+    // Sort the results then check if we have the right items
+    vals.sort().forEach((val, i) => do_check_eq(val, uris[i].spec))
+
+    if (current_test < (tests.length - 1)) {
+      current_test++;
+      tests[current_test]();
+    }
+
+    do_test_finished();
+  };
+
+  controller.startSearch(searchTerm);
+}
+
+var uri1 = uri("http://site.tld/1");
+var uri2 = uri("http://site.tld/2");
+var uri3 = uri("http://site.tld/3");
+var uri4 = uri("http://site.tld/4");
+var uri5 = uri("http://site.tld/5");
+var uri6 = uri("http://site.tld/6");
+
+var tests = [function() { ensure_tag_results([uri1, uri2, uri3], "foo"); },
+             function() { ensure_tag_results([uri1, uri2, uri3], "Foo"); },
+             function() { ensure_tag_results([uri1, uri2, uri3], "foO"); },
+             function() { ensure_tag_results([uri4, uri5, uri6], "bar mud"); },
+             function() { ensure_tag_results([uri4, uri5, uri6], "BAR MUD"); },
+             function() { ensure_tag_results([uri4, uri5, uri6], "Bar Mud"); }];
+
+/**
+ * Properly tags a uri adding it to bookmarks.
+ *
+ * @param aURI
+ *        The nsIURI to tag.
+ * @param aTags
+ *        The tags to add.
+ */
+function tagURI(aURI, aTags) {
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       aURI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "A title");
+  tagssvc.tagURI(aURI, aTags);
+}
+
+/**
+ * Test bug #408221
+ */
+function run_test() {
+  // always search in history + bookmarks, no matter what the default is
+  var prefs = Cc["@mozilla.org/preferences-service;1"].
+              getService(Ci.nsIPrefBranch);
+  prefs.setIntPref("browser.urlbar.search.sources", 3);
+  prefs.setIntPref("browser.urlbar.default.behavior", 0);
+
+  tagURI(uri1, ["Foo"]);
+  tagURI(uri2, ["FOO"]);
+  tagURI(uri3, ["foO"]);
+  tagURI(uri4, ["BAR"]);
+  tagURI(uri4, ["MUD"]);
+  tagURI(uri5, ["bar"]);
+  tagURI(uri5, ["mud"]);
+  tagURI(uri6, ["baR"]);
+  tagURI(uri6, ["muD"]);
+
+  tests[0]();
+}
diff --git a/toolkit/components/places/tests/unit/test_412132.js b/toolkit/components/places/tests/unit/test_412132.js
new file mode 100644
index 000000000..827391f18
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_412132.js
@@ -0,0 +1,136 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/*
+ * TEST DESCRIPTION:
+ *
+ * Tests patch to Bug 412132:
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=412132
+ */
+
+add_task(function* changeuri_unvisited_bookmark()
+{
+  do_print("After changing URI of bookmark, frecency of bookmark's " +
+           "original URI should be zero if original URI is unvisited and " +
+           "no longer bookmarked.");
+  const TEST_URI = NetUtil.newURI("http://example.com/1");
+  let id = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                TEST_URI,
+                                                PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                "bookmark title");
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Bookmarked => frecency of URI should be != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  PlacesUtils.bookmarks.changeBookmarkURI(id, uri("http://example.com/2"));
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Unvisited URI no longer bookmarked => frecency should = 0");
+  do_check_eq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* changeuri_visited_bookmark()
+{
+  do_print("After changing URI of bookmark, frecency of bookmark's " +
+           "original URI should not be zero if original URI is visited.");
+  const TEST_URI = NetUtil.newURI("http://example.com/1");
+  let id = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                TEST_URI,
+                                                PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                "bookmark title");
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Bookmarked => frecency of URI should be != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesTestUtils.addVisits(TEST_URI);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  PlacesUtils.bookmarks.changeBookmarkURI(id, uri("http://example.com/2"));
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("*Visited* URI no longer bookmarked => frecency should != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* changeuri_bookmark_still_bookmarked()
+{
+  do_print("After changing URI of bookmark, frecency of bookmark's " +
+           "original URI should not be zero if original URI is still " +
+           "bookmarked.");
+  const TEST_URI = NetUtil.newURI("http://example.com/1");
+  let id1 = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                 TEST_URI,
+                                                 PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                 "bookmark 1 title");
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       TEST_URI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "bookmark 2 title");
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Bookmarked => frecency of URI should be != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  PlacesUtils.bookmarks.changeBookmarkURI(id1, uri("http://example.com/2"));
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("URI still bookmarked => frecency should != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* changeuri_nonexistent_bookmark()
+{
+  do_print("Changing the URI of a nonexistent bookmark should fail.");
+  function tryChange(itemId)
+  {
+    try {
+      PlacesUtils.bookmarks.changeBookmarkURI(itemId + 1, uri("http://example.com/2"));
+      do_throw("Nonexistent bookmark should throw.");
+    }
+    catch (ex) {}
+  }
+
+  // First try a straight-up bogus item ID, one greater than the current max
+  // ID.
+  let stmt = DBConn().createStatement("SELECT MAX(id) FROM moz_bookmarks");
+  stmt.executeStep();
+  let maxId = stmt.getInt32(0);
+  stmt.finalize();
+  tryChange(maxId + 1);
+
+  // Now add a bookmark, delete it, and check.
+  let id = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                uri("http://example.com/"),
+                                                PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                "bookmark title");
+  PlacesUtils.bookmarks.removeItem(id);
+  tryChange(id);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
+
+function run_test()
+{
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_413784.js b/toolkit/components/places/tests/unit/test_413784.js
new file mode 100644
index 000000000..6df4dfbbb
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_413784.js
@@ -0,0 +1,118 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/*
+
+Test autocomplete for non-English URLs
+
+- add a visit for a page with a non-English URL
+- search
+- test number of matches (should be exactly one)
+
+*/
+
+var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+              getService(Ci.nsINavHistoryService);
+var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+            getService(Ci.nsINavBookmarksService);
+
+// create test data
+var searchTerm = "ユニコード";
+var decoded = "http://www.foobar.com/" + searchTerm + "/";
+var url = uri(decoded);
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+function run_test()
+{
+  do_test_pending();
+  PlacesTestUtils.addVisits(url).then(continue_test);
+}
+
+function continue_test()
+{
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput(["unifiedcomplete"]);
+
+  controller.input = input;
+
+  var numSearchesStarted = 0;
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  input.onSearchComplete = function() {
+    do_check_eq(numSearchesStarted, 1);
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+
+    // test that we found the entry we added
+    do_check_eq(controller.matchCount, 1);
+
+    // Make sure the url is the same according to spec, so it can be deleted
+    do_check_eq(controller.getValueAt(0), url.spec);
+
+    do_test_finished();
+  };
+
+  controller.startSearch(searchTerm);
+}
diff --git a/toolkit/components/places/tests/unit/test_415460.js b/toolkit/components/places/tests/unit/test_415460.js
new file mode 100644
index 000000000..f2e049f09
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_415460.js
@@ -0,0 +1,43 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+
+/**
+ * Checks to see that a search has exactly one result in the database.
+ *
+ * @param aTerms
+ *        The terms to search for.
+ * @returns true if the search returns one result, false otherwise.
+ */
+function search_has_result(aTerms)
+{
+  var options = hs.getNewQueryOptions();
+  options.maxResults = 1;
+  options.resultType = options.RESULTS_AS_URI;
+  var query = hs.getNewQuery();
+  query.searchTerms = aTerms;
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var cc = root.childCount;
+  root.containerOpen = false;
+  return (cc == 1);
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  const SEARCH_TERM = "ユニコード";
+  const TEST_URL = "http://example.com/" + SEARCH_TERM + "/";
+  yield PlacesTestUtils.addVisits(uri(TEST_URL));
+  do_check_true(search_has_result(SEARCH_TERM));
+});
diff --git a/toolkit/components/places/tests/unit/test_415757.js b/toolkit/components/places/tests/unit/test_415757.js
new file mode 100644
index 000000000..afd396183
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_415757.js
@@ -0,0 +1,102 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Checks to see that a URI is in the database.
+ *
+ * @param aURI
+ *        The URI to check.
+ * @returns true if the URI is in the DB, false otherwise.
+ */
+function uri_in_db(aURI) {
+  var options = PlacesUtils.history.getNewQueryOptions();
+  options.maxResults = 1;
+  options.resultType = options.RESULTS_AS_URI
+  var query = PlacesUtils.history.getNewQuery();
+  query.uri = aURI;
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var cc = root.childCount;
+  root.containerOpen = false;
+  return (cc == 1);
+}
+
+const TOTAL_SITES = 20;
+
+// main
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  // add pages to global history
+  for (let i = 0; i < TOTAL_SITES; i++) {
+    let site = "http://www.test-" + i + ".com/";
+    let testURI = uri(site);
+    let when = Date.now() * 1000 + (i * TOTAL_SITES);
+    yield PlacesTestUtils.addVisits({ uri: testURI, visitDate: when });
+  }
+  for (let i = 0; i < TOTAL_SITES; i++) {
+    let site = "http://www.test.com/" + i + "/";
+    let testURI = uri(site);
+    let when = Date.now() * 1000 + (i * TOTAL_SITES);
+    yield PlacesTestUtils.addVisits({ uri: testURI, visitDate: when });
+  }
+
+  // set a page annotation on one of the urls that will be removed
+  var testAnnoDeletedURI = uri("http://www.test.com/1/");
+  var testAnnoDeletedName = "foo";
+  var testAnnoDeletedValue = "bar";
+  PlacesUtils.annotations.setPageAnnotation(testAnnoDeletedURI,
+                                            testAnnoDeletedName,
+                                            testAnnoDeletedValue, 0,
+                                            PlacesUtils.annotations.EXPIRE_WITH_HISTORY);
+
+  // set a page annotation on one of the urls that will NOT be removed
+  var testAnnoRetainedURI = uri("http://www.test-1.com/");
+  var testAnnoRetainedName = "foo";
+  var testAnnoRetainedValue = "bar";
+  PlacesUtils.annotations.setPageAnnotation(testAnnoRetainedURI,
+                                            testAnnoRetainedName,
+                                            testAnnoRetainedValue, 0,
+                                            PlacesUtils.annotations.EXPIRE_WITH_HISTORY);
+
+  // remove pages from www.test.com
+  PlacesUtils.history.removePagesFromHost("www.test.com", false);
+
+  // check that all pages in www.test.com have been removed
+  for (let i = 0; i < TOTAL_SITES; i++) {
+    let site = "http://www.test.com/" + i + "/";
+    let testURI = uri(site);
+    do_check_false(uri_in_db(testURI));
+  }
+
+  // check that all pages in www.test-X.com have NOT been removed
+  for (let i = 0; i < TOTAL_SITES; i++) {
+    let site = "http://www.test-" + i + ".com/";
+    let testURI = uri(site);
+    do_check_true(uri_in_db(testURI));
+  }
+
+  // check that annotation on the removed item does not exists
+  try {
+    PlacesUtils.annotations.getPageAnnotation(testAnnoDeletedURI, testAnnoName);
+    do_throw("fetching page-annotation that doesn't exist, should've thrown");
+  } catch (ex) {}
+
+  // check that annotation on the NOT removed item still exists
+  try {
+    var annoVal = PlacesUtils.annotations.getPageAnnotation(testAnnoRetainedURI,
+                                                            testAnnoRetainedName);
+  } catch (ex) {
+    do_throw("The annotation has been removed erroneously");
+  }
+  do_check_eq(annoVal, testAnnoRetainedValue);
+
+});
diff --git a/toolkit/components/places/tests/unit/test_418643_removeFolderChildren.js b/toolkit/components/places/tests/unit/test_418643_removeFolderChildren.js
new file mode 100644
index 000000000..2eed02921
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_418643_removeFolderChildren.js
@@ -0,0 +1,143 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get services.
+try {
+  var histSvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+                getService(Ci.nsINavHistoryService);
+  var bmSvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+              getService(Ci.nsINavBookmarksService);
+  var annoSvc = Cc["@mozilla.org/browser/annotation-service;1"]
+                  .getService(Ci.nsIAnnotationService);
+} catch (ex) {
+  do_throw("Could not get services\n");
+}
+
+var validAnnoName = "validAnno";
+var validItemName = "validItem";
+var deletedAnnoName = "deletedAnno";
+var deletedItemName = "deletedItem";
+var bookmarkedURI = uri("http://www.mozilla.org/");
+// set lastModified to the past to prevent VM timing bugs
+var pastDate = Date.now() * 1000 - 1;
+var deletedBookmarkIds = [];
+
+// bookmarks observer
+var observer = {
+  // cached ordered array of notified items
+  _onItemRemovedItemIds: [],
+  onItemRemoved: function(aItemId, aParentId, aIndex) {
+    // We should first get notifications for children, then for their parent
+    do_check_eq(this._onItemRemovedItemIds.indexOf(aParentId), -1);
+    // Ensure we are not wrongly removing 1 level up
+    do_check_neq(aParentId, bmSvc.toolbarFolder);
+    // Removed item must be one of those we have manually deleted
+    do_check_neq(deletedBookmarkIds.indexOf(aItemId), -1);
+    this._onItemRemovedItemIds.push(aItemId);
+  },
+
+  QueryInterface: function(aIID) {
+    if (aIID.equals(Ci.nsINavBookmarkObserver) ||
+        aIID.equals(Ci.nsISupports)) {
+      return this;
+    }
+    throw Cr.NS_ERROR_NO_INTERFACE;
+  }
+};
+
+bmSvc.addObserver(observer, false);
+
+function add_bookmarks() {
+  // This is the folder we will cleanup
+  var validFolderId = bmSvc.createFolder(bmSvc.toolbarFolder,
+                                         validItemName,
+                                         bmSvc.DEFAULT_INDEX);
+  annoSvc.setItemAnnotation(validFolderId, validAnnoName,
+                            "annotation", 0,
+                            annoSvc.EXPIRE_NEVER);
+  bmSvc.setItemLastModified(validFolderId, pastDate);
+
+  // This bookmark should not be deleted
+  var validItemId = bmSvc.insertBookmark(bmSvc.toolbarFolder,
+                                         bookmarkedURI,
+                                         bmSvc.DEFAULT_INDEX,
+                                         validItemName);
+  annoSvc.setItemAnnotation(validItemId, validAnnoName,
+                            "annotation", 0, annoSvc.EXPIRE_NEVER);
+
+  // The following contents should be deleted
+  var deletedItemId = bmSvc.insertBookmark(validFolderId,
+                                           bookmarkedURI,
+                                           bmSvc.DEFAULT_INDEX,
+                                           deletedItemName);
+  annoSvc.setItemAnnotation(deletedItemId, deletedAnnoName,
+                            "annotation", 0, annoSvc.EXPIRE_NEVER);
+  deletedBookmarkIds.push(deletedItemId);
+
+  var internalFolderId = bmSvc.createFolder(validFolderId,
+                                           deletedItemName,
+                                           bmSvc.DEFAULT_INDEX);
+  annoSvc.setItemAnnotation(internalFolderId, deletedAnnoName,
+                            "annotation", 0, annoSvc.EXPIRE_NEVER);
+  deletedBookmarkIds.push(internalFolderId);
+
+  deletedItemId = bmSvc.insertBookmark(internalFolderId,
+                                       bookmarkedURI,
+                                       bmSvc.DEFAULT_INDEX,
+                                       deletedItemName);
+  annoSvc.setItemAnnotation(deletedItemId, deletedAnnoName,
+                            "annotation", 0, annoSvc.EXPIRE_NEVER);
+  deletedBookmarkIds.push(deletedItemId);
+
+  return validFolderId;
+}
+
+function check_bookmarks(aFolderId) {
+  // check that we still have valid bookmarks
+  var bookmarks = bmSvc.getBookmarkIdsForURI(bookmarkedURI);
+  for (var i = 0; i < bookmarks.length; i++) {
+    do_check_eq(bmSvc.getItemTitle(bookmarks[i]), validItemName);
+    do_check_true(annoSvc.itemHasAnnotation(bookmarks[i], validAnnoName));
+  }
+
+  // check that folder exists and has still its annotation
+  do_check_eq(bmSvc.getItemTitle(aFolderId), validItemName);
+  do_check_true(annoSvc.itemHasAnnotation(aFolderId, validAnnoName));
+
+  // check that folder is empty
+  var options = histSvc.getNewQueryOptions();
+  var query = histSvc.getNewQuery();
+  query.setFolders([aFolderId], 1);
+  var result = histSvc.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 0);
+  root.containerOpen = false;
+
+  // test that lastModified got updated
+  do_check_true(pastDate < bmSvc.getItemLastModified(aFolderId));
+
+  // test that all children have been deleted, we use annos for that
+  var deletedItems = annoSvc.getItemsWithAnnotation(deletedAnnoName);
+  do_check_eq(deletedItems.length, 0);
+
+  // test that observer has been called for (and only for) deleted items
+  do_check_eq(observer._onItemRemovedItemIds.length, deletedBookmarkIds.length);
+
+  // Sanity check: all roots should be intact
+  do_check_eq(bmSvc.getFolderIdForItem(bmSvc.placesRoot), 0);
+  do_check_eq(bmSvc.getFolderIdForItem(bmSvc.bookmarksMenuFolder), bmSvc.placesRoot);
+  do_check_eq(bmSvc.getFolderIdForItem(bmSvc.tagsFolder), bmSvc.placesRoot);
+  do_check_eq(bmSvc.getFolderIdForItem(bmSvc.unfiledBookmarksFolder), bmSvc.placesRoot);
+  do_check_eq(bmSvc.getFolderIdForItem(bmSvc.toolbarFolder), bmSvc.placesRoot);
+}
+
+// main
+function run_test() {
+  var folderId = add_bookmarks();
+  bmSvc.removeFolderChildren(folderId);
+  check_bookmarks(folderId);
+}
diff --git a/toolkit/components/places/tests/unit/test_419731.js b/toolkit/components/places/tests/unit/test_419731.js
new file mode 100644
index 000000000..b1a434e12
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_419731.js
@@ -0,0 +1,96 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function run_test() {
+  let uri1 = NetUtil.newURI("http://foo.bar/");
+
+  // create 2 bookmarks
+  let bookmark1id = PlacesUtils.bookmarks
+                               .insertBookmark(PlacesUtils.bookmarksMenuFolderId,
+                                               uri1,
+                                               PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                               "title 1");
+  let bookmark2id = PlacesUtils.bookmarks
+                               .insertBookmark(PlacesUtils.toolbarFolderId,
+                                               uri1,
+                                               PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                               "title 2");
+  // add a new tag
+  PlacesUtils.tagging.tagURI(uri1, ["foo"]);
+
+  // get tag folder id
+  let options = PlacesUtils.history.getNewQueryOptions();
+  let query = PlacesUtils.history.getNewQuery();
+  query.setFolders([PlacesUtils.tagsFolderId], 1);
+  let result = PlacesUtils.history.executeQuery(query, options);
+  let tagRoot = result.root;
+  tagRoot.containerOpen = true;
+  let tagNode = tagRoot.getChild(0)
+                       .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  let tagItemId = tagNode.itemId;
+  tagRoot.containerOpen = false;
+
+  // change bookmark 1 title
+  PlacesUtils.bookmarks.setItemTitle(bookmark1id, "new title 1");
+
+  // Workaround timers resolution and time skews.
+  let bookmark2LastMod = PlacesUtils.bookmarks.getItemLastModified(bookmark2id);
+  PlacesUtils.bookmarks.setItemLastModified(bookmark1id, bookmark2LastMod + 1000);
+
+  // Query the tag.
+  options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  options.resultType = options.RESULTS_AS_TAG_QUERY;
+
+  query = PlacesUtils.history.getNewQuery();
+  result = PlacesUtils.history.executeQuery(query, options);
+  let root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 1);
+
+  let theTag = root.getChild(0)
+                   .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  // Bug 524219: Check that renaming the tag shows up in the result.
+  do_check_eq(theTag.title, "foo")
+  PlacesUtils.bookmarks.setItemTitle(tagItemId, "bar");
+
+  // Check that the item has been replaced
+  do_check_neq(theTag, root.getChild(0));
+  theTag = root.getChild(0)
+                   .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(theTag.title, "bar");
+
+  // Check that tag container contains new title
+  theTag.containerOpen = true;
+  do_check_eq(theTag.childCount, 1);
+  let node = theTag.getChild(0);
+  do_check_eq(node.title, "new title 1");
+  theTag.containerOpen = false;
+  root.containerOpen = false;
+
+  // Change bookmark 2 title.
+  PlacesUtils.bookmarks.setItemTitle(bookmark2id, "new title 2");
+
+  // Workaround timers resolution and time skews.
+  let bookmark1LastMod = PlacesUtils.bookmarks.getItemLastModified(bookmark1id);
+  PlacesUtils.bookmarks.setItemLastModified(bookmark2id, bookmark1LastMod + 1000);
+
+  // Check that tag container contains new title
+  options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+  options.resultType = options.RESULTS_AS_TAG_CONTENTS;
+
+  query = PlacesUtils.history.getNewQuery();
+  query.setFolders([tagItemId], 1);
+  result = PlacesUtils.history.executeQuery(query, options);
+  root = result.root;
+
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 1);
+  node = root.getChild(0);
+  do_check_eq(node.title, "new title 2");
+  root.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/unit/test_419792_node_tags_property.js b/toolkit/components/places/tests/unit/test_419792_node_tags_property.js
new file mode 100644
index 000000000..4c726d667
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_419792_node_tags_property.js
@@ -0,0 +1,49 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// get services
+var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+              getService(Ci.nsINavHistoryService);
+var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+            getService(Ci.nsINavBookmarksService);
+var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+              getService(Ci.nsITaggingService);
+
+function run_test() {
+  // get toolbar node
+  var options = histsvc.getNewQueryOptions();
+  var query = histsvc.getNewQuery();
+  query.setFolders([bmsvc.toolbarFolder], 1);
+  var result = histsvc.executeQuery(query, options);
+  var toolbarNode = result.root;
+  toolbarNode.containerOpen = true;
+
+  // add a bookmark
+  var bookmarkURI = uri("http://foo.com");
+  var bookmarkId = bmsvc.insertBookmark(bmsvc.toolbarFolder, bookmarkURI,
+                                        bmsvc.DEFAULT_INDEX, "");
+
+  // get the node for the new bookmark
+  var node = toolbarNode.getChild(toolbarNode.childCount-1);
+  do_check_eq(node.itemId, bookmarkId);
+
+  // confirm there's no tags via the .tags property
+  do_check_eq(node.tags, null);
+
+  // add a tag
+  tagssvc.tagURI(bookmarkURI, ["foo"]);
+  do_check_eq(node.tags, "foo");
+
+  // add another tag, to test delimiter and sorting
+  tagssvc.tagURI(bookmarkURI, ["bar"]);
+  do_check_eq(node.tags, "bar, foo");
+
+  // remove the tags, confirming the property is cleared
+  tagssvc.untagURI(bookmarkURI, null);
+  do_check_eq(node.tags, null);
+
+  toolbarNode.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/unit/test_425563.js b/toolkit/components/places/tests/unit/test_425563.js
new file mode 100644
index 000000000..bee3a4a54
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_425563.js
@@ -0,0 +1,74 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  let count_visited_URIs = ["http://www.test-link.com/",
+                            "http://www.test-typed.com/",
+                            "http://www.test-bookmark.com/",
+                            "http://www.test-redirect-permanent.com/",
+                            "http://www.test-redirect-temporary.com/"];
+
+  let notcount_visited_URIs = ["http://www.test-embed.com/",
+                               "http://www.test-download.com/",
+                               "http://www.test-framed.com/",
+                               "http://www.test-reload.com/"];
+
+  // add visits, one for each transition type
+  yield PlacesTestUtils.addVisits([
+    { uri: uri("http://www.test-link.com/"),
+      transition: TRANSITION_LINK },
+    { uri: uri("http://www.test-typed.com/"),
+      transition: TRANSITION_TYPED },
+    { uri: uri("http://www.test-bookmark.com/"),
+      transition: TRANSITION_BOOKMARK },
+    { uri: uri("http://www.test-embed.com/"),
+      transition: TRANSITION_EMBED },
+    { uri: uri("http://www.test-framed.com/"),
+      transition: TRANSITION_FRAMED_LINK },
+    { uri: uri("http://www.test-redirect-permanent.com/"),
+      transition: TRANSITION_REDIRECT_PERMANENT },
+    { uri: uri("http://www.test-redirect-temporary.com/"),
+      transition: TRANSITION_REDIRECT_TEMPORARY },
+    { uri: uri("http://www.test-download.com/"),
+      transition: TRANSITION_DOWNLOAD },
+    { uri: uri("http://www.test-reload.com/"),
+      transition: TRANSITION_RELOAD },
+  ]);
+
+  // check that all links are marked as visited
+  for (let visited_uri of count_visited_URIs) {
+    do_check_true(yield promiseIsURIVisited(uri(visited_uri)));
+  }
+  for (let visited_uri of notcount_visited_URIs) {
+    do_check_true(yield promiseIsURIVisited(uri(visited_uri)));
+  }
+
+  // check that visit_count does not take in count embed and downloads
+  // maxVisits query are directly binded to visit_count
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_VISITCOUNT_DESCENDING;
+  options.resultType = options.RESULTS_AS_VISIT;
+  options.includeHidden = true;
+  let query = PlacesUtils.history.getNewQuery();
+  query.minVisits = 1;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+
+  root.containerOpen = true;
+  let cc = root.childCount;
+  do_check_eq(cc, count_visited_URIs.length);
+
+  for (let i = 0; i < cc; i++) {
+    let node = root.getChild(i);
+    do_check_neq(count_visited_URIs.indexOf(node.uri), -1);
+  }
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_429505_remove_shortcuts.js b/toolkit/components/places/tests/unit/test_429505_remove_shortcuts.js
new file mode 100644
index 000000000..e0b6be64c
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_429505_remove_shortcuts.js
@@ -0,0 +1,35 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/*
+
+- add a folder
+- add a folder-shortcut to the new folder
+- query for the shortcut
+- remove the folder-shortcut
+- confirm the shortcut is removed from the query results
+
+*/
+
+function run_test() {
+    const IDX = PlacesUtils.bookmarks.DEFAULT_INDEX;
+    var folderId =
+      PlacesUtils.bookmarks.createFolder(PlacesUtils.toolbarFolderId, "", IDX);
+
+    var queryId =
+      PlacesUtils.bookmarks.insertBookmark(PlacesUtils.toolbarFolderId,
+                                           uri("place:folder=" + folderId), IDX, "");
+
+    var root = PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId, false, true).root;
+
+    var oldCount = root.childCount;
+
+    PlacesUtils.bookmarks.removeItem(queryId);
+
+    do_check_eq(root.childCount, oldCount-1);
+
+    root.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/unit/test_433317_query_title_update.js b/toolkit/components/places/tests/unit/test_433317_query_title_update.js
new file mode 100644
index 000000000..52558e844
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_433317_query_title_update.js
@@ -0,0 +1,38 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function run_test() {
+  try {
+  var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+                getService(Ci.nsINavHistoryService);
+  var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+              getService(Ci.nsINavBookmarksService);
+  } catch (ex) {
+    do_throw("Unable to initialize Places services");
+  }
+
+  // create a query bookmark
+  var queryId = bmsvc.insertBookmark(bmsvc.toolbarFolder, uri("place:"),
+                                     0 /* first item */, "test query");
+
+  // query for that query
+  var options = histsvc.getNewQueryOptions();
+  var query = histsvc.getNewQuery();
+  query.setFolders([bmsvc.toolbarFolder], 1);
+  var result = histsvc.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var queryNode = root.getChild(0);
+  do_check_eq(queryNode.title, "test query");
+
+  // change the title
+  bmsvc.setItemTitle(queryId, "foo");
+
+  // confirm the node was updated
+  do_check_eq(queryNode.title, "foo");
+
+  root.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/unit/test_433525_hasChildren_crash.js b/toolkit/components/places/tests/unit/test_433525_hasChildren_crash.js
new file mode 100644
index 000000000..92dac0b17
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_433525_hasChildren_crash.js
@@ -0,0 +1,56 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  try {
+    var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+                  getService(Ci.nsINavHistoryService);
+    var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+              getService(Ci.nsINavBookmarksService);
+  } catch (ex) {
+    do_throw("Unable to initialize Places services");
+  }
+
+  // add a visit
+  var testURI = uri("http://test");
+  yield PlacesTestUtils.addVisits(testURI);
+
+  // query for the visit
+  var options = histsvc.getNewQueryOptions();
+  options.maxResults = 1;
+  options.resultType = options.RESULTS_AS_URI;
+  var query = histsvc.getNewQuery();
+  query.uri = testURI;
+  var result = histsvc.executeQuery(query, options);
+  var root = result.root;
+
+  // check hasChildren while the container is closed
+  do_check_eq(root.hasChildren, true);
+
+  // now check via the saved search path
+  var queryURI = histsvc.queriesToQueryString([query], 1, options);
+  bmsvc.insertBookmark(bmsvc.toolbarFolder, uri(queryURI),
+                       0 /* first item */, "test query");
+
+  // query for that query
+  options = histsvc.getNewQueryOptions();
+  query = histsvc.getNewQuery();
+  query.setFolders([bmsvc.toolbarFolder], 1);
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  var queryNode = root.getChild(0);
+  do_check_eq(queryNode.title, "test query");
+  queryNode.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(queryNode.hasChildren, true);
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_452777.js b/toolkit/components/places/tests/unit/test_452777.js
new file mode 100644
index 000000000..97b2852f6
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_452777.js
@@ -0,0 +1,36 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim:set ts=2 sw=2 sts=2 expandtab
+ * 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 test ensures that when removing a folder within a transaction, undoing
+ * the transaction restores it with the same id (as received by the observers).
+ */
+
+var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+         getService(Ci.nsINavBookmarksService);
+
+function run_test()
+{
+  const TITLE = "test folder";
+
+  // Create two test folders; remove the first one.  This ensures that undoing
+  // the removal will not get the same id by chance (the insert id's can be
+  // reused in SQLite).
+  let id = bs.createFolder(bs.placesRoot, TITLE, -1);
+  bs.createFolder(bs.placesRoot, "test folder 2", -1);
+  let transaction = bs.getRemoveFolderTransaction(id);
+  transaction.doTransaction();
+
+  // Now check to make sure it gets added with the right id
+  bs.addObserver({
+    onItemAdded: function(aItemId, aFolder, aIndex, aItemType, aURI, aTitle)
+    {
+      do_check_eq(aItemId, id);
+      do_check_eq(aTitle, TITLE);
+    }
+  }, false);
+  transaction.undoTransaction();
+}
diff --git a/toolkit/components/places/tests/unit/test_454977.js b/toolkit/components/places/tests/unit/test_454977.js
new file mode 100644
index 000000000..606e83048
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_454977.js
@@ -0,0 +1,124 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Cache actual visit_count value, filled by add_visit, used by check_results
+var visit_count = 0;
+
+// Returns the Place ID corresponding to an added visit.
+function* task_add_visit(aURI, aVisitType)
+{
+  // Add the visit asynchronously, and save its visit ID.
+  let deferUpdatePlaces = new Promise((resolve, reject) =>
+  {
+    PlacesUtils.asyncHistory.updatePlaces({
+      uri: aURI,
+      visits: [{ transitionType: aVisitType, visitDate: Date.now() * 1000 }]
+    }, {
+      handleError: function TAV_handleError() {
+        reject(new Error("Unexpected error in adding visit."));
+      },
+      handleResult: function (aPlaceInfo) {
+        this.visitId = aPlaceInfo.visits[0].visitId;
+      },
+      handleCompletion: function TAV_handleCompletion() {
+        resolve(this.visitId);
+      }
+    });
+  });
+
+  let visitId = yield deferUpdatePlaces;
+
+  // Increase visit_count if applicable
+  if (aVisitType != 0 &&
+      aVisitType != TRANSITION_EMBED &&
+      aVisitType != TRANSITION_FRAMED_LINK &&
+      aVisitType != TRANSITION_DOWNLOAD &&
+      aVisitType != TRANSITION_RELOAD) {
+    visit_count ++;
+  }
+
+  // Get the place id
+  if (visitId > 0) {
+    let sql = "SELECT place_id FROM moz_historyvisits WHERE id = ?1";
+    let stmt = DBConn().createStatement(sql);
+    stmt.bindByIndex(0, visitId);
+    do_check_true(stmt.executeStep());
+    let placeId = stmt.getInt64(0);
+    stmt.finalize();
+    do_check_true(placeId > 0);
+    return placeId;
+  }
+  return 0;
+}
+
+/**
+ * Checks for results consistency, using visit_count as constraint
+ * @param   aExpectedCount
+ *          Number of history results we are expecting (excluded hidden ones)
+ * @param   aExpectedCountWithHidden
+ *          Number of history results we are expecting (included hidden ones)
+ */
+function check_results(aExpectedCount, aExpectedCountWithHidden)
+{
+  let query = PlacesUtils.history.getNewQuery();
+  // used to check visit_count
+  query.minVisits = visit_count;
+  query.maxVisits = visit_count;
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_HISTORY;
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  // Children without hidden ones
+  do_check_eq(root.childCount, aExpectedCount);
+  root.containerOpen = false;
+
+  // Execute again with includeHidden = true
+  // This will ensure visit_count is correct
+  options.includeHidden = true;
+  root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  // Children with hidden ones
+  do_check_eq(root.childCount, aExpectedCountWithHidden);
+  root.containerOpen = false;
+}
+
+// main
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  const TEST_URI = uri("http://test.mozilla.org/");
+
+  // Add a visit that force hidden
+  yield task_add_visit(TEST_URI, TRANSITION_EMBED);
+  check_results(0, 0);
+
+  let placeId = yield task_add_visit(TEST_URI, TRANSITION_FRAMED_LINK);
+  check_results(0, 1);
+
+  // Add a visit that force unhide and check the place id.
+  // - We expect that the place gets hidden = 0 while retaining the same
+  //   place id and a correct visit_count.
+  do_check_eq((yield task_add_visit(TEST_URI, TRANSITION_TYPED)), placeId);
+  check_results(1, 1);
+
+  // Add a visit that should not increase visit_count
+  do_check_eq((yield task_add_visit(TEST_URI, TRANSITION_RELOAD)), placeId);
+  check_results(1, 1);
+
+  // Add a visit that should not increase visit_count
+  do_check_eq((yield task_add_visit(TEST_URI, TRANSITION_DOWNLOAD)), placeId);
+  check_results(1, 1);
+
+  // Add a visit, check that hidden is not overwritten
+  // - We expect that the place has still hidden = 0, while retaining
+  //   correct visit_count.
+  yield task_add_visit(TEST_URI, TRANSITION_EMBED);
+  check_results(1, 1);
+});
diff --git a/toolkit/components/places/tests/unit/test_463863.js b/toolkit/components/places/tests/unit/test_463863.js
new file mode 100644
index 000000000..2f7cece4a
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_463863.js
@@ -0,0 +1,60 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/*
+ * TEST DESCRIPTION:
+ *
+ * This test checks that in a basic history query all transition types visits
+ * appear but TRANSITION_EMBED and TRANSITION_FRAMED_LINK ones.
+ */
+
+var transitions = [
+  TRANSITION_LINK
+, TRANSITION_TYPED
+, TRANSITION_BOOKMARK
+, TRANSITION_EMBED
+, TRANSITION_FRAMED_LINK
+, TRANSITION_REDIRECT_PERMANENT
+, TRANSITION_REDIRECT_TEMPORARY
+, TRANSITION_DOWNLOAD
+];
+
+function runQuery(aResultType) {
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.resultType = aResultType;
+  let root = PlacesUtils.history.executeQuery(PlacesUtils.history.getNewQuery(),
+                                              options).root;
+  root.containerOpen = true;
+  let cc = root.childCount;
+  do_check_eq(cc, transitions.length - 2);
+
+  for (let i = 0; i < cc; i++) {
+    let node = root.getChild(i);
+    // Check that all transition types but EMBED and FRAMED appear in results
+    do_check_neq(node.uri.substr(6, 1), TRANSITION_EMBED);
+    do_check_neq(node.uri.substr(6, 1), TRANSITION_FRAMED_LINK);
+  }
+  root.containerOpen = false;
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  // add visits, one for each transition type
+  for (let transition of transitions) {
+    yield PlacesTestUtils.addVisits({
+      uri: uri("http://" + transition + ".mozilla.org/"),
+      transition: transition
+    });
+  }
+
+  runQuery(Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT);
+  runQuery(Ci.nsINavHistoryQueryOptions.RESULTS_AS_URI);
+});
diff --git a/toolkit/components/places/tests/unit/test_485442_crash_bug_nsNavHistoryQuery_GetUri.js b/toolkit/components/places/tests/unit/test_485442_crash_bug_nsNavHistoryQuery_GetUri.js
new file mode 100644
index 000000000..873174ffd
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_485442_crash_bug_nsNavHistoryQuery_GetUri.js
@@ -0,0 +1,21 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+
+function run_test() {
+  var query = hs.getNewQuery();
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULT_TYPE_QUERY;
+  var result = hs.executeQuery(query, options);
+  result.root.containerOpen = true;
+  var rootNode = result.root;
+  rootNode.QueryInterface(Ci.nsINavHistoryQueryResultNode);
+  var queries = rootNode.getQueries();
+  do_check_eq(queries[0].uri, null); // Should be null, instead of crashing the browser
+  rootNode.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/unit/test_486978_sort_by_date_queries.js b/toolkit/components/places/tests/unit/test_486978_sort_by_date_queries.js
new file mode 100644
index 000000000..05f3f83e7
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_486978_sort_by_date_queries.js
@@ -0,0 +1,129 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/*
+ * TEST DESCRIPTION:
+ *
+ * This test checks that setting a sort on a RESULTS_AS_DATE_QUERY query,
+ * children of inside containers are sorted accordingly.
+ */
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+
+// Will be inserted in this order, so last one will be the newest visit.
+var pages = [
+  "http://a.mozilla.org/1/",
+  "http://a.mozilla.org/2/",
+  "http://a.mozilla.org/3/",
+  "http://a.mozilla.org/4/",
+  "http://b.mozilla.org/5/",
+  "http://b.mozilla.org/6/",
+  "http://b.mozilla.org/7/",
+  "http://b.mozilla.org/8/",
+];
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_initialize()
+{
+  var noon = new Date();
+  noon.setHours(12);
+
+  // Add visits.
+  for (let pageIndex = 0; pageIndex < pages.length; ++pageIndex) {
+    let page = pages[pageIndex];
+    yield PlacesTestUtils.addVisits({
+      uri: uri(page),
+      visitDate: noon - (pages.length - pageIndex) * 1000
+    });
+  }
+});
+
+/**
+ * Tests that sorting date query by none will sort by title asc.
+ */
+add_task(function() {
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_DATE_QUERY;
+  // This should sort by title asc.
+  options.sortingMode = options.SORT_BY_NONE;
+  var query = hs.getNewQuery();
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var dayContainer = root.getChild(0).QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  dayContainer.containerOpen = true;
+
+  var cc = dayContainer.childCount;
+  do_check_eq(cc, pages.length);
+  for (var i = 0; i < cc; i++) {
+    var node = dayContainer.getChild(i);
+    do_check_eq(pages[i], node.uri);
+  }
+
+  dayContainer.containerOpen = false;
+  root.containerOpen = false;
+});
+
+/**
+ * Tests that sorting date query by date will sort accordingly.
+ */
+add_task(function() {
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_DATE_QUERY;
+  // This should sort by title asc.
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  var query = hs.getNewQuery();
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var dayContainer = root.getChild(0).QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  dayContainer.containerOpen = true;
+
+  var cc = dayContainer.childCount;
+  do_check_eq(cc, pages.length);
+  for (var i = 0; i < cc; i++) {
+    var node = dayContainer.getChild(i);
+    do_check_eq(pages[pages.length - i - 1], node.uri);
+  }
+
+  dayContainer.containerOpen = false;
+  root.containerOpen = false;
+});
+
+/**
+ * Tests that sorting date site query by date will still sort by title asc.
+ */
+add_task(function() {
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_DATE_SITE_QUERY;
+  // This should sort by title asc.
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  var query = hs.getNewQuery();
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var dayContainer = root.getChild(0).QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  dayContainer.containerOpen = true;
+  var siteContainer = dayContainer.getChild(0).QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(siteContainer.title, "a.mozilla.org");
+  siteContainer.containerOpen = true;
+
+  var cc = siteContainer.childCount;
+  do_check_eq(cc, pages.length / 2);
+  for (var i = 0; i < cc / 2; i++) {
+    var node = siteContainer.getChild(i);
+    do_check_eq(pages[i], node.uri);
+  }
+
+  siteContainer.containerOpen = false;
+  dayContainer.containerOpen = false;
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_536081.js b/toolkit/components/places/tests/unit/test_536081.js
new file mode 100644
index 000000000..b61b91866
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_536081.js
@@ -0,0 +1,56 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+var bh = hs.QueryInterface(Ci.nsIBrowserHistory);
+var db = hs.QueryInterface(Ci.nsPIPlacesDatabase).DBConnection;
+
+const URLS = [
+  { u: "http://www.google.com/search?q=testing%3Bthis&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:en-US:unofficial&client=firefox-a",
+    s: "goog" },
+];
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  for (let url of URLS) {
+    yield task_test_url(url);
+  }
+});
+
+function* task_test_url(aURL) {
+  print("Testing url: " + aURL.u);
+  yield PlacesTestUtils.addVisits(uri(aURL.u));
+  let query = hs.getNewQuery();
+  query.searchTerms = aURL.s;
+  let options = hs.getNewQueryOptions();
+  let root = hs.executeQuery(query, options).root;
+  root.containerOpen = true;
+  let cc = root.childCount;
+  do_check_eq(cc, 1);
+  print("Checking url is in the query.");
+  let node = root.getChild(0);
+  print("Found " + node.uri);
+  root.containerOpen = false;
+  bh.removePage(uri(node.uri));
+}
+
+function check_empty_table(table_name) {
+  print("Checking url has been removed.");
+  let stmt = db.createStatement("SELECT count(*) FROM " + table_name);
+  try {
+    stmt.executeStep();
+    do_check_eq(stmt.getInt32(0), 0);
+  }
+  finally {
+    stmt.finalize();
+  }
+}
diff --git a/toolkit/components/places/tests/unit/test_PlacesSearchAutocompleteProvider.js b/toolkit/components/places/tests/unit/test_PlacesSearchAutocompleteProvider.js
new file mode 100644
index 000000000..1280ce3e7
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_PlacesSearchAutocompleteProvider.js
@@ -0,0 +1,133 @@
+/* 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/. */
+
+Cu.import("resource://gre/modules/PlacesSearchAutocompleteProvider.jsm");
+
+function run_test() {
+  // Tell the search service we are running in the US.  This also has the
+  // desired side-effect of preventing our geoip lookup.
+  Services.prefs.setBoolPref("browser.search.isUS", true);
+  Services.prefs.setCharPref("browser.search.countryCode", "US");
+  Services.prefs.setBoolPref("browser.search.geoSpecificDefaults", false);
+  run_next_test();
+}
+
+add_task(function* search_engine_match() {
+  let engine = yield promiseDefaultSearchEngine();
+  let token = engine.getResultDomain();
+  let match = yield PlacesSearchAutocompleteProvider.findMatchByToken(token.substr(0, 1));
+  do_check_eq(match.url, engine.searchForm);
+  do_check_eq(match.engineName, engine.name);
+  do_check_eq(match.iconUrl, engine.iconURI ? engine.iconURI.spec : null);
+});
+
+add_task(function* no_match() {
+  do_check_eq(null, yield PlacesSearchAutocompleteProvider.findMatchByToken("test"));
+});
+
+add_task(function* hide_search_engine_nomatch() {
+  let engine = yield promiseDefaultSearchEngine();
+  let token = engine.getResultDomain();
+  let promiseTopic = promiseSearchTopic("engine-changed");
+  Services.search.removeEngine(engine);
+  yield promiseTopic;
+  do_check_true(engine.hidden);
+  do_check_eq(null, yield PlacesSearchAutocompleteProvider.findMatchByToken(token.substr(0, 1)));
+});
+
+add_task(function* add_search_engine_match() {
+  let promiseTopic = promiseSearchTopic("engine-added");
+  do_check_eq(null, yield PlacesSearchAutocompleteProvider.findMatchByToken("bacon"));
+  Services.search.addEngineWithDetails("bacon", "", "pork", "Search Bacon",
+                                       "GET", "http://www.bacon.moz/?search={searchTerms}");
+  yield promiseTopic;
+  let match = yield PlacesSearchAutocompleteProvider.findMatchByToken("bacon");
+  do_check_eq(match.url, "http://www.bacon.moz");
+  do_check_eq(match.engineName, "bacon");
+  do_check_eq(match.iconUrl, null);
+});
+
+add_task(function* test_aliased_search_engine_match() {
+  do_check_eq(null, yield PlacesSearchAutocompleteProvider.findMatchByAlias("sober"));
+  // Lower case
+  let match = yield PlacesSearchAutocompleteProvider.findMatchByAlias("pork");
+  do_check_eq(match.engineName, "bacon");
+  do_check_eq(match.alias, "pork");
+  do_check_eq(match.iconUrl, null);
+  // Upper case
+  let match1 = yield PlacesSearchAutocompleteProvider.findMatchByAlias("PORK");
+  do_check_eq(match1.engineName, "bacon");
+  do_check_eq(match1.alias, "pork");
+  do_check_eq(match1.iconUrl, null);
+  // Cap case
+  let match2 = yield PlacesSearchAutocompleteProvider.findMatchByAlias("Pork");
+  do_check_eq(match2.engineName, "bacon");
+  do_check_eq(match2.alias, "pork");
+  do_check_eq(match2.iconUrl, null);
+});
+
+add_task(function* test_aliased_search_engine_match_upper_case_alias() {
+  let promiseTopic = promiseSearchTopic("engine-added");
+  do_check_eq(null, yield PlacesSearchAutocompleteProvider.findMatchByToken("patch"));
+  Services.search.addEngineWithDetails("patch", "", "PR", "Search Patch",
+                                       "GET", "http://www.patch.moz/?search={searchTerms}");
+  yield promiseTopic;
+  // lower case
+  let match = yield PlacesSearchAutocompleteProvider.findMatchByAlias("pr");
+  do_check_eq(match.engineName, "patch");
+  do_check_eq(match.alias, "PR");
+  do_check_eq(match.iconUrl, null);
+  // Upper case
+  let match1 = yield PlacesSearchAutocompleteProvider.findMatchByAlias("PR");
+  do_check_eq(match1.engineName, "patch");
+  do_check_eq(match1.alias, "PR");
+  do_check_eq(match1.iconUrl, null);
+  // Cap case
+  let match2 = yield PlacesSearchAutocompleteProvider.findMatchByAlias("Pr");
+  do_check_eq(match2.engineName, "patch");
+  do_check_eq(match2.alias, "PR");
+  do_check_eq(match2.iconUrl, null);
+});
+
+add_task(function* remove_search_engine_nomatch() {
+  let engine = Services.search.getEngineByName("bacon");
+  let promiseTopic = promiseSearchTopic("engine-removed");
+  Services.search.removeEngine(engine);
+  yield promiseTopic;
+  do_check_eq(null, yield PlacesSearchAutocompleteProvider.findMatchByToken("bacon"));
+});
+
+add_task(function* test_parseSubmissionURL_basic() {
+  // Most of the logic of parseSubmissionURL is tested in the search service
+  // itself, thus we only do a sanity check of the wrapper here.
+  let engine = yield promiseDefaultSearchEngine();
+  let submissionURL = engine.getSubmission("terms").uri.spec;
+
+  let result = PlacesSearchAutocompleteProvider.parseSubmissionURL(submissionURL);
+  do_check_eq(result.engineName, engine.name);
+  do_check_eq(result.terms, "terms");
+
+  result = PlacesSearchAutocompleteProvider.parseSubmissionURL("http://example.org/");
+  do_check_eq(result, null);
+});
+
+function promiseDefaultSearchEngine() {
+  let deferred = Promise.defer();
+  Services.search.init( () => {
+    deferred.resolve(Services.search.defaultEngine);
+  });
+  return deferred.promise;
+}
+
+function promiseSearchTopic(expectedVerb) {
+  let deferred = Promise.defer();
+  Services.obs.addObserver( function observe(subject, topic, verb) {
+    do_print("browser-search-engine-modified: " + verb);
+    if (verb == expectedVerb) {
+      Services.obs.removeObserver(observe, "browser-search-engine-modified");
+      deferred.resolve();
+    }
+  }, "browser-search-engine-modified", false);
+  return deferred.promise;
+}
diff --git a/toolkit/components/places/tests/unit/test_PlacesUtils_asyncGetBookmarkIds.js b/toolkit/components/places/tests/unit/test_PlacesUtils_asyncGetBookmarkIds.js
new file mode 100644
index 000000000..182f75eac
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_PlacesUtils_asyncGetBookmarkIds.js
@@ -0,0 +1,77 @@
+/**
+ * This file tests PlacesUtils.asyncGetBookmarkIds method.
+ */
+
+const TEST_URL = "http://www.example.com/";
+
+var promiseAsyncGetBookmarkIds = Task.async(function* (url) {
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  return new Promise(resolve => {
+    PlacesUtils.asyncGetBookmarkIds(url, (itemIds, uri) => {
+      Assert.equal(uri, url);
+      resolve({ itemIds, url });
+    });
+  });
+});
+
+add_task(function* test_no_bookmark() {
+  let { itemIds, url } = yield promiseAsyncGetBookmarkIds(TEST_URL);
+  Assert.equal(itemIds.length, 0);
+  Assert.equal(url, TEST_URL);
+});
+
+add_task(function* test_one_bookmark() {
+  let bookmark = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: TEST_URL,
+    title: "test"
+  });
+  let itemId = yield PlacesUtils.promiseItemId(bookmark.guid);
+  {
+    let { itemIds, url } = yield promiseAsyncGetBookmarkIds(NetUtil.newURI(TEST_URL));
+    Assert.equal(itemIds.length, 1);
+    Assert.equal(itemIds[0], itemId);
+    Assert.equal(url.spec, TEST_URL);
+  }
+  {
+    let { itemIds, url } = yield promiseAsyncGetBookmarkIds(TEST_URL);
+    Assert.equal(itemIds.length, 1);
+    Assert.equal(itemIds[0], itemId);
+    Assert.equal(url, TEST_URL);
+  }
+  yield PlacesUtils.bookmarks.remove(bookmark);
+});
+
+add_task(function* test_multiple_bookmarks() {
+  let ids = [];
+  let bookmark1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: TEST_URL,
+    title: "test"
+  });
+  ids.push((yield PlacesUtils.promiseItemId(bookmark1.guid)));
+  let bookmark2 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: TEST_URL,
+    title: "test"
+  });
+  ids.push((yield PlacesUtils.promiseItemId(bookmark2.guid)));
+
+  let { itemIds, url } = yield promiseAsyncGetBookmarkIds(TEST_URL);
+  Assert.deepEqual(ids, itemIds);
+  Assert.equal(url, TEST_URL);
+
+  yield PlacesUtils.bookmarks.remove(bookmark1);
+  yield PlacesUtils.bookmarks.remove(bookmark2);
+});
+
+add_task(function* test_cancel() {
+  let pending = PlacesUtils.asyncGetBookmarkIds(TEST_URL, () => {
+    Assert.ok(false, "A canceled pending statement should not be invoked");
+  });
+  pending.cancel();
+
+  let { itemIds, url } = yield promiseAsyncGetBookmarkIds(TEST_URL);
+  Assert.equal(itemIds.length, 0);
+  Assert.equal(url, TEST_URL);
+});
diff --git a/toolkit/components/places/tests/unit/test_PlacesUtils_invalidateCachedGuidFor.js b/toolkit/components/places/tests/unit/test_PlacesUtils_invalidateCachedGuidFor.js
new file mode 100644
index 000000000..b7906ec5c
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_PlacesUtils_invalidateCachedGuidFor.js
@@ -0,0 +1,25 @@
+add_task(function* () {
+  do_print("Add a bookmark.");
+  let bm = yield PlacesUtils.bookmarks.insert({ url: "http://example.com/",
+                                                parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let id = yield PlacesUtils.promiseItemId(bm.guid);
+  Assert.equal((yield PlacesUtils.promiseItemGuid(id)), bm.guid);
+
+  // Ensure invalidating a non-existent itemId doesn't throw.
+  PlacesUtils.invalidateCachedGuidFor(null);
+  PlacesUtils.invalidateCachedGuidFor(9999);
+
+  do_print("Change the GUID.");
+  yield PlacesUtils.withConnectionWrapper("test", Task.async(function*(db) {
+    yield db.execute("UPDATE moz_bookmarks SET guid = :guid WHERE id = :id",
+                     { guid: "123456789012", id});
+  }));
+  // The cache should still point to the wrong id.
+  Assert.equal((yield PlacesUtils.promiseItemGuid(id)), bm.guid);
+
+  do_print("Invalidate the cache.");
+  PlacesUtils.invalidateCachedGuidFor(id);
+  Assert.equal((yield PlacesUtils.promiseItemGuid(id)), "123456789012");
+  Assert.equal((yield PlacesUtils.promiseItemId("123456789012")), id);
+  yield Assert.rejects(PlacesUtils.promiseItemId(bm.guid), /no item found for the given GUID/);
+});
diff --git a/toolkit/components/places/tests/unit/test_PlacesUtils_lazyobservers.js b/toolkit/components/places/tests/unit/test_PlacesUtils_lazyobservers.js
new file mode 100644
index 000000000..f0e9c5517
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_PlacesUtils_lazyobservers.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test() {
+  do_test_pending();
+
+  const TEST_URI = NetUtil.newURI("http://moz.org/")
+  let observer = {
+    QueryInterface: XPCOMUtils.generateQI([
+      Ci.nsINavBookmarkObserver,
+    ]),
+
+    onBeginUpdateBatch: function () {},
+    onEndUpdateBatch: function () {},
+    onItemAdded: function (aItemId, aParentId, aIndex, aItemType, aURI) {
+      do_check_true(aURI.equals(TEST_URI));
+      PlacesUtils.removeLazyBookmarkObserver(this);
+      do_test_finished();
+    },
+    onItemRemoved: function () {},
+    onItemChanged: function () {},
+    onItemVisited: function () {},
+    onItemMoved: function () {},
+  };
+
+  // Check registration and removal with uninitialized bookmarks service.
+  PlacesUtils.addLazyBookmarkObserver(observer);
+  PlacesUtils.removeLazyBookmarkObserver(observer);
+
+  // Add a proper lazy observer we will test.
+  PlacesUtils.addLazyBookmarkObserver(observer);
+
+  // Check that we don't leak when adding and removing an observer while the
+  // bookmarks service is instantiated but no change happened (bug 721319).
+  PlacesUtils.bookmarks;
+  PlacesUtils.addLazyBookmarkObserver(observer);
+  PlacesUtils.removeLazyBookmarkObserver(observer);
+  try {
+    PlacesUtils.bookmarks.removeObserver(observer);
+    do_throw("Trying to remove a nonexisting observer should throw!");
+  } catch (ex) {}
+
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       TEST_URI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "Bookmark title");
+}
diff --git a/toolkit/components/places/tests/unit/test_adaptive.js b/toolkit/components/places/tests/unit/test_adaptive.js
new file mode 100644
index 000000000..78ffaedb5
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_adaptive.js
@@ -0,0 +1,406 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Test for bug 395739 to make sure the feedback to the search results in those
+ * entries getting better ranks. Additionally, exact matches should be ranked
+ * higher. Because the interactions among adaptive rank and visit counts is not
+ * well defined, this test holds one of the two values constant when modifying
+ * the other.
+ *
+ * This also tests bug 395735 for the instrumentation feedback mechanism.
+ *
+ * Bug 411293 is tested to make sure the drop down strongly prefers previously
+ * typed pages that have been selected and are moved to the top with adaptive
+ * learning.
+ */
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  get minResultsForPopup() {
+    return 0;
+  },
+  get timeout() {
+    return 10;
+  },
+  get searchParam() {
+    return "";
+  },
+  get textValue() {
+    return "";
+  },
+  get disableAutoComplete() {
+    return false;
+  },
+  get completeDefaultIndex() {
+    return false;
+  },
+
+  get searchCount() {
+    return this.searches.length;
+  },
+  getSearchAt: function (aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function () {},
+  onSearchComplete: function() {},
+
+  get popupOpen() {
+    return false;
+  },
+  popup: {
+    set selectedIndex(aIndex) {},
+    invalidate: function () {},
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompletePopup])
+  },
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompleteInput])
+}
+
+/**
+ * Checks that autocomplete results are ordered correctly.
+ */
+function ensure_results(expected, searchTerm)
+{
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete.
+  let input = new AutoCompleteInput(["unifiedcomplete"]);
+
+  controller.input = input;
+
+  input.onSearchComplete = function() {
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+    do_check_eq(controller.matchCount, expected.length);
+    for (let i = 0; i < controller.matchCount; i++) {
+      print("Testing for '" + expected[i].uri.spec + "' got '" + controller.getValueAt(i) + "'");
+      do_check_eq(controller.getValueAt(i), expected[i].uri.spec);
+      do_check_eq(controller.getStyleAt(i), expected[i].style);
+    }
+
+    deferEnsureResults.resolve();
+  };
+
+  controller.startSearch(searchTerm);
+}
+
+/**
+ * Asynchronous task that bumps up the rank for an uri.
+ */
+function* task_setCountRank(aURI, aCount, aRank, aSearch, aBookmark)
+{
+  // Bump up the visit count for the uri.
+  let visits = [];
+  for (let i = 0; i < aCount; i++) {
+    visits.push({ uri: aURI, visitDate: d1, transition: TRANSITION_TYPED });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+
+  // Make a nsIAutoCompleteController and friends for instrumentation feedback.
+  let thing = {
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompleteInput,
+                                           Ci.nsIAutoCompletePopup,
+                                           Ci.nsIAutoCompleteController]),
+    get popup() {
+      return thing;
+    },
+    get controller() {
+      return thing;
+    },
+    popupOpen: true,
+    selectedIndex: 0,
+    getValueAt: function() {
+      return aURI.spec;
+    },
+    searchString: aSearch
+  };
+
+  // Bump up the instrumentation feedback.
+  for (let i = 0; i < aRank; i++) {
+    Services.obs.notifyObservers(thing, "autocomplete-will-enter-text", null);
+  }
+
+  // If this is supposed to be a bookmark, add it.
+  if (aBookmark) {
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                         aURI,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         "test_book");
+
+    // And add the tag if we need to.
+    if (aBookmark == "tag") {
+      PlacesUtils.tagging.tagURI(aURI, ["test_tag"]);
+    }
+  }
+}
+
+/**
+ * Decay the adaptive entries by sending the daily idle topic.
+ */
+function doAdaptiveDecay()
+{
+  PlacesUtils.history.runInBatchMode({
+    runBatched: function() {
+      for (let i = 0; i < 10; i++) {
+        PlacesUtils.history.QueryInterface(Ci.nsIObserver)
+                           .observe(null, "idle-daily", null);
+      }
+    }
+  }, this);
+}
+
+var uri1 = uri("http://site.tld/1");
+var uri2 = uri("http://site.tld/2");
+
+// d1 is some date for the page visit
+var d1 = new Date(Date.now() - 1000 * 60 * 60) * 1000;
+// c1 is larger (should show up higher) than c2
+var c1 = 10;
+var c2 = 1;
+// s1 is a partial match of s2
+var s0 = "";
+var s1 = "si";
+var s2 = "site";
+
+var observer = {
+  results: null,
+  search: null,
+  runCount: -1,
+  observe: function(aSubject, aTopic, aData)
+  {
+    if (--this.runCount > 0)
+      return;
+    ensure_results(this.results, this.search);
+  }
+};
+Services.obs.addObserver(observer, PlacesUtils.TOPIC_FEEDBACK_UPDATED, false);
+
+/**
+ * Make the result object for a given URI that will be passed to ensure_results.
+ */
+function makeResult(aURI, aStyle = "favicon") {
+  return {
+    uri: aURI,
+    style: aStyle,
+  };
+}
+
+var tests = [
+  // Test things without a search term.
+  function*() {
+    print("Test 0 same count, diff rank, same term; no search");
+    observer.results = [
+      makeResult(uri1),
+      makeResult(uri2),
+    ];
+    observer.search = s0;
+    observer.runCount = c1 + c2;
+    yield task_setCountRank(uri1, c1, c1, s2);
+    yield task_setCountRank(uri2, c1, c2, s2);
+  },
+  function*() {
+    print("Test 1 same count, diff rank, same term; no search");
+    observer.results = [
+      makeResult(uri2),
+      makeResult(uri1),
+    ];
+    observer.search = s0;
+    observer.runCount = c1 + c2;
+    yield task_setCountRank(uri1, c1, c2, s2);
+    yield task_setCountRank(uri2, c1, c1, s2);
+  },
+  function*() {
+    print("Test 2 diff count, same rank, same term; no search");
+    observer.results = [
+      makeResult(uri1),
+      makeResult(uri2),
+    ];
+    observer.search = s0;
+    observer.runCount = c1 + c1;
+    yield task_setCountRank(uri1, c1, c1, s2);
+    yield task_setCountRank(uri2, c2, c1, s2);
+  },
+  function*() {
+    print("Test 3 diff count, same rank, same term; no search");
+    observer.results = [
+      makeResult(uri2),
+      makeResult(uri1),
+    ];
+    observer.search = s0;
+    observer.runCount = c1 + c1;
+    yield task_setCountRank(uri1, c2, c1, s2);
+    yield task_setCountRank(uri2, c1, c1, s2);
+  },
+
+  // Test things with a search term (exact match one, partial other).
+  function*() {
+    print("Test 4 same count, same rank, diff term; one exact/one partial search");
+    observer.results = [
+      makeResult(uri1),
+      makeResult(uri2),
+    ];
+    observer.search = s1;
+    observer.runCount = c1 + c1;
+    yield task_setCountRank(uri1, c1, c1, s1);
+    yield task_setCountRank(uri2, c1, c1, s2);
+  },
+  function*() {
+    print("Test 5 same count, same rank, diff term; one exact/one partial search");
+    observer.results = [
+      makeResult(uri2),
+      makeResult(uri1),
+    ];
+    observer.search = s1;
+    observer.runCount = c1 + c1;
+    yield task_setCountRank(uri1, c1, c1, s2);
+    yield task_setCountRank(uri2, c1, c1, s1);
+  },
+
+  // Test things with a search term (exact match both).
+  function*() {
+    print("Test 6 same count, diff rank, same term; both exact search");
+    observer.results = [
+      makeResult(uri1),
+      makeResult(uri2),
+    ];
+    observer.search = s1;
+    observer.runCount = c1 + c2;
+    yield task_setCountRank(uri1, c1, c1, s1);
+    yield task_setCountRank(uri2, c1, c2, s1);
+  },
+  function*() {
+    print("Test 7 same count, diff rank, same term; both exact search");
+    observer.results = [
+      makeResult(uri2),
+      makeResult(uri1),
+    ];
+    observer.search = s1;
+    observer.runCount = c1 + c2;
+    yield task_setCountRank(uri1, c1, c2, s1);
+    yield task_setCountRank(uri2, c1, c1, s1);
+  },
+
+  // Test things with a search term (partial match both).
+  function*() {
+    print("Test 8 same count, diff rank, same term; both partial search");
+    observer.results = [
+      makeResult(uri1),
+      makeResult(uri2),
+    ];
+    observer.search = s1;
+    observer.runCount = c1 + c2;
+    yield task_setCountRank(uri1, c1, c1, s2);
+    yield task_setCountRank(uri2, c1, c2, s2);
+  },
+  function*() {
+    print("Test 9 same count, diff rank, same term; both partial search");
+    observer.results = [
+      makeResult(uri2),
+      makeResult(uri1),
+    ];
+    observer.search = s1;
+    observer.runCount = c1 + c2;
+    yield task_setCountRank(uri1, c1, c2, s2);
+    yield task_setCountRank(uri2, c1, c1, s2);
+  },
+  function*() {
+    print("Test 10 same count, same rank, same term, decay first; exact match");
+    observer.results = [
+      makeResult(uri2),
+      makeResult(uri1),
+    ];
+    observer.search = s1;
+    observer.runCount = c1 + c1;
+    yield task_setCountRank(uri1, c1, c1, s1);
+    doAdaptiveDecay();
+    yield task_setCountRank(uri2, c1, c1, s1);
+  },
+  function*() {
+    print("Test 11 same count, same rank, same term, decay second; exact match");
+    observer.results = [
+      makeResult(uri1),
+      makeResult(uri2),
+    ];
+    observer.search = s1;
+    observer.runCount = c1 + c1;
+    yield task_setCountRank(uri2, c1, c1, s1);
+    doAdaptiveDecay();
+    yield task_setCountRank(uri1, c1, c1, s1);
+  },
+  // Test that bookmarks are hidden if the preferences are set right.
+  function*() {
+    print("Test 12 same count, diff rank, same term; no search; history only");
+    Services.prefs.setBoolPref("browser.urlbar.suggest.history", true);
+    Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", false);
+    Services.prefs.setBoolPref("browser.urlbar.suggest.openpage", false);
+    observer.results = [
+      makeResult(uri1),
+      makeResult(uri2),
+    ];
+    observer.search = s0;
+    observer.runCount = c1 + c2;
+    yield task_setCountRank(uri1, c1, c1, s2, "bookmark");
+    yield task_setCountRank(uri2, c1, c2, s2);
+  },
+  // Test that tags are shown if the preferences are set right.
+  function*() {
+    print("Test 13 same count, diff rank, same term; no search; history only with tag");
+    Services.prefs.setBoolPref("browser.urlbar.suggest.history", true);
+    Services.prefs.setBoolPref("browser.urlbar.suggest.bookmark", false);
+    Services.prefs.setBoolPref("browser.urlbar.suggest.openpage", false);
+    observer.results = [
+      makeResult(uri1, "tag"),
+      makeResult(uri2),
+    ];
+    observer.search = s0;
+    observer.runCount = c1 + c2;
+    yield task_setCountRank(uri1, c1, c1, s2, "tag");
+    yield task_setCountRank(uri2, c1, c2, s2);
+  },
+];
+
+/**
+ * This deferred object contains a promise that is resolved when the
+ * ensure_results function has finished its execution.
+ */
+var deferEnsureResults;
+
+/**
+ * Test adaptive autocomplete.
+ */
+add_task(function* test_adaptive()
+{
+  // Disable autoFill for this test.
+  Services.prefs.setBoolPref("browser.urlbar.autoFill", false);
+  do_register_cleanup(() => Services.prefs.clearUserPref("browser.urlbar.autoFill"));
+  for (let test of tests) {
+    // Cleanup.
+    PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.unfiledBookmarksFolderId);
+    PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.tagsFolderId);
+    observer.runCount = -1;
+
+    let types = ["history", "bookmark", "openpage"];
+    for (let type of types) {
+      Services.prefs.clearUserPref("browser.urlbar.suggest." + type);
+    }
+
+    yield PlacesTestUtils.clearHistory();
+
+    deferEnsureResults = Promise.defer();
+    yield test();
+    yield deferEnsureResults.promise;
+  }
+
+  Services.obs.removeObserver(observer, PlacesUtils.TOPIC_FEEDBACK_UPDATED);
+});
diff --git a/toolkit/components/places/tests/unit/test_adaptive_bug527311.js b/toolkit/components/places/tests/unit/test_adaptive_bug527311.js
new file mode 100644
index 000000000..024553bba
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_adaptive_bug527311.js
@@ -0,0 +1,141 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const TEST_URL = "http://adapt.mozilla.org/";
+const SEARCH_STRING = "adapt";
+const SUGGEST_TYPES = ["history", "bookmark", "openpage"];
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+         getService(Ci.nsINavBookmarksService);
+var os = Cc["@mozilla.org/observer-service;1"].
+         getService(Ci.nsIObserverService);
+var ps = Cc["@mozilla.org/preferences-service;1"].
+         getService(Ci.nsIPrefBranch);
+
+const PLACES_AUTOCOMPLETE_FEEDBACK_UPDATED_TOPIC =
+  "places-autocomplete-feedback-updated";
+
+function cleanup() {
+  for (let type of SUGGEST_TYPES) {
+    ps.clearUserPref("browser.urlbar.suggest." + type);
+  }
+}
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+  searches: null,
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function ACI_getSearchAt(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchComplete: function ACI_onSearchComplete() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function() {},
+    invalidate: function() {},
+
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  onSearchBegin: function() {},
+
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+function check_results() {
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+  let input = new AutoCompleteInput(["unifiedcomplete"]);
+  controller.input = input;
+
+  input.onSearchComplete = function() {
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH);
+    do_check_eq(controller.matchCount, 0);
+
+    PlacesUtils.bookmarks.eraseEverything().then(() => {
+      cleanup();
+      do_test_finished();
+    });
+ };
+
+  controller.startSearch(SEARCH_STRING);
+}
+
+
+function addAdaptiveFeedback(aUrl, aSearch, aCallback) {
+  let observer = {
+    observe: function(aSubject, aTopic, aData) {
+      os.removeObserver(observer, PLACES_AUTOCOMPLETE_FEEDBACK_UPDATED_TOPIC);
+      do_timeout(0, aCallback);
+    }
+  };
+  os.addObserver(observer, PLACES_AUTOCOMPLETE_FEEDBACK_UPDATED_TOPIC, false);
+
+  let thing = {
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompleteInput,
+                                           Ci.nsIAutoCompletePopup,
+                                           Ci.nsIAutoCompleteController]),
+    get popup() { return thing; },
+    get controller() { return thing; },
+    popupOpen: true,
+    selectedIndex: 0,
+    getValueAt: () => aUrl,
+    searchString: aSearch
+  };
+
+  os.notifyObservers(thing, "autocomplete-will-enter-text", null);
+}
+
+
+function run_test() {
+  do_test_pending();
+
+  // Add a bookmark to our url.
+  bs.insertBookmark(bs.unfiledBookmarksFolder, uri(TEST_URL),
+                    bs.DEFAULT_INDEX, "test_book");
+  // We want to search only history.
+  for (let type of SUGGEST_TYPES) {
+    type == "history" ? ps.setBoolPref("browser.urlbar.suggest." + type, true)
+                      : ps.setBoolPref("browser.urlbar.suggest." + type, false);
+  }
+
+  // Add an adaptive entry.
+  addAdaptiveFeedback(TEST_URL, SEARCH_STRING, check_results);
+}
diff --git a/toolkit/components/places/tests/unit/test_analyze.js b/toolkit/components/places/tests/unit/test_analyze.js
new file mode 100644
index 000000000..456270101
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_analyze.js
@@ -0,0 +1,28 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Tests sqlite_sta1 table exists, it should be created by analyze.
+// Since the bookmark roots are created when the DB is created (bug 704855),
+// the table will contain data.
+
+function run_test() {
+  do_test_pending();
+
+  let stmt = DBConn().createAsyncStatement(
+    "SELECT ROWID FROM sqlite_stat1"
+  );
+  stmt.executeAsync({
+    _gotResult: false,
+    handleResult: function(aResultSet) {
+      this._gotResult = true;
+    },
+    handleError: function(aError) {
+      do_throw("Unexpected error (" + aError.result + "): " + aError.message);
+    },
+    handleCompletion: function(aReason) {
+      do_check_true(this._gotResult);
+       do_test_finished();
+    }
+  });
+  stmt.finalize();
+}
diff --git a/toolkit/components/places/tests/unit/test_annotations.js b/toolkit/components/places/tests/unit/test_annotations.js
new file mode 100644
index 000000000..a37d7e6c9
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_annotations.js
@@ -0,0 +1,363 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get bookmark service
+try {
+  var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].getService(Ci.nsINavBookmarksService);
+} catch (ex) {
+  do_throw("Could not get nav-bookmarks-service\n");
+}
+
+// Get annotation service
+try {
+  var annosvc= Cc["@mozilla.org/browser/annotation-service;1"].getService(Ci.nsIAnnotationService);
+} catch (ex) {
+  do_throw("Could not get annotation service\n");
+}
+
+var annoObserver = {
+  PAGE_lastSet_URI: "",
+  PAGE_lastSet_AnnoName: "",
+
+  onPageAnnotationSet: function(aURI, aName) {
+    this.PAGE_lastSet_URI = aURI.spec;
+    this.PAGE_lastSet_AnnoName = aName;
+  },
+
+  ITEM_lastSet_Id: -1,
+  ITEM_lastSet_AnnoName: "",
+  onItemAnnotationSet: function(aItemId, aName) {
+    this.ITEM_lastSet_Id = aItemId;
+    this.ITEM_lastSet_AnnoName = aName;
+  },
+
+  PAGE_lastRemoved_URI: "",
+  PAGE_lastRemoved_AnnoName: "",
+  onPageAnnotationRemoved: function(aURI, aName) {
+    this.PAGE_lastRemoved_URI = aURI.spec;
+    this.PAGE_lastRemoved_AnnoName = aName;
+  },
+
+  ITEM_lastRemoved_Id: -1,
+  ITEM_lastRemoved_AnnoName: "",
+  onItemAnnotationRemoved: function(aItemId, aName) {
+    this.ITEM_lastRemoved_Id = aItemId;
+    this.ITEM_lastRemoved_AnnoName = aName;
+  }
+};
+
+// main
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  var testURI = uri("http://mozilla.com/");
+  var testItemId = bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, testURI, -1, "");
+  var testAnnoName = "moz-test-places/annotations";
+  var testAnnoVal = "test";
+
+  annosvc.addObserver(annoObserver);
+  // create new string annotation
+  try {
+    annosvc.setPageAnnotation(testURI, testAnnoName, testAnnoVal, 0, 0);
+  } catch (ex) {
+    do_throw("unable to add page-annotation");
+  }
+  do_check_eq(annoObserver.PAGE_lastSet_URI, testURI.spec);
+  do_check_eq(annoObserver.PAGE_lastSet_AnnoName, testAnnoName);
+
+  // get string annotation
+  do_check_true(annosvc.pageHasAnnotation(testURI, testAnnoName));
+  var storedAnnoVal = annosvc.getPageAnnotation(testURI, testAnnoName);
+  do_check_true(testAnnoVal === storedAnnoVal);
+  // string item-annotation
+  try {
+    var lastModified = bmsvc.getItemLastModified(testItemId);
+    // Verify that lastModified equals dateAdded before we set the annotation.
+    do_check_eq(lastModified, bmsvc.getItemDateAdded(testItemId));
+    // Workaround possible VM timers issues moving last modified to the past.
+    bmsvc.setItemLastModified(testItemId, --lastModified);
+    annosvc.setItemAnnotation(testItemId, testAnnoName, testAnnoVal, 0, 0);
+    var lastModified2 = bmsvc.getItemLastModified(testItemId);
+    // verify that setting the annotation updates the last modified time
+    do_check_true(lastModified2 > lastModified);
+  } catch (ex) {
+    do_throw("unable to add item annotation");
+  }
+  do_check_eq(annoObserver.ITEM_lastSet_Id, testItemId);
+  do_check_eq(annoObserver.ITEM_lastSet_AnnoName, testAnnoName);
+
+  try {
+    var annoVal = annosvc.getItemAnnotation(testItemId, testAnnoName);
+    // verify the anno value
+    do_check_true(testAnnoVal === annoVal);
+  } catch (ex) {
+    do_throw("unable to get item annotation");
+  }
+
+  // test getPagesWithAnnotation
+  var uri2 = uri("http://www.tests.tld");
+  yield PlacesTestUtils.addVisits(uri2);
+  annosvc.setPageAnnotation(uri2, testAnnoName, testAnnoVal, 0, 0);
+  var pages = annosvc.getPagesWithAnnotation(testAnnoName);
+  do_check_eq(pages.length, 2);
+  // Don't rely on the order
+  do_check_false(pages[0].equals(pages[1]));
+  do_check_true(pages[0].equals(testURI) || pages[1].equals(testURI));
+  do_check_true(pages[0].equals(uri2) || pages[1].equals(uri2));
+
+  // test getItemsWithAnnotation
+  var testItemId2 = bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri2, -1, "");
+  annosvc.setItemAnnotation(testItemId2, testAnnoName, testAnnoVal, 0, 0);
+  var items = annosvc.getItemsWithAnnotation(testAnnoName);
+  do_check_eq(items.length, 2);
+  // Don't rely on the order
+  do_check_true(items[0] != items[1]);
+  do_check_true(items[0] == testItemId || items[1] == testItemId);
+  do_check_true(items[0] == testItemId2 || items[1] == testItemId2);
+
+  // get annotation that doesn't exist
+  try {
+    annosvc.getPageAnnotation(testURI, "blah");
+    do_throw("fetching page-annotation that doesn't exist, should've thrown");
+  } catch (ex) {}
+  try {
+    annosvc.getItemAnnotation(testURI, "blah");
+    do_throw("fetching item-annotation that doesn't exist, should've thrown");
+  } catch (ex) {}
+
+  // get annotation info
+  var flags = {}, exp = {}, storageType = {};
+  annosvc.getPageAnnotationInfo(testURI, testAnnoName, flags, exp, storageType);
+  do_check_eq(flags.value, 0);
+  do_check_eq(exp.value, 0);
+  do_check_eq(storageType.value, Ci.nsIAnnotationService.TYPE_STRING);
+  annosvc.getItemAnnotationInfo(testItemId, testAnnoName, flags, exp, storageType);
+  do_check_eq(flags.value, 0);
+  do_check_eq(exp.value, 0);
+  do_check_eq(storageType.value, Ci.nsIAnnotationService.TYPE_STRING);
+
+  // get annotation names for a uri
+  var annoNames = annosvc.getPageAnnotationNames(testURI);
+  do_check_eq(annoNames.length, 1);
+  do_check_eq(annoNames[0], "moz-test-places/annotations");
+
+  // get annotation names for an item
+  annoNames = annosvc.getItemAnnotationNames(testItemId);
+  do_check_eq(annoNames.length, 1);
+  do_check_eq(annoNames[0], "moz-test-places/annotations");
+
+  // copy annotations to another uri
+  var newURI = uri("http://mozilla.org");
+  yield PlacesTestUtils.addVisits(newURI);
+  annosvc.setPageAnnotation(testURI, "oldAnno", "new", 0, 0);
+  annosvc.setPageAnnotation(newURI, "oldAnno", "old", 0, 0);
+  annoNames = annosvc.getPageAnnotationNames(newURI);
+  do_check_eq(annoNames.length, 1);
+  do_check_eq(annoNames[0], "oldAnno");
+  var oldAnnoNames = annosvc.getPageAnnotationNames(testURI);
+  do_check_eq(oldAnnoNames.length, 2);
+  var copiedAnno = oldAnnoNames[0];
+  annosvc.copyPageAnnotations(testURI, newURI, false);
+  var newAnnoNames = annosvc.getPageAnnotationNames(newURI);
+  do_check_eq(newAnnoNames.length, 2);
+  do_check_true(annosvc.pageHasAnnotation(newURI, "oldAnno"));
+  do_check_true(annosvc.pageHasAnnotation(newURI, copiedAnno));
+  do_check_eq(annosvc.getPageAnnotation(newURI, "oldAnno"), "old");
+  annosvc.setPageAnnotation(newURI, "oldAnno", "new", 0, 0);
+  annosvc.copyPageAnnotations(testURI, newURI, true);
+  newAnnoNames = annosvc.getPageAnnotationNames(newURI);
+  do_check_eq(newAnnoNames.length, 2);
+  do_check_true(annosvc.pageHasAnnotation(newURI, "oldAnno"));
+  do_check_true(annosvc.pageHasAnnotation(newURI, copiedAnno));
+  do_check_eq(annosvc.getPageAnnotation(newURI, "oldAnno"), "new");
+
+
+  // copy annotations to another item
+  newURI = uri("http://mozilla.org");
+  var newItemId = bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, newURI, -1, "");
+  var itemId = bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, testURI, -1, "");
+  annosvc.setItemAnnotation(itemId, "oldAnno", "new", 0, 0);
+  annosvc.setItemAnnotation(itemId, "testAnno", "test", 0, 0);
+  annosvc.setItemAnnotation(newItemId, "oldAnno", "old", 0, 0);
+  annoNames = annosvc.getItemAnnotationNames(newItemId);
+  do_check_eq(annoNames.length, 1);
+  do_check_eq(annoNames[0], "oldAnno");
+  oldAnnoNames = annosvc.getItemAnnotationNames(itemId);
+  do_check_eq(oldAnnoNames.length, 2);
+  copiedAnno = oldAnnoNames[0];
+  annosvc.copyItemAnnotations(itemId, newItemId, false);
+  newAnnoNames = annosvc.getItemAnnotationNames(newItemId);
+  do_check_eq(newAnnoNames.length, 2);
+  do_check_true(annosvc.itemHasAnnotation(newItemId, "oldAnno"));
+  do_check_true(annosvc.itemHasAnnotation(newItemId, copiedAnno));
+  do_check_eq(annosvc.getItemAnnotation(newItemId, "oldAnno"), "old");
+  annosvc.setItemAnnotation(newItemId, "oldAnno", "new", 0, 0);
+  annosvc.copyItemAnnotations(itemId, newItemId, true);
+  newAnnoNames = annosvc.getItemAnnotationNames(newItemId);
+  do_check_eq(newAnnoNames.length, 2);
+  do_check_true(annosvc.itemHasAnnotation(newItemId, "oldAnno"));
+  do_check_true(annosvc.itemHasAnnotation(newItemId, copiedAnno));
+  do_check_eq(annosvc.getItemAnnotation(newItemId, "oldAnno"), "new");
+
+  // test int32 anno type
+  var int32Key = testAnnoName + "/types/Int32";
+  var int32Val = 23;
+  annosvc.setPageAnnotation(testURI, int32Key, int32Val, 0, 0);
+  do_check_true(annosvc.pageHasAnnotation(testURI, int32Key));
+  flags = {}, exp = {}, storageType = {};
+  annosvc.getPageAnnotationInfo(testURI, int32Key, flags, exp, storageType);
+  do_check_eq(flags.value, 0);
+  do_check_eq(exp.value, 0);
+  do_check_eq(storageType.value, Ci.nsIAnnotationService.TYPE_INT32);
+  var storedVal = annosvc.getPageAnnotation(testURI, int32Key);
+  do_check_true(int32Val === storedVal);
+  annosvc.setItemAnnotation(testItemId, int32Key, int32Val, 0, 0);
+  do_check_true(annosvc.itemHasAnnotation(testItemId, int32Key));
+  annosvc.getItemAnnotationInfo(testItemId, int32Key, flags, exp, storageType);
+  do_check_eq(flags.value, 0);
+  do_check_eq(exp.value, 0);
+  storedVal = annosvc.getItemAnnotation(testItemId, int32Key);
+  do_check_true(int32Val === storedVal);
+
+  // test int64 anno type
+  var int64Key = testAnnoName + "/types/Int64";
+  var int64Val = 4294967296;
+  annosvc.setPageAnnotation(testURI, int64Key, int64Val, 0, 0);
+  annosvc.getPageAnnotationInfo(testURI, int64Key, flags, exp, storageType);
+  do_check_eq(flags.value, 0);
+  do_check_eq(exp.value, 0);
+  storedVal = annosvc.getPageAnnotation(testURI, int64Key);
+  do_check_true(int64Val === storedVal);
+  annosvc.setItemAnnotation(testItemId, int64Key, int64Val, 0, 0);
+  do_check_true(annosvc.itemHasAnnotation(testItemId, int64Key));
+  annosvc.getItemAnnotationInfo(testItemId, int64Key, flags, exp, storageType);
+  do_check_eq(flags.value, 0);
+  do_check_eq(exp.value, 0);
+  storedVal = annosvc.getItemAnnotation(testItemId, int64Key);
+  do_check_true(int64Val === storedVal);
+
+  // test double anno type
+  var doubleKey = testAnnoName + "/types/Double";
+  var doubleVal = 0.000002342;
+  annosvc.setPageAnnotation(testURI, doubleKey, doubleVal, 0, 0);
+  annosvc.getPageAnnotationInfo(testURI, doubleKey, flags, exp, storageType);
+  do_check_eq(flags.value, 0);
+  do_check_eq(exp.value, 0);
+  storedVal = annosvc.getPageAnnotation(testURI, doubleKey);
+  do_check_true(doubleVal === storedVal);
+  annosvc.setItemAnnotation(testItemId, doubleKey, doubleVal, 0, 0);
+  do_check_true(annosvc.itemHasAnnotation(testItemId, doubleKey));
+  annosvc.getItemAnnotationInfo(testItemId, doubleKey, flags, exp, storageType);
+  do_check_eq(flags.value, 0);
+  do_check_eq(exp.value, 0);
+  do_check_eq(storageType.value, Ci.nsIAnnotationService.TYPE_DOUBLE);
+  storedVal = annosvc.getItemAnnotation(testItemId, doubleKey);
+  do_check_true(doubleVal === storedVal);
+
+  // test annotation removal
+  annosvc.removePageAnnotation(testURI, int32Key);
+
+  annosvc.setItemAnnotation(testItemId, testAnnoName, testAnnoVal, 0, 0);
+  // verify that removing an annotation updates the last modified date
+  var lastModified3 = bmsvc.getItemLastModified(testItemId);
+  // Workaround possible VM timers issues moving last modified to the past.
+  bmsvc.setItemLastModified(testItemId, --lastModified3);
+  annosvc.removeItemAnnotation(testItemId, int32Key);
+  var lastModified4 = bmsvc.getItemLastModified(testItemId);
+  do_print("verify that removing an annotation updates the last modified date");
+  do_print("lastModified3 = " + lastModified3);
+  do_print("lastModified4 = " + lastModified4);
+  do_check_true(lastModified4 > lastModified3);
+
+  do_check_eq(annoObserver.PAGE_lastRemoved_URI, testURI.spec);
+  do_check_eq(annoObserver.PAGE_lastRemoved_AnnoName, int32Key);
+  do_check_eq(annoObserver.ITEM_lastRemoved_Id, testItemId);
+  do_check_eq(annoObserver.ITEM_lastRemoved_AnnoName, int32Key);
+
+  // test that getItems/PagesWithAnnotation returns an empty array after
+  // removing all items/pages which had the annotation set, see bug 380317.
+  do_check_eq(annosvc.getItemsWithAnnotation(int32Key).length, 0);
+  do_check_eq(annosvc.getPagesWithAnnotation(int32Key).length, 0);
+
+  // Setting item annotations on invalid item ids should throw
+  var invalidIds = [-1, 0, 37643];
+  for (var id of invalidIds) {
+    try {
+      annosvc.setItemAnnotation(id, "foo", "bar", 0, 0);
+      do_throw("setItemAnnotation* should throw for invalid item id: " + id)
+    }
+    catch (ex) { }
+  }
+
+  // setting an annotation with EXPIRE_HISTORY for an item should throw
+  itemId = bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, testURI, -1, "");
+  try {
+    annosvc.setItemAnnotation(itemId, "foo", "bar", 0, annosvc.EXPIRE_WITH_HISTORY);
+    do_throw("setting an item annotation with EXPIRE_HISTORY should throw");
+  }
+  catch (ex) {
+  }
+
+  annosvc.removeObserver(annoObserver);
+});
+
+add_test(function test_getAnnotationsHavingName() {
+  let uri = NetUtil.newURI("http://cat.mozilla.org");
+  let id = PlacesUtils.bookmarks.insertBookmark(
+    PlacesUtils.unfiledBookmarksFolderId, uri,
+    PlacesUtils.bookmarks.DEFAULT_INDEX, "cat");
+  let fid = PlacesUtils.bookmarks.createFolder(
+    PlacesUtils.unfiledBookmarksFolderId, "pillow",
+    PlacesUtils.bookmarks.DEFAULT_INDEX);
+
+  const ANNOS = {
+    "int": 7,
+    "double": 7.7,
+    "string": "seven"
+  };
+  for (let name in ANNOS) {
+    PlacesUtils.annotations.setPageAnnotation(
+      uri, name, ANNOS[name], 0,
+      PlacesUtils.annotations.EXPIRE_SESSION);
+    PlacesUtils.annotations.setItemAnnotation(
+      id, name, ANNOS[name], 0,
+      PlacesUtils.annotations.EXPIRE_SESSION);
+    PlacesUtils.annotations.setItemAnnotation(
+      fid, name, ANNOS[name], 0,
+      PlacesUtils.annotations.EXPIRE_SESSION);
+  }
+
+  for (let name in ANNOS) {
+    let results = PlacesUtils.annotations.getAnnotationsWithName(name);
+    do_check_eq(results.length, 3);
+
+    for (let result of results) {
+      do_check_eq(result.annotationName, name);
+      do_check_eq(result.annotationValue, ANNOS[name]);
+      if (result.uri)
+        do_check_true(result.uri.equals(uri));
+      else
+        do_check_true(result.itemId > 0);
+
+      if (result.itemId != -1) {
+        if (result.uri)
+          do_check_eq(result.itemId, id);
+        else
+          do_check_eq(result.itemId, fid);
+        do_check_guid_for_bookmark(result.itemId, result.guid);
+      }
+      else {
+        do_check_guid_for_uri(result.uri, result.guid);
+      }
+    }
+  }
+
+  run_next_test();
+});
diff --git a/toolkit/components/places/tests/unit/test_asyncExecuteLegacyQueries.js b/toolkit/components/places/tests/unit/test_asyncExecuteLegacyQueries.js
new file mode 100644
index 000000000..7296fe061
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_asyncExecuteLegacyQueries.js
@@ -0,0 +1,95 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+// This is a test for asyncExecuteLegacyQueries API.
+
+var tests = [
+
+function test_history_query() {
+  let uri = NetUtil.newURI("http://test.visit.mozilla.com/");
+  let title = "Test visit";
+  PlacesTestUtils.addVisits({ uri: uri, title: title }).then(function () {
+    let options = PlacesUtils.history.getNewQueryOptions();
+    options.sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING;
+    let query = PlacesUtils.history.getNewQuery();
+
+    PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
+                       .asyncExecuteLegacyQueries([query], 1, options, {
+      handleResult: function (aResultSet) {
+        for (let row; (row = aResultSet.getNextRow());) {
+          try {
+            do_check_eq(row.getResultByIndex(1), uri.spec);
+            do_check_eq(row.getResultByIndex(2), title);
+          } catch (e) {
+            do_throw("Error while fetching page data.");
+          }
+        }
+      },
+      handleError: function (aError) {
+        do_throw("Async execution error (" + aError.result + "): " + aError.message);
+      },
+      handleCompletion: function (aReason) {
+        run_next_test();
+      },
+    });
+  });
+},
+
+function test_bookmarks_query() {
+  let uri = NetUtil.newURI("http://test.bookmark.mozilla.com/");
+  let title = "Test bookmark";
+  bookmark(uri, title);
+  let options = PlacesUtils.history.getNewQueryOptions();
+  options.sortingMode = Ci.nsINavHistoryQueryOptions.SORT_BY_LASMODIFIED_DESCENDING;
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  let query = PlacesUtils.history.getNewQuery();
+
+  PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
+                     .asyncExecuteLegacyQueries([query], 1, options, {
+    handleResult: function (aResultSet) {
+      for (let row; (row = aResultSet.getNextRow());) {
+        try {
+          do_check_eq(row.getResultByIndex(1), uri.spec);
+          do_check_eq(row.getResultByIndex(2), title);
+        } catch (e) {
+          do_throw("Error while fetching page data.");
+        }
+      }
+    },
+    handleError: function (aError) {
+      do_throw("Async execution error (" + aError.result + "): " + aError.message);
+    },
+    handleCompletion: function (aReason) {
+      run_next_test();
+    },
+  });
+},
+
+];
+
+function bookmark(aURI, aTitle)
+{
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       aURI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       aTitle);
+}
+
+function run_test()
+{
+  do_test_pending();
+  run_next_test();
+}
+
+function run_next_test() {
+  if (tests.length == 0) {
+    do_test_finished();
+    return;
+  }
+
+  Promise.all([
+    PlacesTestUtils.clearHistory(),
+    PlacesUtils.bookmarks.eraseEverything()
+  ]).then(tests.shift());
+}
diff --git a/toolkit/components/places/tests/unit/test_async_history_api.js b/toolkit/components/places/tests/unit/test_async_history_api.js
new file mode 100644
index 000000000..a012fcda2
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_async_history_api.js
@@ -0,0 +1,1118 @@
+/**
+ * This file tests the async history API exposed by mozIAsyncHistory.
+ */
+
+// Globals
+
+const TEST_DOMAIN = "http://mozilla.org/";
+const URI_VISIT_SAVED = "uri-visit-saved";
+const RECENT_EVENT_THRESHOLD = 15 * 60 * 1000000;
+
+// Helpers
+/**
+ * Object that represents a mozIVisitInfo object.
+ *
+ * @param [optional] aTransitionType
+ *        The transition type of the visit.  Defaults to TRANSITION_LINK if not
+ *        provided.
+ * @param [optional] aVisitTime
+ *        The time of the visit.  Defaults to now if not provided.
+ */
+function VisitInfo(aTransitionType,
+                   aVisitTime) {
+  this.transitionType =
+    aTransitionType === undefined ? TRANSITION_LINK : aTransitionType;
+  this.visitDate = aVisitTime || Date.now() * 1000;
+}
+
+function promiseUpdatePlaces(aPlaces) {
+  return new Promise((resolve, reject) => {
+    PlacesUtils.asyncHistory.updatePlaces(aPlaces, {
+      _errors: [],
+      _results: [],
+      handleError(aResultCode, aPlace) {
+        this._errors.push({ resultCode: aResultCode, info: aPlace});
+      },
+      handleResult(aPlace) {
+        this._results.push(aPlace);
+      },
+      handleCompletion() {
+        resolve({ errors: this._errors, results: this._results });
+      }
+    });
+  });
+}
+
+/**
+ * Listens for a title change notification, and calls aCallback when it gets it.
+ *
+ * @param aURI
+ *        The URI of the page we expect a notification for.
+ * @param aExpectedTitle
+ *        The expected title of the URI we expect a notification for.
+ * @param aCallback
+ *        The method to call when we have gotten the proper notification about
+ *        the title changing.
+ */
+function TitleChangedObserver(aURI,
+                              aExpectedTitle,
+                              aCallback) {
+  this.uri = aURI;
+  this.expectedTitle = aExpectedTitle;
+  this.callback = aCallback;
+}
+TitleChangedObserver.prototype = {
+  __proto__: NavHistoryObserver.prototype,
+  onTitleChanged(aURI, aTitle, aGUID) {
+    do_print("onTitleChanged(" + aURI.spec + ", " + aTitle + ", " + aGUID + ")");
+    if (!this.uri.equals(aURI)) {
+      return;
+    }
+    do_check_eq(aTitle, this.expectedTitle);
+    do_check_guid_for_uri(aURI, aGUID);
+    this.callback();
+  },
+};
+
+/**
+ * Listens for a visit notification, and calls aCallback when it gets it.
+ *
+ * @param aURI
+ *        The URI of the page we expect a notification for.
+ * @param aCallback
+ *        The method to call when we have gotten the proper notification about
+ *        being visited.
+ */
+function VisitObserver(aURI,
+                       aGUID,
+                       aCallback)
+{
+  this.uri = aURI;
+  this.guid = aGUID;
+  this.callback = aCallback;
+}
+VisitObserver.prototype = {
+  __proto__: NavHistoryObserver.prototype,
+  onVisit: function(aURI,
+                    aVisitId,
+                    aTime,
+                    aSessionId,
+                    aReferringId,
+                    aTransitionType,
+                    aGUID)
+  {
+    do_print("onVisit(" + aURI.spec + ", " + aVisitId + ", " + aTime +
+             ", " + aSessionId + ", " + aReferringId + ", " +
+             aTransitionType + ", " + aGUID + ")");
+    if (!this.uri.equals(aURI) || this.guid != aGUID) {
+      return;
+    }
+    this.callback(aTime, aTransitionType);
+  },
+};
+
+/**
+ * Tests that a title was set properly in the database.
+ *
+ * @param aURI
+ *        The uri to check.
+ * @param aTitle
+ *        The expected title in the database.
+ */
+function do_check_title_for_uri(aURI,
+                                aTitle)
+{
+  let stack = Components.stack.caller;
+  let stmt = DBConn().createStatement(
+    `SELECT title
+     FROM moz_places
+     WHERE url_hash = hash(:url) AND url = :url`
+  );
+  stmt.params.url = aURI.spec;
+  do_check_true(stmt.executeStep(), stack);
+  do_check_eq(stmt.row.title, aTitle, stack);
+  stmt.finalize();
+}
+
+// Test Functions
+
+add_task(function* test_interface_exists() {
+  let history = Cc["@mozilla.org/browser/history;1"].getService(Ci.nsISupports);
+  do_check_true(history instanceof Ci.mozIAsyncHistory);
+});
+
+add_task(function* test_invalid_uri_throws() {
+  // First, test passing in nothing.
+  let place = {
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  try {
+    yield promiseUpdatePlaces(place);
+    do_throw("Should have thrown!");
+  }
+  catch (e) {
+    do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+
+  // Now, test other bogus things.
+  const TEST_VALUES = [
+    null,
+    undefined,
+    {},
+    [],
+    TEST_DOMAIN + "test_invalid_id_throws",
+  ];
+  for (let i = 0; i < TEST_VALUES.length; i++) {
+    place.uri = TEST_VALUES[i];
+    try {
+      yield promiseUpdatePlaces(place);
+      do_throw("Should have thrown!");
+    }
+    catch (e) {
+      do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+    }
+  }
+});
+
+add_task(function* test_invalid_places_throws() {
+  // First, test passing in nothing.
+  try {
+    PlacesUtils.asyncHistory.updatePlaces();
+    do_throw("Should have thrown!");
+  }
+  catch (e) {
+    do_check_eq(e.result, Cr.NS_ERROR_XPC_NOT_ENOUGH_ARGS);
+  }
+
+  // Now, test other bogus things.
+  const TEST_VALUES = [
+    null,
+    undefined,
+    {},
+    [],
+    "",
+  ];
+  for (let i = 0; i < TEST_VALUES.length; i++) {
+    let value = TEST_VALUES[i];
+    try {
+      yield promiseUpdatePlaces(value);
+      do_throw("Should have thrown!");
+    }
+    catch (e) {
+      do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+    }
+  }
+});
+
+add_task(function* test_invalid_guid_throws() {
+  // First check invalid length guid.
+  let place = {
+    guid: "BAD_GUID",
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_invalid_guid_throws"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  try {
+    yield promiseUpdatePlaces(place);
+    do_throw("Should have thrown!");
+  }
+  catch (e) {
+    do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+
+  // Now check invalid character guid.
+  place.guid = "__BADGUID+__";
+  do_check_eq(place.guid.length, 12);
+  try {
+    yield promiseUpdatePlaces(place);
+    do_throw("Should have thrown!");
+  }
+  catch (e) {
+    do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_no_visits_throws() {
+  const TEST_URI =
+    NetUtil.newURI(TEST_DOMAIN + "test_no_id_or_guid_no_visits_throws");
+  const TEST_GUID = "_RANDOMGUID_";
+
+  let log_test_conditions = function(aPlace) {
+    let str = "Testing place with " +
+      (aPlace.uri ? "uri" : "no uri") + ", " +
+      (aPlace.guid ? "guid" : "no guid") + ", " +
+      (aPlace.visits ? "visits array" : "no visits array");
+    do_print(str);
+  };
+
+  // Loop through every possible case.  Note that we don't actually care about
+  // the case where we have no uri, place id, or guid (covered by another test),
+  // but it is easier to just make sure it too throws than to exclude it.
+  let place = { };
+  for (let uri = 1; uri >= 0; uri--) {
+    place.uri = uri ? TEST_URI : undefined;
+
+    for (let guid = 1; guid >= 0; guid--) {
+      place.guid = guid ? TEST_GUID : undefined;
+
+      for (let visits = 1; visits >= 0; visits--) {
+        place.visits = visits ? [] : undefined;
+
+        log_test_conditions(place);
+        try {
+          yield promiseUpdatePlaces(place);
+          do_throw("Should have thrown!");
+        }
+        catch (e) {
+          do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+        }
+      }
+    }
+  }
+});
+
+add_task(function* test_add_visit_no_date_throws() {
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_add_visit_no_date_throws"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  delete place.visits[0].visitDate;
+  try {
+    yield promiseUpdatePlaces(place);
+    do_throw("Should have thrown!");
+  }
+  catch (e) {
+    do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_add_visit_no_transitionType_throws() {
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_add_visit_no_transitionType_throws"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  delete place.visits[0].transitionType;
+  try {
+    yield promiseUpdatePlaces(place);
+    do_throw("Should have thrown!");
+  }
+  catch (e) {
+    do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_add_visit_invalid_transitionType_throws() {
+  // First, test something that has a transition type lower than the first one.
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN +
+                        "test_add_visit_invalid_transitionType_throws"),
+    visits: [
+      new VisitInfo(TRANSITION_LINK - 1),
+    ],
+  };
+  try {
+    yield promiseUpdatePlaces(place);
+    do_throw("Should have thrown!");
+  }
+  catch (e) {
+    do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+
+  // Now, test something that has a transition type greater than the last one.
+  place.visits[0] = new VisitInfo(TRANSITION_RELOAD + 1);
+  try {
+    yield promiseUpdatePlaces(place);
+    do_throw("Should have thrown!");
+  }
+  catch (e) {
+    do_check_eq(e.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_non_addable_uri_errors() {
+  // Array of protocols that nsINavHistoryService::canAddURI returns false for.
+  const URLS = [
+    "about:config",
+    "imap://cyrus.andrew.cmu.edu/archive.imap",
+    "news://new.mozilla.org/mozilla.dev.apps.firefox",
+    "mailbox:Inbox",
+    "moz-anno:favicon:http://mozilla.org/made-up-favicon",
+    "view-source:http://mozilla.org",
+    "chrome://browser/content/browser.xul",
+    "resource://gre-resources/hiddenWindow.html",
+    "data:,Hello%2C%20World!",
+    "wyciwyg:/0/http://mozilla.org",
+    "javascript:alert('hello wolrd!');",
+    "blob:foo",
+  ];
+  let places = [];
+  URLS.forEach(function(url) {
+    try {
+      let place = {
+        uri: NetUtil.newURI(url),
+        title: "test for " + url,
+        visits: [
+          new VisitInfo(),
+        ],
+      };
+      places.push(place);
+    }
+    catch (e) {
+      if (e.result != Cr.NS_ERROR_FAILURE) {
+        throw e;
+      }
+      // NetUtil.newURI() can throw if e.g. our app knows about imap://
+      // but the account is not set up and so the URL is invalid for us.
+      // Note this in the log but ignore as it's not the subject of this test.
+      do_print("Could not construct URI for '" + url + "'; ignoring");
+    }
+  });
+
+  let placesResult = yield promiseUpdatePlaces(places);
+  if (placesResult.results.length > 0) {
+    do_throw("Unexpected success.");
+  }
+  for (let place of placesResult.errors) {
+    do_print("Checking '" + place.info.uri.spec + "'");
+    do_check_eq(place.resultCode, Cr.NS_ERROR_INVALID_ARG);
+    do_check_false(yield promiseIsURIVisited(place.info.uri));
+  }
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_duplicate_guid_errors() {
+  // This test ensures that trying to add a visit, with a guid already found in
+  // another visit, fails.
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_duplicate_guid_fails_first"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+
+  do_check_false(yield promiseIsURIVisited(place.uri));
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  let placeInfo = placesResult.results[0];
+  do_check_true(yield promiseIsURIVisited(placeInfo.uri));
+
+  let badPlace = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_duplicate_guid_fails_second"),
+    visits: [
+      new VisitInfo(),
+    ],
+    guid: placeInfo.guid,
+  };
+
+  do_check_false(yield promiseIsURIVisited(badPlace.uri));
+  placesResult = yield promiseUpdatePlaces(badPlace);
+  if (placesResult.results.length > 0) {
+    do_throw("Unexpected success.");
+  }
+  let badPlaceInfo = placesResult.errors[0];
+  do_check_eq(badPlaceInfo.resultCode, Cr.NS_ERROR_STORAGE_CONSTRAINT);
+  do_check_false(yield promiseIsURIVisited(badPlaceInfo.info.uri));
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_invalid_referrerURI_ignored() {
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN +
+                        "test_invalid_referrerURI_ignored"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  place.visits[0].referrerURI = NetUtil.newURI(place.uri.spec + "_unvisistedURI");
+  do_check_false(yield promiseIsURIVisited(place.uri));
+  do_check_false(yield promiseIsURIVisited(place.visits[0].referrerURI));
+
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  let placeInfo = placesResult.results[0];
+  do_check_true(yield promiseIsURIVisited(placeInfo.uri));
+
+  // Check to make sure we do not visit the invalid referrer.
+  do_check_false(yield promiseIsURIVisited(place.visits[0].referrerURI));
+
+  // Check to make sure from_visit is zero in database.
+  let stmt = DBConn().createStatement(
+    `SELECT from_visit
+     FROM moz_historyvisits
+     WHERE id = :visit_id`
+  );
+  stmt.params.visit_id = placeInfo.visits[0].visitId;
+  do_check_true(stmt.executeStep());
+  do_check_eq(stmt.row.from_visit, 0);
+  stmt.finalize();
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_nonnsIURI_referrerURI_ignored() {
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN +
+                        "test_nonnsIURI_referrerURI_ignored"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  place.visits[0].referrerURI = place.uri.spec + "_nonnsIURI";
+  do_check_false(yield promiseIsURIVisited(place.uri));
+
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  let placeInfo = placesResult.results[0];
+  do_check_true(yield promiseIsURIVisited(placeInfo.uri));
+
+  // Check to make sure from_visit is zero in database.
+  let stmt = DBConn().createStatement(
+    `SELECT from_visit
+     FROM moz_historyvisits
+     WHERE id = :visit_id`
+  );
+  stmt.params.visit_id = placeInfo.visits[0].visitId;
+  do_check_true(stmt.executeStep());
+  do_check_eq(stmt.row.from_visit, 0);
+  stmt.finalize();
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_old_referrer_ignored() {
+  // This tests that a referrer for a visit which is not recent (specifically,
+  // older than 15 minutes as per RECENT_EVENT_THRESHOLD) is not saved by
+  // updatePlaces.
+  let oldTime = (Date.now() * 1000) - (RECENT_EVENT_THRESHOLD + 1);
+  let referrerPlace = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_old_referrer_ignored_referrer"),
+    visits: [
+      new VisitInfo(TRANSITION_LINK, oldTime),
+    ],
+  };
+
+  // First we must add our referrer to the history so that it is not ignored
+  // as being invalid.
+  do_check_false(yield promiseIsURIVisited(referrerPlace.uri));
+  let placesResult = yield promiseUpdatePlaces(referrerPlace);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+
+  // Now that the referrer is added, we can add a page with a valid
+  // referrer to determine if the recency of the referrer is taken into
+  // account.
+  do_check_true(yield promiseIsURIVisited(referrerPlace.uri));
+
+  let visitInfo = new VisitInfo();
+  visitInfo.referrerURI = referrerPlace.uri;
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_old_referrer_ignored_page"),
+    visits: [
+      visitInfo,
+    ],
+  };
+
+  do_check_false(yield promiseIsURIVisited(place.uri));
+  placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  let placeInfo = placesResult.results[0];
+  do_check_true(yield promiseIsURIVisited(place.uri));
+
+  // Though the visit will not contain the referrer, we must examine the
+  // database to be sure.
+  do_check_eq(placeInfo.visits[0].referrerURI, null);
+  let stmt = DBConn().createStatement(
+    `SELECT COUNT(1) AS count
+     FROM moz_historyvisits
+     JOIN moz_places h ON h.id = place_id
+     WHERE url_hash = hash(:page_url) AND url = :page_url
+     AND from_visit = 0`
+  );
+  stmt.params.page_url = place.uri.spec;
+  do_check_true(stmt.executeStep());
+  do_check_eq(stmt.row.count, 1);
+  stmt.finalize();
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_place_id_ignored() {
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_place_id_ignored_first"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+
+  do_check_false(yield promiseIsURIVisited(place.uri));
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  let placeInfo = placesResult.results[0];
+  do_check_true(yield promiseIsURIVisited(place.uri));
+
+  let placeId = placeInfo.placeId;
+  do_check_neq(placeId, 0);
+
+  let badPlace = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_place_id_ignored_second"),
+    visits: [
+      new VisitInfo(),
+    ],
+    placeId: placeId,
+  };
+
+  do_check_false(yield promiseIsURIVisited(badPlace.uri));
+  placesResult = yield promiseUpdatePlaces(badPlace);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  placeInfo = placesResult.results[0];
+
+  do_check_neq(placeInfo.placeId, placeId);
+  do_check_true(yield promiseIsURIVisited(badPlace.uri));
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_handleCompletion_called_when_complete() {
+  // We test a normal visit, and embeded visit, and a uri that would fail
+  // the canAddURI test to make sure that the notification happens after *all*
+  // of them have had a callback.
+  let places = [
+    { uri: NetUtil.newURI(TEST_DOMAIN +
+                          "test_handleCompletion_called_when_complete"),
+      visits: [
+        new VisitInfo(),
+        new VisitInfo(TRANSITION_EMBED),
+      ],
+    },
+    { uri: NetUtil.newURI("data:,Hello%2C%20World!"),
+      visits: [
+        new VisitInfo(),
+      ],
+    },
+  ];
+  do_check_false(yield promiseIsURIVisited(places[0].uri));
+  do_check_false(yield promiseIsURIVisited(places[1].uri));
+
+  const EXPECTED_COUNT_SUCCESS = 2;
+  const EXPECTED_COUNT_FAILURE = 1;
+
+  let {results, errors} = yield promiseUpdatePlaces(places);
+
+  do_check_eq(results.length, EXPECTED_COUNT_SUCCESS);
+  do_check_eq(errors.length, EXPECTED_COUNT_FAILURE);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_add_visit() {
+  const VISIT_TIME = Date.now() * 1000;
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_add_visit"),
+    title: "test_add_visit title",
+    visits: [],
+  };
+  for (let t in PlacesUtils.history.TRANSITIONS) {
+    let transitionType = PlacesUtils.history.TRANSITIONS[t];
+    place.visits.push(new VisitInfo(transitionType, VISIT_TIME));
+  }
+  do_check_false(yield promiseIsURIVisited(place.uri));
+
+  let callbackCount = 0;
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  for (let placeInfo of placesResult.results) {
+    do_check_true(yield promiseIsURIVisited(place.uri));
+
+    // Check mozIPlaceInfo properties.
+    do_check_true(place.uri.equals(placeInfo.uri));
+    do_check_eq(placeInfo.frecency, -1); // We don't pass frecency here!
+    do_check_eq(placeInfo.title, place.title);
+
+    // Check mozIVisitInfo properties.
+    let visits = placeInfo.visits;
+    do_check_eq(visits.length, 1);
+    let visit = visits[0];
+    do_check_eq(visit.visitDate, VISIT_TIME);
+    do_check_true(Object.values(PlacesUtils.history.TRANSITIONS).includes(visit.transitionType));
+    do_check_true(visit.referrerURI === null);
+
+    // For TRANSITION_EMBED visits, many properties will always be zero or
+    // undefined.
+    if (visit.transitionType == TRANSITION_EMBED) {
+      // Check mozIPlaceInfo properties.
+      do_check_eq(placeInfo.placeId, 0, '//');
+      do_check_eq(placeInfo.guid, null);
+
+      // Check mozIVisitInfo properties.
+      do_check_eq(visit.visitId, 0);
+    }
+    // But they should be valid for non-embed visits.
+    else {
+      // Check mozIPlaceInfo properties.
+      do_check_true(placeInfo.placeId > 0);
+      do_check_valid_places_guid(placeInfo.guid);
+
+      // Check mozIVisitInfo properties.
+      do_check_true(visit.visitId > 0);
+    }
+
+    // If we have had all of our callbacks, continue running tests.
+    if (++callbackCount == place.visits.length) {
+      yield PlacesTestUtils.promiseAsyncUpdates();
+    }
+  }
+});
+
+add_task(function* test_properties_saved() {
+  // Check each transition type to make sure it is saved properly.
+  let places = [];
+  for (let t in PlacesUtils.history.TRANSITIONS) {
+    let transitionType = PlacesUtils.history.TRANSITIONS[t];
+    let place = {
+      uri: NetUtil.newURI(TEST_DOMAIN + "test_properties_saved/" +
+                          transitionType),
+      title: "test_properties_saved test",
+      visits: [
+        new VisitInfo(transitionType),
+      ],
+    };
+    do_check_false(yield promiseIsURIVisited(place.uri));
+    places.push(place);
+  }
+
+  let callbackCount = 0;
+  let placesResult = yield promiseUpdatePlaces(places);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  for (let placeInfo of placesResult.results) {
+    let uri = placeInfo.uri;
+    do_check_true(yield promiseIsURIVisited(uri));
+    let visit = placeInfo.visits[0];
+    print("TEST-INFO | test_properties_saved | updatePlaces callback for " +
+          "transition type " + visit.transitionType);
+
+    // Note that TRANSITION_EMBED should not be in the database.
+    const EXPECTED_COUNT = visit.transitionType == TRANSITION_EMBED ? 0 : 1;
+
+    // mozIVisitInfo::date
+    let stmt = DBConn().createStatement(
+      `SELECT COUNT(1) AS count
+       FROM moz_places h
+       JOIN moz_historyvisits v
+       ON h.id = v.place_id
+       WHERE h.url_hash = hash(:page_url) AND h.url = :page_url
+       AND v.visit_date = :visit_date`
+    );
+    stmt.params.page_url = uri.spec;
+    stmt.params.visit_date = visit.visitDate;
+    do_check_true(stmt.executeStep());
+    do_check_eq(stmt.row.count, EXPECTED_COUNT);
+    stmt.finalize();
+
+    // mozIVisitInfo::transitionType
+    stmt = DBConn().createStatement(
+      `SELECT COUNT(1) AS count
+       FROM moz_places h
+       JOIN moz_historyvisits v
+       ON h.id = v.place_id
+       WHERE h.url_hash = hash(:page_url) AND h.url = :page_url
+       AND v.visit_type = :transition_type`
+    );
+    stmt.params.page_url = uri.spec;
+    stmt.params.transition_type = visit.transitionType;
+    do_check_true(stmt.executeStep());
+    do_check_eq(stmt.row.count, EXPECTED_COUNT);
+    stmt.finalize();
+
+    // mozIPlaceInfo::title
+    stmt = DBConn().createStatement(
+      `SELECT COUNT(1) AS count
+       FROM moz_places h
+       WHERE h.url_hash = hash(:page_url) AND h.url = :page_url
+       AND h.title = :title`
+    );
+    stmt.params.page_url = uri.spec;
+    stmt.params.title = placeInfo.title;
+    do_check_true(stmt.executeStep());
+    do_check_eq(stmt.row.count, EXPECTED_COUNT);
+    stmt.finalize();
+
+    // If we have had all of our callbacks, continue running tests.
+    if (++callbackCount == places.length) {
+      yield PlacesTestUtils.promiseAsyncUpdates();
+    }
+  }
+});
+
+add_task(function* test_guid_saved() {
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_guid_saved"),
+    guid: "__TESTGUID__",
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  do_check_valid_places_guid(place.guid);
+  do_check_false(yield promiseIsURIVisited(place.uri));
+
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  let placeInfo = placesResult.results[0];
+  let uri = placeInfo.uri;
+  do_check_true(yield promiseIsURIVisited(uri));
+  do_check_eq(placeInfo.guid, place.guid);
+  do_check_guid_for_uri(uri, place.guid);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_referrer_saved() {
+  let places = [
+    { uri: NetUtil.newURI(TEST_DOMAIN + "test_referrer_saved/referrer"),
+      visits: [
+        new VisitInfo(),
+      ],
+    },
+    { uri: NetUtil.newURI(TEST_DOMAIN + "test_referrer_saved/test"),
+      visits: [
+        new VisitInfo(),
+      ],
+    },
+  ];
+  places[1].visits[0].referrerURI = places[0].uri;
+  do_check_false(yield promiseIsURIVisited(places[0].uri));
+  do_check_false(yield promiseIsURIVisited(places[1].uri));
+
+  let resultCount = 0;
+  let placesResult = yield promiseUpdatePlaces(places);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  for (let placeInfo of placesResult.results) {
+    let uri = placeInfo.uri;
+    do_check_true(yield promiseIsURIVisited(uri));
+    let visit = placeInfo.visits[0];
+
+    // We need to insert all of our visits before we can test conditions.
+    if (++resultCount == places.length) {
+      do_check_true(places[0].uri.equals(visit.referrerURI));
+
+      let stmt = DBConn().createStatement(
+        `SELECT COUNT(1) AS count
+         FROM moz_historyvisits
+         JOIN moz_places h ON h.id = place_id
+         WHERE url_hash = hash(:page_url) AND url = :page_url
+         AND from_visit = (
+           SELECT v.id
+           FROM moz_historyvisits v
+           JOIN moz_places h ON h.id = place_id
+           WHERE url_hash = hash(:referrer) AND url = :referrer
+         )`
+      );
+      stmt.params.page_url = uri.spec;
+      stmt.params.referrer = visit.referrerURI.spec;
+      do_check_true(stmt.executeStep());
+      do_check_eq(stmt.row.count, 1);
+      stmt.finalize();
+
+      yield PlacesTestUtils.promiseAsyncUpdates();
+    }
+  }
+});
+
+add_task(function* test_guid_change_saved() {
+  // First, add a visit for it.
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_guid_change_saved"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  do_check_false(yield promiseIsURIVisited(place.uri));
+
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  // Then, change the guid with visits.
+  place.guid = "_GUIDCHANGE_";
+  place.visits = [new VisitInfo()];
+  placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  do_check_guid_for_uri(place.uri, place.guid);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_title_change_saved() {
+  // First, add a visit for it.
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_title_change_saved"),
+    title: "original title",
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  do_check_false(yield promiseIsURIVisited(place.uri));
+
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+
+  // Now, make sure the empty string clears the title.
+  place.title = "";
+  place.visits = [new VisitInfo()];
+  placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  do_check_title_for_uri(place.uri, null);
+
+  // Then, change the title with visits.
+  place.title = "title change";
+  place.visits = [new VisitInfo()];
+  placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  do_check_title_for_uri(place.uri, place.title);
+
+  // Lastly, check that the title is cleared if we set it to null.
+  place.title = null;
+  place.visits = [new VisitInfo()];
+  placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  do_check_title_for_uri(place.uri, place.title);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_no_title_does_not_clear_title() {
+  const TITLE = "test title";
+  // First, add a visit for it.
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_no_title_does_not_clear_title"),
+    title: TITLE,
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  do_check_false(yield promiseIsURIVisited(place.uri));
+
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  // Now, make sure that not specifying a title does not clear it.
+  delete place.title;
+  place.visits = [new VisitInfo()];
+  placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+  do_check_title_for_uri(place.uri, TITLE);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_title_change_notifies() {
+  // There are three cases to test.  The first case is to make sure we do not
+  // get notified if we do not specify a title.
+  let place = {
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_title_change_notifies"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  do_check_false(yield promiseIsURIVisited(place.uri));
+
+  let silentObserver =
+    new TitleChangedObserver(place.uri, "DO NOT WANT", function() {
+      do_throw("unexpected callback!");
+    });
+
+  PlacesUtils.history.addObserver(silentObserver, false);
+  let placesResult = yield promiseUpdatePlaces(place);
+  if (placesResult.errors.length > 0) {
+    do_throw("Unexpected error.");
+  }
+
+  // The second case to test is that we get the notification when we add
+  // it for the first time.  The first case will fail before our callback if it
+  // is busted, so we can do this now.
+  place.uri = NetUtil.newURI(place.uri.spec + "/new-visit-with-title");
+  place.title = "title 1";
+  function promiseTitleChangedObserver(aPlace) {
+    return new Promise((resolve, reject) => {
+      let callbackCount = 0;
+      let observer = new TitleChangedObserver(aPlace.uri, aPlace.title, function() {
+        switch (++callbackCount) {
+          case 1:
+            // The third case to test is to make sure we get a notification when
+            // we change an existing place.
+            observer.expectedTitle = place.title = "title 2";
+            place.visits = [new VisitInfo()];
+            PlacesUtils.asyncHistory.updatePlaces(place);
+            break;
+          case 2:
+            PlacesUtils.history.removeObserver(silentObserver);
+            PlacesUtils.history.removeObserver(observer);
+            resolve();
+            break;
+        }
+      });
+
+      PlacesUtils.history.addObserver(observer, false);
+      PlacesUtils.asyncHistory.updatePlaces(aPlace);
+    });
+  }
+
+  yield promiseTitleChangedObserver(place);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_visit_notifies() {
+  // There are two observers we need to see for each visit.  One is an
+  // nsINavHistoryObserver and the other is the uri-visit-saved observer topic.
+  let place = {
+    guid: "abcdefghijkl",
+    uri: NetUtil.newURI(TEST_DOMAIN + "test_visit_notifies"),
+    visits: [
+      new VisitInfo(),
+    ],
+  };
+  do_check_false(yield promiseIsURIVisited(place.uri));
+
+  function promiseVisitObserver(aPlace) {
+    return new Promise((resolve, reject) => {
+      let callbackCount = 0;
+      let finisher = function() {
+        if (++callbackCount == 2) {
+          resolve();
+        }
+      }
+      let visitObserver = new VisitObserver(place.uri, place.guid,
+                                            function(aVisitDate,
+                                                     aTransitionType) {
+        let visit = place.visits[0];
+        do_check_eq(visit.visitDate, aVisitDate);
+        do_check_eq(visit.transitionType, aTransitionType);
+
+        PlacesUtils.history.removeObserver(visitObserver);
+        finisher();
+      });
+      PlacesUtils.history.addObserver(visitObserver, false);
+      let observer = function(aSubject, aTopic, aData) {
+        do_print("observe(" + aSubject + ", " + aTopic + ", " + aData + ")");
+        do_check_true(aSubject instanceof Ci.nsIURI);
+        do_check_true(aSubject.equals(place.uri));
+
+        Services.obs.removeObserver(observer, URI_VISIT_SAVED);
+        finisher();
+      };
+      Services.obs.addObserver(observer, URI_VISIT_SAVED, false);
+      PlacesUtils.asyncHistory.updatePlaces(place);
+    });
+  }
+
+  yield promiseVisitObserver(place);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+// test with empty mozIVisitInfoCallback object
+add_task(function* test_callbacks_not_supplied() {
+  const URLS = [
+    "imap://cyrus.andrew.cmu.edu/archive.imap",  // bad URI
+    "http://mozilla.org/" // valid URI
+  ];
+  let places = [];
+  URLS.forEach(function(url) {
+    try {
+      let place = {
+        uri: NetUtil.newURI(url),
+        title: "test for " + url,
+        visits: [
+          new VisitInfo(),
+        ],
+      };
+      places.push(place);
+    }
+    catch (e) {
+      if (e.result != Cr.NS_ERROR_FAILURE) {
+        throw e;
+      }
+      // NetUtil.newURI() can throw if e.g. our app knows about imap://
+      // but the account is not set up and so the URL is invalid for us.
+      // Note this in the log but ignore as it's not the subject of this test.
+      do_print("Could not construct URI for '" + url + "'; ignoring");
+    }
+  });
+
+  PlacesUtils.asyncHistory.updatePlaces(places, {});
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+// Test that we don't wrongly overwrite typed and hidden when adding new visits.
+add_task(function* test_typed_hidden_not_overwritten() {
+  yield PlacesTestUtils.clearHistory();
+  let places = [
+    { uri: NetUtil.newURI("http://mozilla.org/"),
+      title: "test",
+      visits: [
+        new VisitInfo(TRANSITION_TYPED),
+        new VisitInfo(TRANSITION_LINK)
+      ]
+    },
+    { uri: NetUtil.newURI("http://mozilla.org/"),
+      title: "test",
+      visits: [
+        new VisitInfo(TRANSITION_FRAMED_LINK)
+      ]
+    },
+  ];
+  yield promiseUpdatePlaces(places);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.execute(
+    "SELECT hidden, typed FROM moz_places WHERE url_hash = hash(:url) AND url = :url",
+    { url: "http://mozilla.org/" });
+  Assert.equal(rows[0].getResultByName("typed"), 1,
+               "The page should be marked as typed");
+  Assert.equal(rows[0].getResultByName("hidden"), 0,
+               "The page should be marked as not hidden");
+});
+
+function run_test()
+{
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_async_in_batchmode.js b/toolkit/components/places/tests/unit/test_async_in_batchmode.js
new file mode 100644
index 000000000..b39b26519
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_async_in_batchmode.js
@@ -0,0 +1,55 @@
+// This is testing the frankenstein situation Sync forces Places into.
+// Sync does runInBatchMode() and before the callback returns the Places async
+// APIs are used (either by Sync itself, or by any other code in the system)
+// As seen in bug 1197856 and bug 1190131.
+
+Cu.import("resource://gre/modules/PlacesUtils.jsm");
+
+// This function "waits" for a promise to resolve by spinning a nested event
+// loop.
+function waitForPromise(promise) {
+  let thread = Cc["@mozilla.org/thread-manager;1"].getService().currentThread;
+
+  let finalResult, finalException;
+
+  promise.then(result => {
+    finalResult = result;
+  }, err => {
+    finalException = err;
+  });
+
+  // Keep waiting until our callback is triggered (unless the app is quitting).
+  while (!finalResult && !finalException) {
+    thread.processNextEvent(true);
+  }
+  if (finalException) {
+    throw finalException;
+  }
+  return finalResult;
+}
+
+add_test(function() {
+  let testCompleted = false;
+  PlacesUtils.bookmarks.runInBatchMode({
+    runBatched() {
+      // create a bookmark.
+      let info = { parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                   type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                   url: "http://example.com/" };
+      let insertPromise = PlacesUtils.bookmarks.insert(info);
+      let bookmark = waitForPromise(insertPromise);
+      // Check we got a bookmark (bookmark creation failed completely in
+      // bug 1190131)
+      equal(bookmark.url, info.url);
+      // Check the promiseItemGuid and promiseItemId helpers - failure in these
+      // was the underlying reason for the failure.
+      let id = waitForPromise(PlacesUtils.promiseItemId(bookmark.guid));
+      let guid = waitForPromise(PlacesUtils.promiseItemGuid(id));
+      equal(guid, bookmark.guid, "id and guid round-tripped correctly");
+      testCompleted = true;
+    }
+  }, null);
+  // make sure we tested what we think we tested.
+  ok(testCompleted);
+  run_next_test();
+});
diff --git a/toolkit/components/places/tests/unit/test_async_transactions.js b/toolkit/components/places/tests/unit/test_async_transactions.js
new file mode 100644
index 000000000..edc9abf87
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_async_transactions.js
@@ -0,0 +1,1739 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const bmsvc    = PlacesUtils.bookmarks;
+const tagssvc  = PlacesUtils.tagging;
+const annosvc  = PlacesUtils.annotations;
+const PT       = PlacesTransactions;
+const rootGuid = PlacesUtils.bookmarks.rootGuid;
+
+Components.utils.importGlobalProperties(["URL"]);
+
+// Create and add bookmarks observer.
+var observer = {
+  __proto__: NavBookmarkObserver.prototype,
+
+  tagRelatedGuids: new Set(),
+
+  reset: function () {
+    this.itemsAdded = new Map();
+    this.itemsRemoved = new Map();
+    this.itemsChanged = new Map();
+    this.itemsMoved = new Map();
+    this.beginUpdateBatch = false;
+    this.endUpdateBatch = false;
+  },
+
+  onBeginUpdateBatch: function () {
+    this.beginUpdateBatch = true;
+  },
+
+  onEndUpdateBatch: function () {
+    this.endUpdateBatch = true;
+  },
+
+  onItemAdded:
+  function (aItemId, aParentId, aIndex, aItemType, aURI, aTitle, aDateAdded,
+            aGuid, aParentGuid) {
+    // Ignore tag items.
+    if (aParentId == PlacesUtils.tagsFolderId ||
+        (aParentId != PlacesUtils.placesRootId &&
+         bmsvc.getFolderIdForItem(aParentId) == PlacesUtils.tagsFolderId)) {
+      this.tagRelatedGuids.add(aGuid);
+      return;
+    }
+
+    this.itemsAdded.set(aGuid, { itemId:         aItemId
+                               , parentGuid:     aParentGuid
+                               , index:          aIndex
+                               , itemType:       aItemType
+                               , title:          aTitle
+                               , url:            aURI });
+  },
+
+  onItemRemoved:
+  function (aItemId, aParentId, aIndex, aItemType, aURI, aGuid, aParentGuid) {
+    if (this.tagRelatedGuids.has(aGuid))
+      return;
+
+    this.itemsRemoved.set(aGuid, { parentGuid: aParentGuid
+                                 , index:      aIndex
+                                 , itemType:   aItemType });
+  },
+
+  onItemChanged:
+  function (aItemId, aProperty, aIsAnnoProperty, aNewValue, aLastModified,
+            aItemType, aParentId, aGuid, aParentGuid) {
+    if (this.tagRelatedGuids.has(aGuid))
+      return;
+
+    let changesForGuid = this.itemsChanged.get(aGuid);
+    if (changesForGuid === undefined) {
+      changesForGuid = new Map();
+      this.itemsChanged.set(aGuid, changesForGuid);
+    }
+
+    let newValue = aNewValue;
+    if (aIsAnnoProperty) {
+      if (annosvc.itemHasAnnotation(aItemId, aProperty))
+        newValue = annosvc.getItemAnnotation(aItemId, aProperty);
+      else
+        newValue = null;
+    }
+    let change = { isAnnoProperty: aIsAnnoProperty
+                 , newValue: newValue
+                 , lastModified: aLastModified
+                 , itemType: aItemType };
+    changesForGuid.set(aProperty, change);
+  },
+
+  onItemVisited: () => {},
+
+  onItemMoved:
+  function (aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex, aItemType,
+            aGuid, aOldParentGuid, aNewParentGuid) {
+    this.itemsMoved.set(aGuid, { oldParentGuid: aOldParentGuid
+                               , oldIndex:      aOldIndex
+                               , newParentGuid: aNewParentGuid
+                               , newIndex:      aNewIndex
+                               , itemType:      aItemType });
+  }
+};
+observer.reset();
+
+// index at which items should begin
+var bmStartIndex = 0;
+
+function run_test() {
+  bmsvc.addObserver(observer, false);
+  do_register_cleanup(function () {
+    bmsvc.removeObserver(observer);
+  });
+
+  run_next_test();
+}
+
+function sanityCheckTransactionHistory() {
+  do_check_true(PT.undoPosition <= PT.length);
+
+  let check_entry_throws = f => {
+    try {
+      f();
+      do_throw("PT.entry should throw for invalid input");
+    } catch (ex) {}
+  };
+  check_entry_throws( () => PT.entry(-1) );
+  check_entry_throws( () => PT.entry({}) );
+  check_entry_throws( () => PT.entry(PT.length) );
+
+  if (PT.undoPosition < PT.length)
+    do_check_eq(PT.topUndoEntry, PT.entry(PT.undoPosition));
+  else
+    do_check_null(PT.topUndoEntry);
+  if (PT.undoPosition > 0)
+    do_check_eq(PT.topRedoEntry, PT.entry(PT.undoPosition - 1));
+  else
+    do_check_null(PT.topRedoEntry);
+}
+
+function getTransactionsHistoryState() {
+  let history = [];
+  for (let i = 0; i < PT.length; i++) {
+    history.push(PT.entry(i));
+  }
+  return [history, PT.undoPosition];
+}
+
+function ensureUndoState(aExpectedEntries = [], aExpectedUndoPosition = 0) {
+  // ensureUndoState is called in various places during this test, so it's
+  // a good places to sanity-check the transaction-history APIs in all
+  // cases.
+  sanityCheckTransactionHistory();
+
+  let [actualEntries, actualUndoPosition] = getTransactionsHistoryState();
+  do_check_eq(actualEntries.length, aExpectedEntries.length);
+  do_check_eq(actualUndoPosition, aExpectedUndoPosition);
+
+  function checkEqualEntries(aExpectedEntry, aActualEntry) {
+    do_check_eq(aExpectedEntry.length, aActualEntry.length);
+    aExpectedEntry.forEach( (t, i) => do_check_eq(t, aActualEntry[i]) );
+  }
+  aExpectedEntries.forEach( (e, i) => checkEqualEntries(e, actualEntries[i]) );
+}
+
+function ensureItemsAdded(...items) {
+  Assert.equal(observer.itemsAdded.size, items.length);
+  for (let item of items) {
+    Assert.ok(observer.itemsAdded.has(item.guid));
+    let info = observer.itemsAdded.get(item.guid);
+    Assert.equal(info.parentGuid, item.parentGuid);
+    for (let propName of ["title", "index", "itemType"]) {
+      if (propName in item)
+        Assert.equal(info[propName], item[propName]);
+    }
+    if ("url" in item)
+      Assert.ok(info.url.equals(item.url));
+  }
+}
+
+function ensureItemsRemoved(...items) {
+  Assert.equal(observer.itemsRemoved.size, items.length);
+  for (let item of items) {
+    // We accept both guids and full info object here.
+    if (typeof(item) == "string") {
+      Assert.ok(observer.itemsRemoved.has(item));
+    }
+    else {
+      Assert.ok(observer.itemsRemoved.has(item.guid));
+      let info = observer.itemsRemoved.get(item.guid);
+      Assert.equal(info.parentGuid, item.parentGuid);
+      if ("index" in item)
+        Assert.equal(info.index, item.index);
+    }
+  }
+}
+
+function ensureItemsChanged(...items) {
+  for (let item of items) {
+    do_check_true(observer.itemsChanged.has(item.guid));
+    let changes = observer.itemsChanged.get(item.guid);
+    do_check_true(changes.has(item.property));
+    let info = changes.get(item.property);
+    do_check_eq(info.isAnnoProperty, Boolean(item.isAnnoProperty));
+    do_check_eq(info.newValue, item.newValue);
+    if ("url" in item)
+      do_check_true(item.url.equals(info.url));
+  }
+}
+
+function ensureAnnotationsSet(aGuid, aAnnos) {
+  do_check_true(observer.itemsChanged.has(aGuid));
+  let changes = observer.itemsChanged.get(aGuid);
+  for (let anno of aAnnos) {
+    do_check_true(changes.has(anno.name));
+    let changeInfo = changes.get(anno.name);
+    do_check_true(changeInfo.isAnnoProperty);
+    do_check_eq(changeInfo.newValue, anno.value);
+  }
+}
+
+function ensureItemsMoved(...items) {
+  do_check_true(observer.itemsMoved.size, items.length);
+  for (let item of items) {
+    do_check_true(observer.itemsMoved.has(item.guid));
+    let info = observer.itemsMoved.get(item.guid);
+    do_check_eq(info.oldParentGuid, item.oldParentGuid);
+    do_check_eq(info.oldIndex, item.oldIndex);
+    do_check_eq(info.newParentGuid, item.newParentGuid);
+    do_check_eq(info.newIndex, item.newIndex);
+  }
+}
+
+function ensureTimestampsUpdated(aGuid, aCheckDateAdded = false) {
+  do_check_true(observer.itemsChanged.has(aGuid));
+  let changes = observer.itemsChanged.get(aGuid);
+  if (aCheckDateAdded)
+    do_check_true(changes.has("dateAdded"))
+  do_check_true(changes.has("lastModified"));
+}
+
+function ensureTagsForURI(aURI, aTags) {
+  let tagsSet = tagssvc.getTagsForURI(aURI);
+  do_check_eq(tagsSet.length, aTags.length);
+  do_check_true(aTags.every( t => tagsSet.includes(t)));
+}
+
+function createTestFolderInfo(aTitle = "Test Folder") {
+  return { parentGuid: rootGuid, title: "Test Folder" };
+}
+
+function isLivemarkTree(aTree) {
+  return !!aTree.annos &&
+         aTree.annos.some( a => a.name == PlacesUtils.LMANNO_FEEDURI );
+}
+
+function* ensureLivemarkCreatedByAddLivemark(aLivemarkGuid) {
+  // This throws otherwise.
+  yield PlacesUtils.livemarks.getLivemark({ guid: aLivemarkGuid });
+}
+
+// Checks if two bookmark trees (as returned by promiseBookmarksTree) are the
+// same.
+// false value for aCheckParentAndPosition is ignored if aIsRestoredItem is set.
+function* ensureEqualBookmarksTrees(aOriginal,
+                                    aNew,
+                                    aIsRestoredItem = true,
+                                    aCheckParentAndPosition = false) {
+  // Note "id" is not-enumerable, and is therefore skipped by Object.keys (both
+  // ours and the one at deepEqual). This is fine for us because ids are not
+  // restored by Redo.
+  if (aIsRestoredItem) {
+    Assert.deepEqual(aOriginal, aNew);
+    if (isLivemarkTree(aNew))
+      yield ensureLivemarkCreatedByAddLivemark(aNew.guid);
+    return;
+  }
+
+  for (let property of Object.keys(aOriginal)) {
+    if (property == "children") {
+      Assert.equal(aOriginal.children.length, aNew.children.length);
+      for (let i = 0; i < aOriginal.children.length; i++) {
+        yield ensureEqualBookmarksTrees(aOriginal.children[i],
+                                        aNew.children[i],
+                                        false,
+                                        true);
+      }
+    }
+    else if (property == "guid") {
+      // guid shouldn't be copied if the item was not restored.
+      Assert.notEqual(aOriginal.guid, aNew.guid);
+    }
+    else if (property == "dateAdded") {
+      // dateAdded shouldn't be copied if the item was not restored.
+      Assert.ok(is_time_ordered(aOriginal.dateAdded, aNew.dateAdded));
+    }
+    else if (property == "lastModified") {
+      // same same, except for the never-changed case
+      if (!aOriginal.lastModified)
+        Assert.ok(!aNew.lastModified);
+      else
+        Assert.ok(is_time_ordered(aOriginal.lastModified, aNew.lastModified));
+    }
+    else if (aCheckParentAndPosition ||
+             (property != "parentGuid" && property != "index")) {
+      Assert.deepEqual(aOriginal[property], aNew[property]);
+    }
+  }
+
+  if (isLivemarkTree(aNew))
+    yield ensureLivemarkCreatedByAddLivemark(aNew.guid);
+}
+
+function* ensureBookmarksTreeRestoredCorrectly(...aOriginalBookmarksTrees) {
+  for (let originalTree of aOriginalBookmarksTrees) {
+    let restoredTree =
+      yield PlacesUtils.promiseBookmarksTree(originalTree.guid);
+    yield ensureEqualBookmarksTrees(originalTree, restoredTree);
+  }
+}
+
+function* ensureNonExistent(...aGuids) {
+  for (let guid of aGuids) {
+    Assert.strictEqual((yield PlacesUtils.promiseBookmarksTree(guid)), null);
+  }
+}
+
+add_task(function* test_recycled_transactions() {
+  function* ensureTransactThrowsFor(aTransaction) {
+    let [txns, undoPosition] = getTransactionsHistoryState();
+    try {
+      yield aTransaction.transact();
+      do_throw("Shouldn't be able to use the same transaction twice");
+    }
+    catch (ex) { }
+    ensureUndoState(txns, undoPosition);
+  }
+
+  let txn_a = PT.NewFolder(createTestFolderInfo());
+  yield txn_a.transact();
+  ensureUndoState([[txn_a]], 0);
+  yield ensureTransactThrowsFor(txn_a);
+
+  yield PT.undo();
+  ensureUndoState([[txn_a]], 1);
+  ensureTransactThrowsFor(txn_a);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+  ensureTransactThrowsFor(txn_a);
+
+  let txn_b = PT.NewFolder(createTestFolderInfo());
+  yield PT.batch(function* () {
+    try {
+      yield txn_a.transact();
+      do_throw("Shouldn't be able to use the same transaction twice");
+    }
+    catch (ex) { }
+    ensureUndoState();
+    yield txn_b.transact();
+  });
+  ensureUndoState([[txn_b]], 0);
+
+  yield PT.undo();
+  ensureUndoState([[txn_b]], 1);
+  ensureTransactThrowsFor(txn_a);
+  ensureTransactThrowsFor(txn_b);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+  observer.reset();
+});
+
+add_task(function* test_new_folder_with_annotation() {
+  const ANNO = { name: "TestAnno", value: "TestValue" };
+  let folder_info = createTestFolderInfo();
+  folder_info.index = bmStartIndex;
+  folder_info.annotations = [ANNO];
+  ensureUndoState();
+  let txn = PT.NewFolder(folder_info);
+  folder_info.guid = yield txn.transact();
+  let ensureDo = function* (aRedo = false) {
+    ensureUndoState([[txn]], 0);
+    yield ensureItemsAdded(folder_info);
+    ensureAnnotationsSet(folder_info.guid, [ANNO]);
+    if (aRedo)
+      ensureTimestampsUpdated(folder_info.guid, true);
+    observer.reset();
+  };
+
+  let ensureUndo = () => {
+    ensureUndoState([[txn]], 1);
+    ensureItemsRemoved({ guid:       folder_info.guid
+                       , parentGuid: folder_info.parentGuid
+                       , index:      bmStartIndex });
+    observer.reset();
+  };
+
+  yield ensureDo();
+  yield PT.undo();
+  yield ensureUndo();
+  yield PT.redo();
+  yield ensureDo(true);
+  yield PT.undo();
+  ensureUndo();
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_new_bookmark() {
+  let bm_info = { parentGuid: rootGuid
+                , url:        NetUtil.newURI("http://test_create_item.com")
+                , index:      bmStartIndex
+                , title:      "Test creating an item" };
+
+  ensureUndoState();
+  let txn = PT.NewBookmark(bm_info);
+  bm_info.guid = yield txn.transact();
+
+  let ensureDo = function* (aRedo = false) {
+    ensureUndoState([[txn]], 0);
+    yield ensureItemsAdded(bm_info);
+    if (aRedo)
+      ensureTimestampsUpdated(bm_info.guid, true);
+    observer.reset();
+  };
+  let ensureUndo = () => {
+    ensureUndoState([[txn]], 1);
+    ensureItemsRemoved({ guid:       bm_info.guid
+                       , parentGuid: bm_info.parentGuid
+                       , index:      bmStartIndex });
+    observer.reset();
+  };
+
+  yield ensureDo();
+  yield PT.undo();
+  ensureUndo();
+  yield PT.redo(true);
+  yield ensureDo();
+  yield PT.undo();
+  ensureUndo();
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_merge_create_folder_and_item() {
+  let folder_info = createTestFolderInfo();
+  let bm_info = { url: NetUtil.newURI("http://test_create_item_to_folder.com")
+                , title: "Test Bookmark"
+                , index: bmStartIndex };
+
+  let [folderTxnResult, bkmTxnResult] = yield PT.batch(function* () {
+    let folderTxn = PT.NewFolder(folder_info);
+    folder_info.guid = bm_info.parentGuid = yield folderTxn.transact();
+    let bkmTxn = PT.NewBookmark(bm_info);
+    bm_info.guid = yield bkmTxn.transact();
+    return [folderTxn, bkmTxn];
+  });
+
+  let ensureDo = function* () {
+    ensureUndoState([[bkmTxnResult, folderTxnResult]], 0);
+    yield ensureItemsAdded(folder_info, bm_info);
+    observer.reset();
+  };
+
+  let ensureUndo = () => {
+    ensureUndoState([[bkmTxnResult, folderTxnResult]], 1);
+    ensureItemsRemoved(folder_info, bm_info);
+    observer.reset();
+  };
+
+  yield ensureDo();
+  yield PT.undo();
+  ensureUndo();
+  yield PT.redo();
+  yield ensureDo();
+  yield PT.undo();
+  ensureUndo();
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_move_items_to_folder() {
+  let folder_a_info = createTestFolderInfo("Folder A");
+  let bkm_a_info = { url: new URL("http://test_move_items.com")
+                   , title: "Bookmark A" };
+  let bkm_b_info = { url: NetUtil.newURI("http://test_move_items.com")
+                   , title: "Bookmark B" };
+
+  // Test moving items within the same folder.
+  let [folder_a_txn_result, bkm_a_txn_result, bkm_b_txn_result] = yield PT.batch(function* () {
+    let folder_a_txn = PT.NewFolder(folder_a_info);
+
+    folder_a_info.guid = bkm_a_info.parentGuid = bkm_b_info.parentGuid =
+      yield folder_a_txn.transact();
+    let bkm_a_txn = PT.NewBookmark(bkm_a_info);
+    bkm_a_info.guid = yield bkm_a_txn.transact();
+    let bkm_b_txn = PT.NewBookmark(bkm_b_info);
+    bkm_b_info.guid = yield bkm_b_txn.transact();
+    return [folder_a_txn, bkm_a_txn, bkm_b_txn];
+  });
+
+  ensureUndoState([[bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result]], 0);
+
+  let moveTxn = PT.Move({ guid:          bkm_a_info.guid
+                        , newParentGuid: folder_a_info.guid });
+  yield moveTxn.transact();
+
+  let ensureDo = () => {
+    ensureUndoState([[moveTxn], [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result]], 0);
+    ensureItemsMoved({ guid:          bkm_a_info.guid
+                     , oldParentGuid: folder_a_info.guid
+                     , newParentGuid: folder_a_info.guid
+                     , oldIndex:      0
+                     , newIndex:      1 });
+    observer.reset();
+  };
+  let ensureUndo = () => {
+    ensureUndoState([[moveTxn], [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result]], 1);
+    ensureItemsMoved({ guid:          bkm_a_info.guid
+                     , oldParentGuid: folder_a_info.guid
+                     , newParentGuid: folder_a_info.guid
+                     , oldIndex:      1
+                     , newIndex:      0 });
+    observer.reset();
+  };
+
+  ensureDo();
+  yield PT.undo();
+  ensureUndo();
+  yield PT.redo();
+  ensureDo();
+  yield PT.undo();
+  ensureUndo();
+
+  yield PT.clearTransactionsHistory(false, true);
+  ensureUndoState([[bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result]], 0);
+
+  // Test moving items between folders.
+  let folder_b_info = createTestFolderInfo("Folder B");
+  let folder_b_txn = PT.NewFolder(folder_b_info);
+  folder_b_info.guid = yield folder_b_txn.transact();
+  ensureUndoState([ [folder_b_txn]
+                  , [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result] ], 0);
+
+  moveTxn = PT.Move({ guid:          bkm_a_info.guid
+                    , newParentGuid: folder_b_info.guid
+                    , newIndex:      bmsvc.DEFAULT_INDEX });
+  yield moveTxn.transact();
+
+  ensureDo = () => {
+    ensureUndoState([ [moveTxn]
+                    , [folder_b_txn]
+                    , [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result] ], 0);
+    ensureItemsMoved({ guid:          bkm_a_info.guid
+                     , oldParentGuid: folder_a_info.guid
+                     , newParentGuid: folder_b_info.guid
+                     , oldIndex:      0
+                     , newIndex:      0 });
+    observer.reset();
+  };
+  ensureUndo = () => {
+    ensureUndoState([ [moveTxn]
+                    , [folder_b_txn]
+                    , [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result] ], 1);
+    ensureItemsMoved({ guid:          bkm_a_info.guid
+                     , oldParentGuid: folder_b_info.guid
+                     , newParentGuid: folder_a_info.guid
+                     , oldIndex:      0
+                     , newIndex:      0 });
+    observer.reset();
+  };
+
+  ensureDo();
+  yield PT.undo();
+  ensureUndo();
+  yield PT.redo();
+  ensureDo();
+  yield PT.undo();
+  ensureUndo();
+
+  // Clean up
+  yield PT.undo();  // folder_b_txn
+  yield PT.undo();  // folder_a_txn + the bookmarks;
+  do_check_eq(observer.itemsRemoved.size, 4);
+  ensureUndoState([ [moveTxn]
+                  , [folder_b_txn]
+                  , [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result] ], 3);
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_remove_folder() {
+  let folder_level_1_info = createTestFolderInfo("Folder Level 1");
+  let folder_level_2_info = { title: "Folder Level 2" };
+  let [folder_level_1_txn_result,
+       folder_level_2_txn_result] = yield PT.batch(function* () {
+    let folder_level_1_txn  = PT.NewFolder(folder_level_1_info);
+    folder_level_1_info.guid = yield folder_level_1_txn.transact();
+    folder_level_2_info.parentGuid = folder_level_1_info.guid;
+    let folder_level_2_txn = PT.NewFolder(folder_level_2_info);
+    folder_level_2_info.guid = yield folder_level_2_txn.transact();
+    return [folder_level_1_txn, folder_level_2_txn];
+  });
+
+  ensureUndoState([[folder_level_2_txn_result, folder_level_1_txn_result]]);
+  yield ensureItemsAdded(folder_level_1_info, folder_level_2_info);
+  observer.reset();
+
+  let remove_folder_2_txn = PT.Remove(folder_level_2_info);
+  yield remove_folder_2_txn.transact();
+
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ]);
+  yield ensureItemsRemoved(folder_level_2_info);
+
+  // Undo Remove "Folder Level 2"
+  yield PT.undo();
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ], 1);
+  yield ensureItemsAdded(folder_level_2_info);
+  ensureTimestampsUpdated(folder_level_2_info.guid, true);
+  observer.reset();
+
+  // Redo Remove "Folder Level 2"
+  yield PT.redo();
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ]);
+  yield ensureItemsRemoved(folder_level_2_info);
+  observer.reset();
+
+  // Undo it again
+  yield PT.undo();
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ], 1);
+  yield ensureItemsAdded(folder_level_2_info);
+  ensureTimestampsUpdated(folder_level_2_info.guid, true);
+  observer.reset();
+
+  // Undo the creation of both folders
+  yield PT.undo();
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ], 2);
+  yield ensureItemsRemoved(folder_level_2_info, folder_level_1_info);
+  observer.reset();
+
+  // Redo the creation of both folders
+  yield PT.redo();
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ], 1);
+  yield ensureItemsAdded(folder_level_1_info, folder_level_2_info);
+  ensureTimestampsUpdated(folder_level_1_info.guid, true);
+  ensureTimestampsUpdated(folder_level_2_info.guid, true);
+  observer.reset();
+
+  // Redo Remove "Folder Level 2"
+  yield PT.redo();
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ]);
+  yield ensureItemsRemoved(folder_level_2_info);
+  observer.reset();
+
+  // Undo everything one last time
+  yield PT.undo();
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ], 1);
+  yield ensureItemsAdded(folder_level_2_info);
+  observer.reset();
+
+  yield PT.undo();
+  ensureUndoState([ [remove_folder_2_txn]
+                  , [folder_level_2_txn_result, folder_level_1_txn_result] ], 2);
+  yield ensureItemsRemoved(folder_level_2_info, folder_level_2_info);
+  observer.reset();
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_add_and_remove_bookmarks_with_additional_info() {
+  const testURI = NetUtil.newURI("http://add.remove.tag");
+  const TAG_1 = "TestTag1";
+  const TAG_2 = "TestTag2";
+  const KEYWORD = "test_keyword";
+  const POST_DATA = "post_data";
+  const ANNO = { name: "TestAnno", value: "TestAnnoValue" };
+
+  let folder_info = createTestFolderInfo();
+  folder_info.guid = yield PT.NewFolder(folder_info).transact();
+  let ensureTags = ensureTagsForURI.bind(null, testURI);
+
+  // Check that the NewBookmark transaction preserves tags.
+  observer.reset();
+  let b1_info = { parentGuid: folder_info.guid, url: testURI, tags: [TAG_1] };
+  b1_info.guid = yield PT.NewBookmark(b1_info).transact();
+  ensureTags([TAG_1]);
+  yield PT.undo();
+  ensureTags([]);
+
+  observer.reset();
+  yield PT.redo();
+  ensureTimestampsUpdated(b1_info.guid, true);
+  ensureTags([TAG_1]);
+
+  // Check if the Remove transaction removes and restores tags of children
+  // correctly.
+  yield PT.Remove(folder_info.guid).transact();
+  ensureTags([]);
+
+  observer.reset();
+  yield PT.undo();
+  ensureTimestampsUpdated(b1_info.guid, true);
+  ensureTags([TAG_1]);
+
+  yield PT.redo();
+  ensureTags([]);
+
+  observer.reset();
+  yield PT.undo();
+  ensureTimestampsUpdated(b1_info.guid, true);
+  ensureTags([TAG_1]);
+
+  // * Check that no-op tagging (the uri is already tagged with TAG_1) is
+  //   also a no-op on undo.
+  // * Test the "keyword" property of the NewBookmark transaction.
+  observer.reset();
+  let b2_info = { parentGuid:  folder_info.guid
+                , url:         testURI, tags: [TAG_1, TAG_2]
+                , keyword:     KEYWORD
+                , postData:    POST_DATA
+                , annotations: [ANNO] };
+  b2_info.guid = yield PT.NewBookmark(b2_info).transact();
+  let b2_post_creation_changes = [
+   { guid: b2_info.guid
+   , isAnnoProperty: true
+   , property: ANNO.name
+   , newValue: ANNO.value },
+   { guid: b2_info.guid
+   , property: "keyword"
+   , newValue: KEYWORD } ];
+  ensureItemsChanged(...b2_post_creation_changes);
+  ensureTags([TAG_1, TAG_2]);
+
+  observer.reset();
+  yield PT.undo();
+  yield ensureItemsRemoved(b2_info);
+  ensureTags([TAG_1]);
+
+  // Check if Remove correctly restores keywords, tags and annotations.
+  // Since both bookmarks share the same uri, they also share the keyword that
+  // is not removed along with one of the bookmarks.
+  observer.reset();
+  yield PT.redo();
+  ensureItemsChanged({ guid: b2_info.guid
+                     , isAnnoProperty: true
+                     , property: ANNO.name
+                     , newValue: ANNO.value });
+  ensureTags([TAG_1, TAG_2]);
+
+  // Test Remove for multiple items.
+  observer.reset();
+  yield PT.Remove(b1_info.guid).transact();
+  yield PT.Remove(b2_info.guid).transact();
+  yield PT.Remove(folder_info.guid).transact();
+  yield ensureItemsRemoved(b1_info, b2_info, folder_info);
+  ensureTags([]);
+  // There is no keyword removal notification cause all bookmarks are removed
+  // before the keyword itself, so there's no one to notify.
+  let entry = yield PlacesUtils.keywords.fetch(KEYWORD);
+  Assert.equal(entry, null, "keyword has been removed");
+
+  observer.reset();
+  yield PT.undo();
+  yield ensureItemsAdded(folder_info);
+  ensureTags([]);
+
+  observer.reset();
+  yield PT.undo();
+  ensureItemsChanged(...b2_post_creation_changes);
+  ensureTags([TAG_1, TAG_2]);
+
+  observer.reset();
+  yield PT.undo();
+  yield ensureItemsAdded(b1_info);
+  ensureTags([TAG_1, TAG_2]);
+
+  // The redo calls below cleanup everything we did.
+  observer.reset();
+  yield PT.redo();
+  yield ensureItemsRemoved(b1_info);
+  ensureTags([TAG_1, TAG_2]);
+
+  observer.reset();
+  yield PT.redo();
+  yield ensureItemsRemoved(b2_info);
+  ensureTags([]);
+
+  observer.reset();
+  yield PT.redo();
+  yield ensureItemsRemoved(folder_info);
+  ensureTags([]);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_creating_and_removing_a_separator() {
+  let folder_info = createTestFolderInfo();
+  let separator_info = {};
+  let undoEntries = [];
+
+  observer.reset();
+  let create_txns = yield PT.batch(function* () {
+    let folder_txn = PT.NewFolder(folder_info);
+    folder_info.guid = separator_info.parentGuid = yield folder_txn.transact();
+    let separator_txn = PT.NewSeparator(separator_info);
+    separator_info.guid = yield separator_txn.transact();
+    return [separator_txn, folder_txn];
+  });
+  undoEntries.unshift(create_txns);
+  ensureUndoState(undoEntries, 0);
+  ensureItemsAdded(folder_info, separator_info);
+
+  observer.reset();
+  yield PT.undo();
+  ensureUndoState(undoEntries, 1);
+  ensureItemsRemoved(folder_info, separator_info);
+
+  observer.reset();
+  yield PT.redo();
+  ensureUndoState(undoEntries, 0);
+  ensureItemsAdded(folder_info, separator_info);
+
+  observer.reset();
+  let remove_sep_txn = PT.Remove(separator_info);
+  yield remove_sep_txn.transact();
+  undoEntries.unshift([remove_sep_txn]);
+  ensureUndoState(undoEntries, 0);
+  ensureItemsRemoved(separator_info);
+
+  observer.reset();
+  yield PT.undo();
+  ensureUndoState(undoEntries, 1);
+  ensureItemsAdded(separator_info);
+
+  observer.reset();
+  yield PT.undo();
+  ensureUndoState(undoEntries, 2);
+  ensureItemsRemoved(folder_info, separator_info);
+
+  observer.reset();
+  yield PT.redo();
+  ensureUndoState(undoEntries, 1);
+  ensureItemsAdded(folder_info, separator_info);
+
+  // Clear redo entries and check that |redo| does nothing
+  observer.reset();
+  yield PT.clearTransactionsHistory(false, true);
+  undoEntries.shift();
+  ensureUndoState(undoEntries, 0);
+  yield PT.redo();
+  ensureItemsAdded();
+  ensureItemsRemoved();
+
+  // Cleanup
+  observer.reset();
+  yield PT.undo();
+  ensureUndoState(undoEntries, 1);
+  ensureItemsRemoved(folder_info, separator_info);
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_add_and_remove_livemark() {
+  let createLivemarkTxn = PT.NewLivemark(
+    { feedUrl: NetUtil.newURI("http://test.remove.livemark")
+    , parentGuid: rootGuid
+    , title: "Test Remove Livemark" });
+  let guid = yield createLivemarkTxn.transact();
+  let originalInfo = yield PlacesUtils.promiseBookmarksTree(guid);
+  Assert.ok(originalInfo);
+  yield ensureLivemarkCreatedByAddLivemark(guid);
+
+  let removeTxn = PT.Remove(guid);
+  yield removeTxn.transact();
+  yield ensureNonExistent(guid);
+  function* undo() {
+    ensureUndoState([[removeTxn], [createLivemarkTxn]], 0);
+    yield PT.undo();
+    ensureUndoState([[removeTxn], [createLivemarkTxn]], 1);
+    yield ensureBookmarksTreeRestoredCorrectly(originalInfo);
+    yield PT.undo();
+    ensureUndoState([[removeTxn], [createLivemarkTxn]], 2);
+    yield ensureNonExistent(guid);
+  }
+  function* redo() {
+    ensureUndoState([[removeTxn], [createLivemarkTxn]], 2);
+    yield PT.redo();
+    ensureUndoState([[removeTxn], [createLivemarkTxn]], 1);
+    yield ensureBookmarksTreeRestoredCorrectly(originalInfo);
+    yield PT.redo();
+    ensureUndoState([[removeTxn], [createLivemarkTxn]], 0);
+    yield ensureNonExistent(guid);
+  }
+
+  yield undo();
+  yield redo();
+  yield undo();
+  yield redo();
+
+  // Cleanup
+  yield undo();
+  observer.reset();
+  yield PT.clearTransactionsHistory();
+});
+
+add_task(function* test_edit_title() {
+  let bm_info = { parentGuid: rootGuid
+                , url:        NetUtil.newURI("http://test_create_item.com")
+                , title:      "Original Title" };
+
+  function ensureTitleChange(aCurrentTitle) {
+    ensureItemsChanged({ guid: bm_info.guid
+                       , property: "title"
+                       , newValue: aCurrentTitle});
+  }
+
+  bm_info.guid = yield PT.NewBookmark(bm_info).transact();
+
+  observer.reset();
+  yield PT.EditTitle({ guid: bm_info.guid, title: "New Title" }).transact();
+  ensureTitleChange("New Title");
+
+  observer.reset();
+  yield PT.undo();
+  ensureTitleChange("Original Title");
+
+  observer.reset();
+  yield PT.redo();
+  ensureTitleChange("New Title");
+
+  // Cleanup
+  observer.reset();
+  yield PT.undo();
+  ensureTitleChange("Original Title");
+  yield PT.undo();
+  ensureItemsRemoved(bm_info);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_edit_url() {
+  let oldURI = NetUtil.newURI("http://old.test_editing_item_uri.com/");
+  let newURI = NetUtil.newURI("http://new.test_editing_item_uri.com/");
+  let bm_info = { parentGuid: rootGuid, url: oldURI, tags: ["TestTag"] };
+  function ensureURIAndTags(aPreChangeURI, aPostChangeURI, aOLdURITagsPreserved) {
+    ensureItemsChanged({ guid: bm_info.guid
+                       , property: "uri"
+                       , newValue: aPostChangeURI.spec });
+    ensureTagsForURI(aPostChangeURI, bm_info.tags);
+    ensureTagsForURI(aPreChangeURI, aOLdURITagsPreserved ? bm_info.tags : []);
+  }
+
+  bm_info.guid = yield PT.NewBookmark(bm_info).transact();
+  ensureTagsForURI(oldURI, bm_info.tags);
+
+  // When there's a single bookmark for the same url, tags should be moved.
+  observer.reset();
+  yield PT.EditUrl({ guid: bm_info.guid, url: newURI }).transact();
+  ensureURIAndTags(oldURI, newURI, false);
+
+  observer.reset();
+  yield PT.undo();
+  ensureURIAndTags(newURI, oldURI, false);
+
+  observer.reset();
+  yield PT.redo();
+  ensureURIAndTags(oldURI, newURI, false);
+
+  observer.reset();
+  yield PT.undo();
+  ensureURIAndTags(newURI, oldURI, false);
+
+  // When there're multiple bookmarks for the same url, tags should be copied.
+  let bm2_info = Object.create(bm_info);
+  bm2_info.guid = yield PT.NewBookmark(bm2_info).transact();
+  let bm3_info = Object.create(bm_info);
+  bm3_info.url = newURI;
+  bm3_info.guid = yield PT.NewBookmark(bm3_info).transact();
+
+  observer.reset();
+  yield PT.EditUrl({ guid: bm_info.guid, url: newURI }).transact();
+  ensureURIAndTags(oldURI, newURI, true);
+
+  observer.reset();
+  yield PT.undo();
+  ensureURIAndTags(newURI, oldURI, true);
+
+  observer.reset();
+  yield PT.redo();
+  ensureURIAndTags(oldURI, newURI, true);
+
+  // Cleanup
+  observer.reset();
+  yield PT.undo();
+  ensureURIAndTags(newURI, oldURI, true);
+  yield PT.undo();
+  yield PT.undo();
+  yield PT.undo();
+  ensureItemsRemoved(bm3_info, bm2_info, bm_info);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_edit_keyword() {
+  let bm_info = { parentGuid: rootGuid
+                , url: NetUtil.newURI("http://test.edit.keyword") };
+  const KEYWORD = "test_keyword";
+  bm_info.guid = yield PT.NewBookmark(bm_info).transact();
+  function ensureKeywordChange(aCurrentKeyword = "") {
+    ensureItemsChanged({ guid: bm_info.guid
+                       , property: "keyword"
+                       , newValue: aCurrentKeyword });
+  }
+
+  bm_info.guid = yield PT.NewBookmark(bm_info).transact();
+
+  observer.reset();
+  yield PT.EditKeyword({ guid: bm_info.guid, keyword: KEYWORD, postData: "postData" }).transact();
+  ensureKeywordChange(KEYWORD);
+  let entry = yield PlacesUtils.keywords.fetch(KEYWORD);
+  Assert.equal(entry.url.href, bm_info.url.spec);
+  Assert.equal(entry.postData, "postData");
+
+  observer.reset();
+  yield PT.undo();
+  ensureKeywordChange();
+  entry = yield PlacesUtils.keywords.fetch(KEYWORD);
+  Assert.equal(entry, null);
+
+  observer.reset();
+  yield PT.redo();
+  ensureKeywordChange(KEYWORD);
+  entry = yield PlacesUtils.keywords.fetch(KEYWORD);
+  Assert.equal(entry.url.href, bm_info.url.spec);
+  Assert.equal(entry.postData, "postData");
+
+  // Cleanup
+  observer.reset();
+  yield PT.undo();
+  ensureKeywordChange();
+  yield PT.undo();
+  ensureItemsRemoved(bm_info);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_edit_specific_keyword() {
+  let bm_info = { parentGuid: rootGuid
+                , url: NetUtil.newURI("http://test.edit.keyword") };
+  bm_info.guid = yield PT.NewBookmark(bm_info).transact();
+  function ensureKeywordChange(aCurrentKeyword = "", aPreviousKeyword = "") {
+    ensureItemsChanged({ guid: bm_info.guid
+                       , property: "keyword"
+                       , newValue: aCurrentKeyword
+                       });
+  }
+
+  yield PlacesUtils.keywords.insert({ keyword: "kw1", url: bm_info.url.spec, postData: "postData1" });
+  yield PlacesUtils.keywords.insert({ keyword: "kw2", url: bm_info.url.spec, postData: "postData2" });
+  bm_info.guid = yield PT.NewBookmark(bm_info).transact();
+
+  observer.reset();
+  yield PT.EditKeyword({ guid: bm_info.guid, keyword: "keyword", oldKeyword: "kw2" }).transact();
+  ensureKeywordChange("keyword", "kw2");
+  let entry = yield PlacesUtils.keywords.fetch("kw1");
+  Assert.equal(entry.url.href, bm_info.url.spec);
+  Assert.equal(entry.postData, "postData1");
+  entry = yield PlacesUtils.keywords.fetch("keyword");
+  Assert.equal(entry.url.href, bm_info.url.spec);
+  Assert.equal(entry.postData, "postData2");
+  entry = yield PlacesUtils.keywords.fetch("kw2");
+  Assert.equal(entry, null);
+
+  observer.reset();
+  yield PT.undo();
+  ensureKeywordChange("kw2", "keyword");
+  entry = yield PlacesUtils.keywords.fetch("kw1");
+  Assert.equal(entry.url.href, bm_info.url.spec);
+  Assert.equal(entry.postData, "postData1");
+  entry = yield PlacesUtils.keywords.fetch("kw2");
+  Assert.equal(entry.url.href, bm_info.url.spec);
+  Assert.equal(entry.postData, "postData2");
+  entry = yield PlacesUtils.keywords.fetch("keyword");
+  Assert.equal(entry, null);
+
+  observer.reset();
+  yield PT.redo();
+  ensureKeywordChange("keyword", "kw2");
+  entry = yield PlacesUtils.keywords.fetch("kw1");
+  Assert.equal(entry.url.href, bm_info.url.spec);
+  Assert.equal(entry.postData, "postData1");
+  entry = yield PlacesUtils.keywords.fetch("keyword");
+  Assert.equal(entry.url.href, bm_info.url.spec);
+  Assert.equal(entry.postData, "postData2");
+  entry = yield PlacesUtils.keywords.fetch("kw2");
+  Assert.equal(entry, null);
+
+  // Cleanup
+  observer.reset();
+  yield PT.undo();
+  ensureKeywordChange("kw2");
+  yield PT.undo();
+  ensureItemsRemoved(bm_info);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_tag_uri() {
+  // This also tests passing uri specs.
+  let bm_info_a = { url: "http://bookmarked.uri"
+                  , parentGuid: rootGuid };
+  let bm_info_b = { url: NetUtil.newURI("http://bookmarked2.uri")
+                  , parentGuid: rootGuid };
+  let unbookmarked_uri = NetUtil.newURI("http://un.bookmarked.uri");
+
+  function* promiseIsBookmarked(aURI) {
+    let deferred = Promise.defer();
+    PlacesUtils.asyncGetBookmarkIds(aURI, ids => {
+                                            deferred.resolve(ids.length > 0);
+                                          });
+    return deferred.promise;
+  }
+
+  yield PT.batch(function* () {
+    bm_info_a.guid = yield PT.NewBookmark(bm_info_a).transact();
+    bm_info_b.guid = yield PT.NewBookmark(bm_info_b).transact();
+  });
+
+  function* doTest(aInfo) {
+    let urls = "url" in aInfo ? [aInfo.url] : aInfo.urls;
+    let tags = "tag" in aInfo ? [aInfo.tag] : aInfo.tags;
+
+    let ensureURI = url => typeof(url) == "string" ? NetUtil.newURI(url) : url;
+    urls = urls.map(ensureURI);
+
+    let tagWillAlsoBookmark = new Set();
+    for (let url of urls) {
+      if (!(yield promiseIsBookmarked(url))) {
+        tagWillAlsoBookmark.add(url);
+      }
+    }
+
+    function* ensureTagsSet() {
+      for (let url of urls) {
+        ensureTagsForURI(url, tags);
+        Assert.ok(yield promiseIsBookmarked(url));
+      }
+    }
+    function* ensureTagsUnset() {
+      for (let url of urls) {
+        ensureTagsForURI(url, []);
+        if (tagWillAlsoBookmark.has(url))
+          Assert.ok(!(yield promiseIsBookmarked(url)));
+        else
+          Assert.ok(yield promiseIsBookmarked(url));
+      }
+    }
+
+    yield PT.Tag(aInfo).transact();
+    yield ensureTagsSet();
+    yield PT.undo();
+    yield ensureTagsUnset();
+    yield PT.redo();
+    yield ensureTagsSet();
+    yield PT.undo();
+    yield ensureTagsUnset();
+  }
+
+  yield doTest({ url: bm_info_a.url, tags: ["MyTag"] });
+  yield doTest({ urls: [bm_info_a.url], tag: "MyTag" });
+  yield doTest({ urls: [bm_info_a.url, bm_info_b.url], tags: ["A, B"] });
+  yield doTest({ urls: [bm_info_a.url, unbookmarked_uri], tag: "C" });
+
+  // Cleanup
+  observer.reset();
+  yield PT.undo();
+  ensureItemsRemoved(bm_info_a, bm_info_b);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_untag_uri() {
+  let bm_info_a = { url: NetUtil.newURI("http://bookmarked.uri")
+                  , parentGuid: rootGuid
+                  , tags: ["A", "B"] };
+  let bm_info_b = { url: NetUtil.newURI("http://bookmarked2.uri")
+                  , parentGuid: rootGuid
+                  , tag: "B" };
+
+  yield PT.batch(function* () {
+    bm_info_a.guid = yield PT.NewBookmark(bm_info_a).transact();
+    ensureTagsForURI(bm_info_a.url, bm_info_a.tags);
+    bm_info_b.guid = yield PT.NewBookmark(bm_info_b).transact();
+    ensureTagsForURI(bm_info_b.url, [bm_info_b.tag]);
+  });
+
+  function* doTest(aInfo) {
+    let urls, tagsRemoved;
+    if (aInfo instanceof Ci.nsIURI) {
+      urls = [aInfo];
+      tagsRemoved = [];
+    }
+    else if (Array.isArray(aInfo)) {
+      urls = aInfo;
+      tagsRemoved = [];
+    }
+    else {
+      urls = "url" in aInfo ? [aInfo.url] : aInfo.urls;
+      tagsRemoved = "tag" in aInfo ? [aInfo.tag] : aInfo.tags;
+    }
+
+    let preRemovalTags = new Map();
+    for (let url of urls) {
+      preRemovalTags.set(url, tagssvc.getTagsForURI(url));
+    }
+
+    function ensureTagsSet() {
+      for (let url of urls) {
+        ensureTagsForURI(url, preRemovalTags.get(url));
+      }
+    }
+    function ensureTagsUnset() {
+      for (let url of urls) {
+        let expectedTags = tagsRemoved.length == 0 ?
+           [] : preRemovalTags.get(url).filter(tag => !tagsRemoved.includes(tag));
+        ensureTagsForURI(url, expectedTags);
+      }
+    }
+
+    yield PT.Untag(aInfo).transact();
+    yield ensureTagsUnset();
+    yield PT.undo();
+    yield ensureTagsSet();
+    yield PT.redo();
+    yield ensureTagsUnset();
+    yield PT.undo();
+    yield ensureTagsSet();
+  }
+
+  yield doTest(bm_info_a);
+  yield doTest(bm_info_b);
+  yield doTest(bm_info_a.url);
+  yield doTest(bm_info_b.url);
+  yield doTest([bm_info_a.url, bm_info_b.url]);
+  yield doTest({ urls: [bm_info_a.url, bm_info_b.url], tags: ["A", "B"] });
+  yield doTest({ urls: [bm_info_a.url, bm_info_b.url], tag: "B" });
+  yield doTest({ urls: [bm_info_a.url, bm_info_b.url], tag: "C" });
+  yield doTest({ urls: [bm_info_a.url, bm_info_b.url], tags: ["C"] });
+
+  // Cleanup
+  observer.reset();
+  yield PT.undo();
+  ensureItemsRemoved(bm_info_a, bm_info_b);
+
+  yield PT.clearTransactionsHistory();
+  ensureUndoState();
+});
+
+add_task(function* test_annotate() {
+  let bm_info = { url: NetUtil.newURI("http://test.item.annotation")
+                , parentGuid: rootGuid };
+  let anno_info = { name: "TestAnno", value: "TestValue" };
+  function ensureAnnoState(aSet) {
+    ensureAnnotationsSet(bm_info.guid,
+                         [{ name: anno_info.name
+                          , value: aSet ? anno_info.value : null }]);
+  }
+
+  bm_info.guid = yield PT.NewBookmark(bm_info).transact();
+
+  observer.reset();
+  yield PT.Annotate({ guid: bm_info.guid, annotation: anno_info }).transact();
+  ensureAnnoState(true);
+
+  observer.reset();
+  yield PT.undo();
+  ensureAnnoState(false);
+
+  observer.reset();
+  yield PT.redo();
+  ensureAnnoState(true);
+
+  // Test removing the annotation by not passing the |value| property.
+  observer.reset();
+  yield PT.Annotate({ guid: bm_info.guid,
+                      annotation: { name: anno_info.name }}).transact();
+  ensureAnnoState(false);
+
+  observer.reset();
+  yield PT.undo();
+  ensureAnnoState(true);
+
+  observer.reset();
+  yield PT.redo();
+  ensureAnnoState(false);
+
+  // Cleanup
+  yield PT.undo();
+  observer.reset();
+});
+
+add_task(function* test_annotate_multiple() {
+  let guid = yield PT.NewFolder(createTestFolderInfo()).transact();
+  let itemId = yield PlacesUtils.promiseItemId(guid);
+
+  function AnnoObj(aName, aValue) {
+    this.name = aName;
+    this.value = aValue;
+    this.flags = 0;
+    this.expires = Ci.nsIAnnotationService.EXPIRE_NEVER;
+  }
+
+  function annos(a = null, b = null) {
+    return [new AnnoObj("A", a), new AnnoObj("B", b)];
+  }
+
+  function verifyAnnoValues(a = null, b = null) {
+    let currentAnnos = PlacesUtils.getAnnotationsForItem(itemId);
+    let expectedAnnos = [];
+    if (a !== null)
+      expectedAnnos.push(new AnnoObj("A", a));
+    if (b !== null)
+      expectedAnnos.push(new AnnoObj("B", b));
+
+    Assert.deepEqual(currentAnnos, expectedAnnos);
+  }
+
+  yield PT.Annotate({ guid: guid, annotations: annos(1, 2) }).transact();
+  verifyAnnoValues(1, 2);
+  yield PT.undo();
+  verifyAnnoValues();
+  yield PT.redo();
+  verifyAnnoValues(1, 2);
+
+  yield PT.Annotate({ guid: guid
+                    , annotation: { name: "A" } }).transact();
+  verifyAnnoValues(null, 2);
+
+  yield PT.Annotate({ guid: guid
+                    , annotation: { name: "B", value: 0 } }).transact();
+  verifyAnnoValues(null, 0);
+  yield PT.undo();
+  verifyAnnoValues(null, 2);
+  yield PT.redo();
+  verifyAnnoValues(null, 0);
+  yield PT.undo();
+  verifyAnnoValues(null, 2);
+  yield PT.undo();
+  verifyAnnoValues(1, 2);
+  yield PT.undo();
+  verifyAnnoValues();
+
+  // Cleanup
+  yield PT.undo();
+  observer.reset();
+});
+
+add_task(function* test_sort_folder_by_name() {
+  let folder_info = createTestFolderInfo();
+
+  let url = NetUtil.newURI("http://sort.by.name/");
+  let preSep =  ["3", "2", "1"].map(i => ({ title: i, url }));
+  let sep = {};
+  let postSep = ["c", "b", "a"].map(l => ({ title: l, url }));
+  let originalOrder = [...preSep, sep, ...postSep];
+  let sortedOrder = [...preSep.slice(0).reverse(),
+                     sep,
+                     ...postSep.slice(0).reverse()];
+  yield PT.batch(function* () {
+    folder_info.guid = yield PT.NewFolder(folder_info).transact();
+    for (let info of originalOrder) {
+      info.parentGuid = folder_info.guid;
+      info.guid = yield info == sep ?
+                    PT.NewSeparator(info).transact() :
+                    PT.NewBookmark(info).transact();
+    }
+  });
+
+  let folderId = yield PlacesUtils.promiseItemId(folder_info.guid);
+  let folderContainer = PlacesUtils.getFolderContents(folderId).root;
+  function ensureOrder(aOrder) {
+    for (let i = 0; i < folderContainer.childCount; i++) {
+      do_check_eq(folderContainer.getChild(i).bookmarkGuid, aOrder[i].guid);
+    }
+  }
+
+  ensureOrder(originalOrder);
+  yield PT.SortByName(folder_info.guid).transact();
+  ensureOrder(sortedOrder);
+  yield PT.undo();
+  ensureOrder(originalOrder);
+  yield PT.redo();
+  ensureOrder(sortedOrder);
+
+  // Cleanup
+  observer.reset();
+  yield PT.undo();
+  ensureOrder(originalOrder);
+  yield PT.undo();
+  ensureItemsRemoved(...originalOrder, folder_info);
+});
+
+add_task(function* test_livemark_txns() {
+  let livemark_info =
+    { feedUrl: NetUtil.newURI("http://test.feed.uri")
+    , parentGuid: rootGuid
+    , title: "Test Livemark" };
+  function ensureLivemarkAdded() {
+    ensureItemsAdded({ guid:       livemark_info.guid
+                     , title:      livemark_info.title
+                     , parentGuid: livemark_info.parentGuid
+                     , itemType:   bmsvc.TYPE_FOLDER });
+    let annos = [{ name:  PlacesUtils.LMANNO_FEEDURI
+                 , value: livemark_info.feedUrl.spec }];
+    if ("siteUrl" in livemark_info) {
+      annos.push({ name: PlacesUtils.LMANNO_SITEURI
+                 , value: livemark_info.siteUrl.spec });
+    }
+    ensureAnnotationsSet(livemark_info.guid, annos);
+  }
+  function ensureLivemarkRemoved() {
+    ensureItemsRemoved({ guid:       livemark_info.guid
+                       , parentGuid: livemark_info.parentGuid });
+  }
+
+  function* _testDoUndoRedoUndo() {
+    observer.reset();
+    livemark_info.guid = yield PT.NewLivemark(livemark_info).transact();
+    ensureLivemarkAdded();
+
+    observer.reset();
+    yield PT.undo();
+    ensureLivemarkRemoved();
+
+    observer.reset();
+    yield PT.redo();
+    ensureLivemarkAdded();
+
+    yield PT.undo();
+    ensureLivemarkRemoved();
+  }
+
+  yield* _testDoUndoRedoUndo()
+  livemark_info.siteUrl = NetUtil.newURI("http://feed.site.uri");
+  yield* _testDoUndoRedoUndo();
+
+  // Cleanup
+  observer.reset();
+  yield PT.clearTransactionsHistory();
+});
+
+add_task(function* test_copy() {
+  function* duplicate_and_test(aOriginalGuid) {
+    let txn = PT.Copy({ guid: aOriginalGuid, newParentGuid: rootGuid });
+    yield duplicateGuid = yield txn.transact();
+    let originalInfo = yield PlacesUtils.promiseBookmarksTree(aOriginalGuid);
+    let duplicateInfo = yield PlacesUtils.promiseBookmarksTree(duplicateGuid);
+    yield ensureEqualBookmarksTrees(originalInfo, duplicateInfo, false);
+
+    function* redo() {
+      yield PT.redo();
+      yield ensureBookmarksTreeRestoredCorrectly(originalInfo);
+      yield PT.redo();
+      yield ensureBookmarksTreeRestoredCorrectly(duplicateInfo);
+    }
+    function* undo() {
+      yield PT.undo();
+      // also undo the original item addition.
+      yield PT.undo();
+      yield ensureNonExistent(aOriginalGuid, duplicateGuid);
+    }
+
+    yield undo();
+    yield redo();
+    yield undo();
+    yield redo();
+
+    // Cleanup. This also remove the original item.
+    yield PT.undo();
+    observer.reset();
+    yield PT.clearTransactionsHistory();
+  }
+
+  // Test duplicating leafs (bookmark, separator, empty folder)
+  PT.NewBookmark({ url: new URL("http://test.item.duplicate")
+                 , parentGuid: rootGuid
+                 , annos: [{ name: "Anno", value: "AnnoValue"}] });
+  let sepTxn = PT.NewSeparator({ parentGuid: rootGuid, index: 1 });
+  let livemarkTxn = PT.NewLivemark(
+    { feedUrl: new URL("http://test.feed.uri")
+    , parentGuid: rootGuid
+    , title: "Test Livemark", index: 1 });
+  let emptyFolderTxn = PT.NewFolder(createTestFolderInfo());
+  for (let txn of [livemarkTxn, sepTxn, emptyFolderTxn]) {
+    let guid = yield txn.transact();
+    yield duplicate_and_test(guid);
+  }
+
+  // Test duplicating a folder having some contents.
+  let filledFolderGuid = yield PT.batch(function *() {
+    let folderGuid = yield PT.NewFolder(createTestFolderInfo()).transact();
+    let nestedFolderGuid =
+      yield PT.NewFolder({ parentGuid: folderGuid
+                         , title: "Nested Folder" }).transact();
+    // Insert a bookmark under the nested folder.
+    yield PT.NewBookmark({ url: new URL("http://nested.nested.bookmark")
+                         , parentGuid: nestedFolderGuid }).transact();
+    // Insert a separator below the nested folder
+    yield PT.NewSeparator({ parentGuid: folderGuid }).transact();
+    // And another bookmark.
+    yield PT.NewBookmark({ url: new URL("http://nested.bookmark")
+                         , parentGuid: folderGuid }).transact();
+    return folderGuid;
+  });
+
+  yield duplicate_and_test(filledFolderGuid);
+
+  // Cleanup
+  yield PT.clearTransactionsHistory();
+});
+
+add_task(function* test_array_input_for_batch() {
+  let folderTxn = PT.NewFolder(createTestFolderInfo());
+  let folderGuid = yield folderTxn.transact();
+
+  let sep1_txn = PT.NewSeparator({ parentGuid: folderGuid });
+  let sep2_txn = PT.NewSeparator({ parentGuid: folderGuid });
+  yield PT.batch([sep1_txn, sep2_txn]);
+  ensureUndoState([[sep2_txn, sep1_txn], [folderTxn]], 0);
+
+  let ensureChildCount = function* (count) {
+    let tree = yield PlacesUtils.promiseBookmarksTree(folderGuid);
+    if (count == 0)
+      Assert.ok(!("children" in tree));
+    else
+      Assert.equal(tree.children.length, count);
+  };
+
+  yield ensureChildCount(2);
+  yield PT.undo();
+  yield ensureChildCount(0);
+  yield PT.redo()
+  yield ensureChildCount(2);
+  yield PT.undo();
+  yield ensureChildCount(0);
+
+  yield PT.undo();
+  Assert.equal((yield PlacesUtils.promiseBookmarksTree(folderGuid)), null);
+
+  // Cleanup
+  yield PT.clearTransactionsHistory();
+});
+
+add_task(function* test_copy_excluding_annotations() {
+  let folderInfo = createTestFolderInfo();
+  let anno = n => { return { name: n, value: 1 } };
+  folderInfo.annotations = [anno("a"), anno("b"), anno("c")];
+  let folderGuid = yield PT.NewFolder(folderInfo).transact();
+
+  let ensureAnnosSet = function* (guid, ...expectedAnnoNames) {
+    let tree = yield PlacesUtils.promiseBookmarksTree(guid);
+    let annoNames = "annos" in tree ?
+                      tree.annos.map(a => a.name).sort() : [];
+    Assert.deepEqual(annoNames, expectedAnnoNames);
+  };
+
+  yield ensureAnnosSet(folderGuid, "a", "b", "c");
+
+  let excluding_a_dupeGuid =
+    yield PT.Copy({ guid: folderGuid
+                  , newParentGuid: rootGuid
+                  , excludingAnnotation: "a" }).transact();
+  yield ensureAnnosSet(excluding_a_dupeGuid,  "b", "c");
+
+  let excluding_ac_dupeGuid =
+    yield PT.Copy({ guid: folderGuid
+                  , newParentGuid: rootGuid
+                  , excludingAnnotations: ["a", "c"] }).transact();
+  yield ensureAnnosSet(excluding_ac_dupeGuid,  "b");
+
+  // Cleanup
+  yield PT.undo();
+  yield PT.undo();
+  yield PT.undo();
+  yield PT.clearTransactionsHistory();
+});
+
+add_task(function* test_invalid_uri_spec_throws() {
+  Assert.throws(() =>
+    PT.NewBookmark({ parentGuid: rootGuid
+                   , url:        "invalid uri spec"
+                   , title:      "test bookmark" }));
+  Assert.throws(() =>
+    PT.Tag({ tag: "TheTag"
+           , urls: ["invalid uri spec"] }));
+  Assert.throws(() =>
+    PT.Tag({ tag: "TheTag"
+           , urls: ["about:blank", "invalid uri spec"] }));
+});
+
+add_task(function* test_annotate_multiple_items() {
+  let parentGuid = rootGuid;
+  let guids = [
+    yield PT.NewBookmark({ url: "about:blank", parentGuid }).transact(),
+    yield PT.NewFolder({ title: "Test Folder", parentGuid }).transact()];
+
+  let annotation = { name: "TestAnno", value: "TestValue" };
+  yield PT.Annotate({ guids, annotation }).transact();
+
+  function *ensureAnnoSet() {
+    for (let guid of guids) {
+      let itemId = yield PlacesUtils.promiseItemId(guid);
+      Assert.equal(annosvc.getItemAnnotation(itemId, annotation.name),
+                   annotation.value);
+    }
+  }
+  function *ensureAnnoUnset() {
+    for (let guid of guids) {
+      let itemId = yield PlacesUtils.promiseItemId(guid);
+      Assert.ok(!annosvc.itemHasAnnotation(itemId, annotation.name));
+    }
+  }
+
+  yield ensureAnnoSet();
+  yield PT.undo();
+  yield ensureAnnoUnset();
+  yield PT.redo();
+  yield ensureAnnoSet();
+  yield PT.undo();
+  yield ensureAnnoUnset();
+
+  // Cleanup
+  yield PT.undo();
+  yield PT.undo();
+  yield ensureNonExistent(...guids);
+  yield PT.clearTransactionsHistory();
+  observer.reset();
+});
+
+add_task(function* test_remove_multiple() {
+  let guids = [];
+  yield PT.batch(function* () {
+    let folderGuid = yield PT.NewFolder({ title: "Test Folder"
+                                        , parentGuid: rootGuid }).transact();
+    let nestedFolderGuid =
+      yield PT.NewFolder({ title: "Nested Test Folder"
+                         , parentGuid: folderGuid }).transact();
+    yield PT.NewSeparator(nestedFolderGuid).transact();
+
+    guids.push(folderGuid);
+
+    let bmGuid =
+      yield PT.NewBookmark({ url: new URL("http://test.bookmark.removed")
+                           , parentGuid: rootGuid }).transact();
+    guids.push(bmGuid);
+  });
+
+  let originalInfos = [];
+  for (let guid of guids) {
+    originalInfos.push(yield PlacesUtils.promiseBookmarksTree(guid));
+  }
+
+  yield PT.Remove(guids).transact();
+  yield ensureNonExistent(...guids);
+  yield PT.undo();
+  yield ensureBookmarksTreeRestoredCorrectly(...originalInfos);
+  yield PT.redo();
+  yield ensureNonExistent(...guids);
+  yield PT.undo();
+  yield ensureBookmarksTreeRestoredCorrectly(...originalInfos);
+
+  // Undo the New* transactions batch.
+  yield PT.undo();
+  yield ensureNonExistent(...guids);
+
+  // Redo it.
+  yield PT.redo();
+  yield ensureBookmarksTreeRestoredCorrectly(...originalInfos);
+
+  // Redo remove.
+  yield PT.redo();
+  yield ensureNonExistent(...guids);
+
+  // Cleanup
+  yield PT.clearTransactionsHistory();
+  observer.reset();
+});
+
+add_task(function* test_remove_bookmarks_for_urls() {
+  let urls = [new URL("http://test.url.1"), new URL("http://test.url.2")];
+  let guids = [];
+  yield PT.batch(function* () {
+    for (let url of urls) {
+      for (let title of ["test title a", "test title b"]) {
+        let txn = PT.NewBookmark({ url, title, parentGuid: rootGuid });
+        guids.push(yield txn.transact());
+      }
+    }
+  });
+
+  let originalInfos = [];
+  for (let guid of guids) {
+    originalInfos.push(yield PlacesUtils.promiseBookmarksTree(guid));
+  }
+
+  yield PT.RemoveBookmarksForUrls(urls).transact();
+  yield ensureNonExistent(...guids);
+  yield PT.undo();
+  yield ensureBookmarksTreeRestoredCorrectly(...originalInfos);
+  yield PT.redo();
+  yield ensureNonExistent(...guids);
+  yield PT.undo();
+  yield ensureBookmarksTreeRestoredCorrectly(...originalInfos);
+
+  // Cleanup.
+  yield PT.redo();
+  yield ensureNonExistent(...guids);
+  yield PT.clearTransactionsHistory();
+  observer.reset();
+});
diff --git a/toolkit/components/places/tests/unit/test_autocomplete_stopSearch_no_throw.js b/toolkit/components/places/tests/unit/test_autocomplete_stopSearch_no_throw.js
new file mode 100644
index 000000000..7d5df565f
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_autocomplete_stopSearch_no_throw.js
@@ -0,0 +1,39 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Added with bug 508102 to make sure that calling stopSearch on our
+ * AutoComplete implementation does not throw.
+ */
+
+// Globals and Constants
+
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+          getService(Ci.nsINavHistoryService);
+var ac = Cc["@mozilla.org/autocomplete/search;1?name=unifiedcomplete"].
+         getService(Ci.nsIAutoCompleteSearch);
+
+// Test Functions
+
+function test_stopSearch()
+{
+  try {
+    ac.stopSearch();
+  }
+  catch (e) {
+    do_throw("we should not have caught anything!");
+  }
+}
+
+// Test Runner
+
+var tests = [
+  test_stopSearch,
+];
+function run_test()
+{
+  tests.forEach(test => test());
+}
diff --git a/toolkit/components/places/tests/unit/test_bookmark_catobs.js b/toolkit/components/places/tests/unit/test_bookmark_catobs.js
new file mode 100644
index 000000000..e2b589090
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bookmark_catobs.js
@@ -0,0 +1,57 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test() {
+  run_next_test()
+}
+
+add_task(function* test_observers() {
+  do_load_manifest("nsDummyObserver.manifest");
+
+  let dummyCreated = false;
+  let dummyReceivedOnItemAdded = false;
+
+  Services.obs.addObserver(function created() {
+    Services.obs.removeObserver(created, "dummy-observer-created");
+    dummyCreated = true;
+  }, "dummy-observer-created", false);
+  Services.obs.addObserver(function added() {
+    Services.obs.removeObserver(added, "dummy-observer-item-added");
+    dummyReceivedOnItemAdded = true;
+  }, "dummy-observer-item-added", false);
+
+  let initialObservers = PlacesUtils.bookmarks.getObservers();
+
+  // Add a common observer, it should be invoked after the category observer.
+  let notificationsPromised = new Promise((resolve, reject) => {
+    PlacesUtils.bookmarks.addObserver( {
+      __proto__: NavBookmarkObserver.prototype,
+      onItemAdded() {
+        let observers = PlacesUtils.bookmarks.getObservers();
+        Assert.equal(observers.length, initialObservers.length + 1);
+
+        // Check the common observer is the last one.
+        for (let i = 0; i < initialObservers.length; ++i) {
+          Assert.equal(initialObservers[i], observers[i]);
+        }
+
+        PlacesUtils.bookmarks.removeObserver(this);
+        observers = PlacesUtils.bookmarks.getObservers();
+        Assert.equal(observers.length, initialObservers.length);
+
+        // Check the category observer has been invoked before this one.
+        Assert.ok(dummyCreated);
+        Assert.ok(dummyReceivedOnItemAdded);
+        resolve();
+      }
+    }, false);
+  });
+
+  // Add a bookmark
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       uri("http://typed.mozilla.org"),
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "bookmark");
+
+  yield notificationsPromised;
+});
diff --git a/toolkit/components/places/tests/unit/test_bookmarks_html.js b/toolkit/components/places/tests/unit/test_bookmarks_html.js
new file mode 100644
index 000000000..b10dc6185
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bookmarks_html.js
@@ -0,0 +1,385 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const LOAD_IN_SIDEBAR_ANNO = "bookmarkProperties/loadInSidebar";
+const DESCRIPTION_ANNO = "bookmarkProperties/description";
+
+// An object representing the contents of bookmarks.preplaces.html.
+var test_bookmarks = {
+  menu: [
+    { title: "Mozilla Firefox",
+      children: [
+        { title: "Help and Tutorials",
+          url: "http://en-us.www.mozilla.com/en-US/firefox/help/",
+          icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+        },
+        { title: "Customize Firefox",
+          url: "http://en-us.www.mozilla.com/en-US/firefox/customize/",
+          icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+        },
+        { title: "Get Involved",
+          url: "http://en-us.www.mozilla.com/en-US/firefox/community/",
+          icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+        },
+        { title: "About Us",
+          url: "http://en-us.www.mozilla.com/en-US/about/",
+          icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+        }
+      ]
+    },
+    {
+      type: Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR
+    },
+    { title: "test",
+      description: "folder test comment",
+      dateAdded: 1177541020000000,
+      lastModified: 1177541050000000,
+      children: [
+        { title: "test post keyword",
+          description: "item description",
+          dateAdded: 1177375336000000,
+          lastModified: 1177375423000000,
+          keyword: "test",
+          sidebar: true,
+          postData: "hidden1%3Dbar&text1%3D%25s",
+          charset: "ISO-8859-1",
+          url: "http://test/post"
+        }
+      ]
+    }
+  ],
+  toolbar: [
+    { title: "Getting Started",
+      url: "http://en-us.www.mozilla.com/en-US/firefox/central/",
+      icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+    },
+    { title: "Latest Headlines",
+      url: "http://en-us.fxfeeds.mozilla.com/en-US/firefox/livebookmarks/",
+      feedUrl: "http://en-us.fxfeeds.mozilla.com/en-US/firefox/headlines.xml"
+    }
+  ],
+  unfiled: [
+    { title: "Example.tld",
+      url: "http://example.tld/"
+    }
+  ]
+};
+
+// Pre-Places bookmarks.html file pointer.
+var gBookmarksFileOld;
+// Places bookmarks.html file pointer.
+var gBookmarksFileNew;
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* setup() {
+  // Avoid creating smart bookmarks during the test.
+  Services.prefs.setIntPref("browser.places.smartBookmarksVersion", -1);
+
+  // File pointer to legacy bookmarks file.
+  gBookmarksFileOld = do_get_file("bookmarks.preplaces.html");
+
+  // File pointer to a new Places-exported bookmarks file.
+  gBookmarksFileNew = Services.dirsvc.get("ProfD", Ci.nsILocalFile);
+  gBookmarksFileNew.append("bookmarks.exported.html");
+  if (gBookmarksFileNew.exists()) {
+    gBookmarksFileNew.remove(false);
+  }
+
+  // This test must be the first one, since it setups the new bookmarks.html.
+  // Test importing a pre-Places canonical bookmarks file.
+  // 1. import bookmarks.preplaces.html
+  // 2. run the test-suite
+  // Note: we do not empty the db before this import to catch bugs like 380999
+  yield BookmarkHTMLUtils.importFromFile(gBookmarksFileOld, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield testImportedBookmarks();
+
+  yield BookmarkHTMLUtils.exportToFile(gBookmarksFileNew);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_import_new()
+{
+  // Test importing a Places bookmarks.html file.
+  // 1. import bookmarks.exported.html
+  // 2. run the test-suite
+  yield BookmarkHTMLUtils.importFromFile(gBookmarksFileNew, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  yield testImportedBookmarks();
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_emptytitle_export()
+{
+  // Test exporting and importing with an empty-titled bookmark.
+  // 1. import bookmarks
+  // 2. create an empty-titled bookmark.
+  // 3. export to bookmarks.exported.html
+  // 4. empty bookmarks db
+  // 5. import bookmarks.exported.html
+  // 6. run the test-suite
+  // 7. remove the empty-titled bookmark
+  // 8. export to bookmarks.exported.html
+  // 9. empty bookmarks db and continue
+
+  yield BookmarkHTMLUtils.importFromFile(gBookmarksFileNew, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  const NOTITLE_URL = "http://notitle.mozilla.org/";
+  let bookmark = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: NOTITLE_URL
+  });
+  test_bookmarks.unfiled.push({ title: "", url: NOTITLE_URL });
+
+  yield BookmarkHTMLUtils.exportToFile(gBookmarksFileNew);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield PlacesUtils.bookmarks.eraseEverything();
+
+  yield BookmarkHTMLUtils.importFromFile(gBookmarksFileNew, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield testImportedBookmarks();
+
+  // Cleanup.
+  test_bookmarks.unfiled.pop();
+  // HTML imports don't restore GUIDs yet.
+  let reimportedBookmark = yield PlacesUtils.bookmarks.fetch({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    index: PlacesUtils.bookmarks.DEFAULT_INDEX
+  });
+  Assert.equal(reimportedBookmark.url.href, bookmark.url.href);
+  yield PlacesUtils.bookmarks.remove(reimportedBookmark);
+
+  yield BookmarkHTMLUtils.exportToFile(gBookmarksFileNew);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_import_chromefavicon()
+{
+  // Test exporting and importing with a bookmark pointing to a chrome favicon.
+  // 1. import bookmarks
+  // 2. create a bookmark pointing to a chrome favicon.
+  // 3. export to bookmarks.exported.html
+  // 4. empty bookmarks db
+  // 5. import bookmarks.exported.html
+  // 6. run the test-suite
+  // 7. remove the bookmark pointing to a chrome favicon.
+  // 8. export to bookmarks.exported.html
+  // 9. empty bookmarks db and continue
+
+  const PAGE_URI = NetUtil.newURI("http://example.com/chromefavicon_page");
+  const CHROME_FAVICON_URI = NetUtil.newURI("chrome://global/skin/icons/information-16.png");
+  const CHROME_FAVICON_URI_2 = NetUtil.newURI("chrome://global/skin/icons/error-16.png");
+
+  do_print("Importing from html");
+  yield BookmarkHTMLUtils.importFromFile(gBookmarksFileNew, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Insert bookmark");
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    url: PAGE_URI,
+    title: "Test"
+  });
+
+  do_print("Set favicon");
+  yield new Promise(resolve => {
+    PlacesUtils.favicons.setAndFetchFaviconForPage(
+      PAGE_URI, CHROME_FAVICON_URI, true,
+      PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+      resolve, Services.scriptSecurityManager.getSystemPrincipal());
+  });
+
+  let data = yield new Promise(resolve => {
+    PlacesUtils.favicons.getFaviconDataForPage(
+      PAGE_URI, (uri, dataLen, faviconData, mimeType) => resolve(faviconData));
+  });
+
+  let base64Icon = "data:image/png;base64," +
+      base64EncodeString(String.fromCharCode.apply(String, data));
+
+  test_bookmarks.unfiled.push(
+    { title: "Test", url: PAGE_URI.spec, icon: base64Icon });
+
+  do_print("Export to html");
+  yield BookmarkHTMLUtils.exportToFile(gBookmarksFileNew);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Set favicon");
+  // Change the favicon to check it's really imported again later.
+  yield new Promise(resolve => {
+    PlacesUtils.favicons.setAndFetchFaviconForPage(
+      PAGE_URI, CHROME_FAVICON_URI_2, true,
+      PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+      resolve, Services.scriptSecurityManager.getSystemPrincipal());
+  });
+
+  do_print("import from html");
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield BookmarkHTMLUtils.importFromFile(gBookmarksFileNew, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  do_print("Test imported bookmarks");
+  yield testImportedBookmarks();
+
+  // Cleanup.
+  test_bookmarks.unfiled.pop();
+  // HTML imports don't restore GUIDs yet.
+  let reimportedBookmark = yield PlacesUtils.bookmarks.fetch({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    index: PlacesUtils.bookmarks.DEFAULT_INDEX
+  });
+  yield PlacesUtils.bookmarks.remove(reimportedBookmark);
+
+  yield BookmarkHTMLUtils.exportToFile(gBookmarksFileNew);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_import_ontop()
+{
+  // Test importing the exported bookmarks.html file *on top of* the existing
+  // bookmarks.
+  // 1. empty bookmarks db
+  // 2. import the exported bookmarks file
+  // 3. export to file
+  // 3. import the exported bookmarks file
+  // 4. run the test-suite
+
+  yield BookmarkHTMLUtils.importFromFile(gBookmarksFileNew, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield BookmarkHTMLUtils.exportToFile(gBookmarksFileNew);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  yield BookmarkHTMLUtils.importFromFile(gBookmarksFileNew, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield testImportedBookmarks();
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+function* testImportedBookmarks()
+{
+  for (let group in test_bookmarks) {
+    do_print("[testImportedBookmarks()] Checking group '" + group + "'");
+
+    let root;
+    switch (group) {
+      case "menu":
+        root = PlacesUtils.getFolderContents(PlacesUtils.bookmarksMenuFolderId).root;
+        break;
+      case "toolbar":
+        root = PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId).root;
+        break;
+      case "unfiled":
+        root = PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+        break;
+    }
+
+    let items = test_bookmarks[group];
+    do_check_eq(root.childCount, items.length);
+
+    for (let key in items) {
+      yield checkItem(items[key], root.getChild(key));
+    }
+
+    root.containerOpen = false;
+  }
+}
+
+function* checkItem(aExpected, aNode)
+{
+  let id = aNode.itemId;
+
+  return Task.spawn(function* () {
+    for (prop in aExpected) {
+      switch (prop) {
+        case "type":
+          do_check_eq(aNode.type, aExpected.type);
+          break;
+        case "title":
+          do_check_eq(aNode.title, aExpected.title);
+          break;
+        case "description":
+          do_check_eq(PlacesUtils.annotations
+                                 .getItemAnnotation(id, DESCRIPTION_ANNO),
+                      aExpected.description);
+          break;
+        case "dateAdded":
+          do_check_eq(PlacesUtils.bookmarks.getItemDateAdded(id),
+                      aExpected.dateAdded);
+          break;
+        case "lastModified":
+          do_check_eq(PlacesUtils.bookmarks.getItemLastModified(id),
+                      aExpected.lastModified);
+          break;
+        case "url":
+          if (!("feedUrl" in aExpected))
+            do_check_eq(aNode.uri, aExpected.url)
+          break;
+        case "icon":
+          let deferred = Promise.defer();
+          PlacesUtils.favicons.getFaviconDataForPage(
+            NetUtil.newURI(aExpected.url),
+            function (aURI, aDataLen, aData, aMimeType) {
+              deferred.resolve(aData);
+            });
+          let data = yield deferred.promise;
+          let base64Icon = "data:image/png;base64," +
+                           base64EncodeString(String.fromCharCode.apply(String, data));
+          do_check_true(base64Icon == aExpected.icon);
+          break;
+        case "keyword": {
+          let entry = yield PlacesUtils.keywords.fetch({ url: aNode.uri });
+          Assert.equal(entry.keyword, aExpected.keyword);
+          break;
+        }
+        case "sidebar":
+          do_check_eq(PlacesUtils.annotations
+                                 .itemHasAnnotation(id, LOAD_IN_SIDEBAR_ANNO),
+                      aExpected.sidebar);
+          break;
+        case "postData": {
+          let entry = yield PlacesUtils.keywords.fetch({ url: aNode.uri });
+          Assert.equal(entry.postData, aExpected.postData);
+          break;
+        }
+        case "charset":
+          let testURI = NetUtil.newURI(aNode.uri);
+          do_check_eq((yield PlacesUtils.getCharsetForURI(testURI)), aExpected.charset);
+          break;
+        case "feedUrl":
+          let livemark = yield PlacesUtils.livemarks.getLivemark({ id: id });
+          do_check_eq(livemark.siteURI.spec, aExpected.url);
+          do_check_eq(livemark.feedURI.spec, aExpected.feedUrl);
+          break;
+        case "children":
+          let folder = aNode.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+          do_check_eq(folder.hasChildren, aExpected.children.length > 0);
+          folder.containerOpen = true;
+          do_check_eq(folder.childCount, aExpected.children.length);
+
+          for (let index = 0; index < aExpected.children.length; index++) {
+            yield checkItem(aExpected.children[index], folder.getChild(index));
+          }
+
+          folder.containerOpen = false;
+          break;
+        default:
+          throw new Error("Unknown property");
+      }
+    }
+  });
+}
diff --git a/toolkit/components/places/tests/unit/test_bookmarks_html_corrupt.js b/toolkit/components/places/tests/unit/test_bookmarks_html_corrupt.js
new file mode 100644
index 000000000..845b2227b
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bookmarks_html_corrupt.js
@@ -0,0 +1,143 @@
+/*
+ * This test ensures that importing/exporting to HTML does not stop
+ * if a malformed uri is found.
+ */
+
+const DESCRIPTION_ANNO = "bookmarkProperties/description";
+const LOAD_IN_SIDEBAR_ANNO = "bookmarkProperties/loadInSidebar";
+
+const TEST_FAVICON_PAGE_URL = "http://en-US.www.mozilla.com/en-US/firefox/central/";
+const TEST_FAVICON_DATA_SIZE = 580;
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_corrupt_file() {
+  // avoid creating the places smart folder during tests
+  Services.prefs.setIntPref("browser.places.smartBookmarksVersion", -1);
+
+  // Import bookmarks from the corrupt file.
+  let corruptHtml = OS.Path.join(do_get_cwd().path, "bookmarks.corrupt.html");
+  yield BookmarkHTMLUtils.importFromFile(corruptHtml, true);
+
+  // Check that bookmarks that are not corrupt have been imported.
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield database_check();
+});
+
+add_task(function* test_corrupt_database() {
+  // Create corruption in the database, then export.
+  let corruptBookmark = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+                                                             url: "http://test.mozilla.org",
+                                                             title: "We love belugas" });
+  yield PlacesUtils.withConnectionWrapper("test", Task.async(function*(db) {
+    yield db.execute("UPDATE moz_bookmarks SET fk = NULL WHERE guid = :guid",
+                     { guid: corruptBookmark.guid });
+  }));
+
+  let bookmarksFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.exported.html");
+  if ((yield OS.File.exists(bookmarksFile)))
+    yield OS.File.remove(bookmarksFile);
+  yield BookmarkHTMLUtils.exportToFile(bookmarksFile);
+
+  // Import again and check for correctness.
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield BookmarkHTMLUtils.importFromFile(bookmarksFile, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield database_check();
+});
+
+/*
+ * Check for imported bookmarks correctness
+ *
+ * @return {Promise}
+ * @resolves When the checks are finished.
+ * @rejects Never.
+ */
+var database_check = Task.async(function* () {
+  // BOOKMARKS MENU
+  let root = PlacesUtils.getFolderContents(PlacesUtils.bookmarksMenuFolderId).root;
+  Assert.equal(root.childCount, 2);
+
+  let folderNode = root.getChild(1);
+  Assert.equal(folderNode.type, folderNode.RESULT_TYPE_FOLDER);
+  Assert.equal(folderNode.title, "test");
+  Assert.equal(PlacesUtils.bookmarks.getItemDateAdded(folderNode.itemId), 1177541020000000);
+  Assert.equal(PlacesUtils.bookmarks.getItemLastModified(folderNode.itemId), 1177541050000000);
+  Assert.equal("folder test comment",
+               PlacesUtils.annotations.getItemAnnotation(folderNode.itemId,
+                                                         DESCRIPTION_ANNO));
+  // open test folder, and test the children
+  PlacesUtils.asQuery(folderNode);
+  Assert.equal(folderNode.hasChildren, true);
+  folderNode.containerOpen = true;
+  Assert.equal(folderNode.childCount, 1);
+
+  let bookmarkNode = folderNode.getChild(0);
+  Assert.equal("http://test/post", bookmarkNode.uri);
+  Assert.equal("test post keyword", bookmarkNode.title);
+
+  let entry = yield PlacesUtils.keywords.fetch({ url: bookmarkNode.uri });
+  Assert.equal("test", entry.keyword);
+  Assert.equal("hidden1%3Dbar&text1%3D%25s", entry.postData);
+
+  Assert.ok(PlacesUtils.annotations.itemHasAnnotation(bookmarkNode.itemId,
+                                                      LOAD_IN_SIDEBAR_ANNO));
+  Assert.equal(bookmarkNode.dateAdded, 1177375336000000);
+  Assert.equal(bookmarkNode.lastModified, 1177375423000000);
+
+  Assert.equal((yield PlacesUtils.getCharsetForURI(NetUtil.newURI(bookmarkNode.uri))),
+               "ISO-8859-1");
+
+  Assert.equal("item description",
+               PlacesUtils.annotations.getItemAnnotation(bookmarkNode.itemId,
+                                                         DESCRIPTION_ANNO));
+
+  // clean up
+  folderNode.containerOpen = false;
+  root.containerOpen = false;
+
+  // BOOKMARKS TOOLBAR
+  root = PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId).root;
+  Assert.equal(root.childCount, 3);
+
+  // For now some promises are resolved later, so we can't guarantee an order.
+  let foundLivemark = false;
+  for (let i = 0; i < root.childCount; ++i) {
+    let node = root.getChild(i);
+    if (node.title == "Latest Headlines") {
+      foundLivemark = true;
+      Assert.equal("Latest Headlines", node.title);
+
+      let livemark = yield PlacesUtils.livemarks.getLivemark({ guid: node.bookmarkGuid });
+      Assert.equal("http://en-us.fxfeeds.mozilla.com/en-US/firefox/livebookmarks/",
+                   livemark.siteURI.spec);
+      Assert.equal("http://en-us.fxfeeds.mozilla.com/en-US/firefox/headlines.xml",
+                   livemark.feedURI.spec);
+    }
+  }
+  Assert.ok(foundLivemark);
+
+  // cleanup
+  root.containerOpen = false;
+
+  // UNFILED BOOKMARKS
+  root = PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+  Assert.equal(root.childCount, 1);
+  root.containerOpen = false;
+
+  // favicons
+  yield new Promise(resolve => {
+    PlacesUtils.favicons.getFaviconDataForPage(uri(TEST_FAVICON_PAGE_URL),
+      (aURI, aDataLen, aData, aMimeType) => {
+        // aURI should never be null when aDataLen > 0.
+        Assert.notEqual(aURI, null);
+        // Favicon data is stored in the bookmarks file as a "data:" URI.  For
+        // simplicity, instead of converting the data we receive to a "data:" URI
+        // and comparing it, we just check the data size.
+        Assert.equal(TEST_FAVICON_DATA_SIZE, aDataLen);
+        resolve();
+      });
+  });
+});
diff --git a/toolkit/components/places/tests/unit/test_bookmarks_html_import_tags.js b/toolkit/components/places/tests/unit/test_bookmarks_html_import_tags.js
new file mode 100644
index 000000000..e4ba433a3
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bookmarks_html_import_tags.js
@@ -0,0 +1,57 @@
+var bookmarkData = [
+  { uri: uri("http://www.toastytech.com"),
+    title: "Nathan's Toasty Technology Page",
+    tags: ["technology", "personal", "retro"] },
+  { uri: uri("http://www.reddit.com"),
+    title: "reddit: the front page of the internet",
+    tags: ["social media", "news", "humour"] },
+  { uri: uri("http://www.4chan.org"),
+    title: "4chan",
+    tags: ["discussion", "imageboard", "anime"] }
+];
+
+/*
+  TEST SUMMARY
+  - Add bookmarks with tags
+  - Export tagged bookmarks as HTML file
+  - Delete bookmarks
+  - Import bookmarks from HTML file
+  - Check that all bookmarks are successfully imported with tags
+*/
+
+add_task(function* test_import_tags() {
+  // Removes bookmarks.html if the file already exists.
+  let HTMLFile = OS.Path.join(OS.Constants.Path.profileDir, "bookmarks.html");
+  if ((yield OS.File.exists(HTMLFile)))
+    yield OS.File.remove(HTMLFile);
+
+  // Adds bookmarks and tags to the database.
+  let bookmarkList = new Set();
+  for (let { uri, title, tags } of bookmarkData) {
+    bookmarkList.add(yield PlacesUtils.bookmarks.insert({
+                                parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+                                url: uri,
+                                title }));
+    PlacesUtils.tagging.tagURI(uri, tags);
+  }
+
+  // Exports the bookmarks as a HTML file.
+  yield BookmarkHTMLUtils.exportToFile(HTMLFile);
+
+  // Deletes bookmarks and tags from the database.
+  for (let bookmark of bookmarkList) {
+    yield PlacesUtils.bookmarks.remove(bookmark.guid);
+  }
+
+  // Re-imports the bookmarks from the HTML file.
+  yield BookmarkHTMLUtils.importFromFile(HTMLFile, true);
+
+  // Tests to ensure that the tags are still present for each bookmark URI.
+  for (let { uri, tags } of bookmarkData) {
+    do_print("Test tags for " + uri.spec + ": " + tags + "\n");
+    let foundTags = PlacesUtils.tagging.getTagsForURI(uri);
+    Assert.equal(foundTags.length, tags.length);
+    Assert.ok(tags.every(tag => foundTags.includes(tag)));
+  }
+});
+
diff --git a/toolkit/components/places/tests/unit/test_bookmarks_html_singleframe.js b/toolkit/components/places/tests/unit/test_bookmarks_html_singleframe.js
new file mode 100644
index 000000000..02b430ff2
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bookmarks_html_singleframe.js
@@ -0,0 +1,32 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Test for bug #801450
+
+// Get Services
+Cu.import("resource://gre/modules/BookmarkHTMLUtils.jsm");
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_bookmarks_html_singleframe()
+{
+  let bookmarksFile = OS.Path.join(do_get_cwd().path, "bookmarks_html_singleframe.html");
+  yield BookmarkHTMLUtils.importFromFile(bookmarksFile, true);
+
+  let root = PlacesUtils.getFolderContents(PlacesUtils.bookmarksMenuFolderId).root;
+  do_check_eq(root.childCount, 1);
+  let folder = root.getChild(0);
+  PlacesUtils.asContainer(folder).containerOpen = true;
+  do_check_eq(folder.title, "Subtitle");
+  do_check_eq(folder.childCount, 1);
+  let bookmark = folder.getChild(0);
+  do_check_eq(bookmark.uri, "http://www.mozilla.org/");
+  do_check_eq(bookmark.title, "Mozilla");
+  folder.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_bookmarks_json.js b/toolkit/components/places/tests/unit/test_bookmarks_json.js
new file mode 100644
index 000000000..a6801540a
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bookmarks_json.js
@@ -0,0 +1,241 @@
+/* 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/. */
+
+Cu.import("resource://gre/modules/BookmarkJSONUtils.jsm");
+
+function run_test() {
+  run_next_test();
+}
+
+const LOAD_IN_SIDEBAR_ANNO = "bookmarkProperties/loadInSidebar";
+const DESCRIPTION_ANNO = "bookmarkProperties/description";
+
+// An object representing the contents of bookmarks.json.
+var test_bookmarks = {
+  menu: [
+    { guid: "OCyeUO5uu9FF",
+      title: "Mozilla Firefox",
+      children: [
+        { guid:"OCyeUO5uu9FG",
+          title: "Help and Tutorials",
+          url: "http://en-us.www.mozilla.com/en-US/firefox/help/",
+          icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+        },
+        { guid:"OCyeUO5uu9FH",
+          title: "Customize Firefox",
+          url: "http://en-us.www.mozilla.com/en-US/firefox/customize/",
+          icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+        },
+        { guid:"OCyeUO5uu9FI",
+          title: "Get Involved",
+          url: "http://en-us.www.mozilla.com/en-US/firefox/community/",
+          icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+        },
+        { guid:"OCyeUO5uu9FJ",
+          title: "About Us",
+          url: "http://en-us.www.mozilla.com/en-US/about/",
+          icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+        }
+      ]
+    },
+    {
+      guid: "OCyeUO5uu9FK",
+      type: Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR
+    },
+    {
+      guid:"OCyeUO5uu9FL",
+      title: "test",
+      description: "folder test comment",
+      dateAdded: 1177541020000000,
+      // lastModified: 1177541050000000,
+      children: [
+        { guid:"OCyeUO5uu9GX",
+          title: "test post keyword",
+          description: "item description",
+          dateAdded: 1177375336000000,
+          // lastModified: 1177375423000000,
+          keyword: "test",
+          sidebar: true,
+          postData: "hidden1%3Dbar&text1%3D%25s",
+          charset: "ISO-8859-1"
+        }
+      ]
+    }
+  ],
+  toolbar: [
+    { guid: "OCyeUO5uu9FB",
+      title: "Getting Started",
+      url: "http://en-us.www.mozilla.com/en-US/firefox/central/",
+      icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="
+    },
+    { guid:"OCyeUO5uu9FR",
+      title: "Latest Headlines",
+      url: "http://en-us.fxfeeds.mozilla.com/en-US/firefox/livebookmarks/",
+      feedUrl: "http://en-us.fxfeeds.mozilla.com/en-US/firefox/headlines.xml"
+    }
+  ],
+  unfiled: [
+    { guid: "OCyeUO5uu9FW",
+      title: "Example.tld",
+      url: "http://example.tld/"
+    }
+  ]
+};
+
+// Exported bookmarks file pointer.
+var bookmarksExportedFile;
+
+add_task(function* test_import_bookmarks() {
+  let bookmarksFile = OS.Path.join(do_get_cwd().path, "bookmarks.json");
+
+  yield BookmarkJSONUtils.importFromFile(bookmarksFile, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield testImportedBookmarks();
+});
+
+add_task(function* test_export_bookmarks() {
+  bookmarksExportedFile = OS.Path.join(OS.Constants.Path.profileDir,
+                                       "bookmarks.exported.json");
+  yield BookmarkJSONUtils.exportToFile(bookmarksExportedFile);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+});
+
+add_task(function* test_import_exported_bookmarks() {
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield BookmarkJSONUtils.importFromFile(bookmarksExportedFile, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield testImportedBookmarks();
+});
+
+add_task(function* test_import_ontop() {
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield BookmarkJSONUtils.importFromFile(bookmarksExportedFile, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield BookmarkJSONUtils.exportToFile(bookmarksExportedFile);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield BookmarkJSONUtils.importFromFile(bookmarksExportedFile, true);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  yield testImportedBookmarks();
+});
+
+add_task(function* test_clean() {
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+function* testImportedBookmarks() {
+  for (let group in test_bookmarks) {
+    do_print("[testImportedBookmarks()] Checking group '" + group + "'");
+
+    let root;
+    switch (group) {
+      case "menu":
+        root =
+          PlacesUtils.getFolderContents(PlacesUtils.bookmarksMenuFolderId).root;
+        break;
+      case "toolbar":
+        root =
+          PlacesUtils.getFolderContents(PlacesUtils.toolbarFolderId).root;
+        break;
+      case "unfiled":
+        root =
+          PlacesUtils.getFolderContents(PlacesUtils.unfiledBookmarksFolderId).root;
+        break;
+    }
+
+    let items = test_bookmarks[group];
+    do_check_eq(root.childCount, items.length);
+
+    for (let key in items) {
+      yield checkItem(items[key], root.getChild(key));
+    }
+
+    root.containerOpen = false;
+  }
+}
+
+function* checkItem(aExpected, aNode) {
+  let id = aNode.itemId;
+
+  return Task.spawn(function* () {
+    for (prop in aExpected) {
+      switch (prop) {
+        case "type":
+          do_check_eq(aNode.type, aExpected.type);
+          break;
+        case "title":
+          do_check_eq(aNode.title, aExpected.title);
+          break;
+        case "description":
+          do_check_eq(PlacesUtils.annotations.getItemAnnotation(
+                      id, DESCRIPTION_ANNO), aExpected.description);
+          break;
+        case "dateAdded":
+          do_check_eq(PlacesUtils.bookmarks.getItemDateAdded(id),
+                      aExpected.dateAdded);
+          break;
+        case "lastModified":
+          do_check_eq(PlacesUtils.bookmarks.getItemLastModified(id),
+                      aExpected.lastModified);
+          break;
+        case "url":
+          if (!("feedUrl" in aExpected))
+            do_check_eq(aNode.uri, aExpected.url);
+          break;
+        case "icon":
+          let deferred = Promise.defer();
+          PlacesUtils.favicons.getFaviconDataForPage(
+            NetUtil.newURI(aExpected.url),
+            function (aURI, aDataLen, aData, aMimeType) {
+              deferred.resolve(aData);
+            });
+          let data = yield deferred.promise;
+          let base64Icon = "data:image/png;base64," +
+                           base64EncodeString(String.fromCharCode.apply(String, data));
+          do_check_true(base64Icon == aExpected.icon);
+          break;
+        case "keyword": {
+          let entry = yield PlacesUtils.keywords.fetch({ url: aNode.uri });
+          Assert.equal(entry.keyword, aExpected.keyword);
+          break;
+        }
+        case "guid":
+          let guid = yield PlacesUtils.promiseItemGuid(id);
+          do_check_eq(guid, aExpected.guid);
+          break;
+        case "sidebar":
+          do_check_eq(PlacesUtils.annotations.itemHasAnnotation(
+                      id, LOAD_IN_SIDEBAR_ANNO), aExpected.sidebar);
+          break;
+        case "postData": {
+          let entry = yield PlacesUtils.keywords.fetch({ url: aNode.uri });
+          Assert.equal(entry.postData, aExpected.postData);
+          break;
+        }
+        case "charset":
+          let testURI = NetUtil.newURI(aNode.uri);
+          do_check_eq((yield PlacesUtils.getCharsetForURI(testURI)), aExpected.charset);
+          break;
+        case "feedUrl":
+          let livemark = yield PlacesUtils.livemarks.getLivemark({ id: id });
+          do_check_eq(livemark.siteURI.spec, aExpected.url);
+          do_check_eq(livemark.feedURI.spec, aExpected.feedUrl);
+          break;
+        case "children":
+          let folder = aNode.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+          do_check_eq(folder.hasChildren, aExpected.children.length > 0);
+          folder.containerOpen = true;
+          do_check_eq(folder.childCount, aExpected.children.length);
+
+          for (let index = 0; index < aExpected.children.length; index++) {
+            yield checkItem(aExpected.children[index], folder.getChild(index));
+          }
+
+          folder.containerOpen = false;
+          break;
+        default:
+          throw new Error("Unknown property");
+      }
+    }
+  });
+}
diff --git a/toolkit/components/places/tests/unit/test_bookmarks_restore_notification.js b/toolkit/components/places/tests/unit/test_bookmarks_restore_notification.js
new file mode 100644
index 000000000..2f8022c6b
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bookmarks_restore_notification.js
@@ -0,0 +1,325 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+Cu.import("resource://gre/modules/BookmarkHTMLUtils.jsm");
+
+/**
+ * Tests the bookmarks-restore-* nsIObserver notifications after restoring
+ * bookmarks from JSON and HTML.  See bug 470314.
+ */
+
+// The topics and data passed to nsIObserver.observe() on bookmarks restore
+const NSIOBSERVER_TOPIC_BEGIN    = "bookmarks-restore-begin";
+const NSIOBSERVER_TOPIC_SUCCESS  = "bookmarks-restore-success";
+const NSIOBSERVER_TOPIC_FAILED   = "bookmarks-restore-failed";
+const NSIOBSERVER_DATA_JSON      = "json";
+const NSIOBSERVER_DATA_HTML      = "html";
+const NSIOBSERVER_DATA_HTML_INIT = "html-initial";
+
+// Bookmarks are added for these URIs
+var uris = [
+  "http://example.com/1",
+  "http://example.com/2",
+  "http://example.com/3",
+  "http://example.com/4",
+  "http://example.com/5",
+];
+
+/**
+ * Adds some bookmarks for the URIs in |uris|.
+ */
+function* addBookmarks() {
+  for (let url of uris) {
+    yield PlacesUtils.bookmarks.insert({
+      url: url, parentGuid: PlacesUtils.bookmarks.menuGuid
+    })
+  }
+  checkBookmarksExist();
+}
+
+/**
+ * Checks that all of the bookmarks created for |uris| exist.  It works by
+ * creating one query per URI and then ORing all the queries.  The number of
+ * results returned should be uris.length.
+ */
+function checkBookmarksExist() {
+  let hs = PlacesUtils.history;
+  let queries = uris.map(function (u) {
+    let q = hs.getNewQuery();
+    q.uri = uri(u);
+    return q;
+  });
+  let options = hs.getNewQueryOptions();
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  let root = hs.executeQueries(queries, uris.length, options).root;
+  root.containerOpen = true;
+  Assert.equal(root.childCount, uris.length);
+  root.containerOpen = false;
+}
+
+/**
+ * Creates an file in the profile directory.
+ *
+ * @param  aBasename
+ *         e.g., "foo.txt" in the path /some/long/path/foo.txt
+ * @return {Promise}
+ * @resolves to an OS.File path
+ */
+function promiseFile(aBasename) {
+  let path = OS.Path.join(OS.Constants.Path.profileDir, aBasename);
+  do_print("opening " + path);
+  return OS.File.open(path, { truncate: true })
+                .then(aFile => {
+                  aFile.close();
+                  return path;
+                });
+}
+
+/**
+ * Register observers via promiseTopicObserved helper.
+ *
+ * @param  {boolean} expectSuccess pass true when expect a success notification
+ * @return {Promise[]}
+ */
+function registerObservers(expectSuccess) {
+  let promiseBegin = promiseTopicObserved(NSIOBSERVER_TOPIC_BEGIN);
+  let promiseResult;
+  if (expectSuccess) {
+    promiseResult = promiseTopicObserved(NSIOBSERVER_TOPIC_SUCCESS);
+  } else {
+    promiseResult = promiseTopicObserved(NSIOBSERVER_TOPIC_FAILED);
+  }
+
+  return [promiseBegin, promiseResult];
+}
+
+/**
+ * Check notification results.
+ *
+ * @param  {Promise[]} expectPromises array contain promiseBegin and promiseResult
+ * @param  {object} expectedData contain data and folderId
+ */
+function* checkObservers(expectPromises, expectedData) {
+  let [promiseBegin, promiseResult] = expectPromises;
+
+  let beginData = (yield promiseBegin)[1];
+  Assert.equal(beginData, expectedData.data,
+    "Data for current test should be what is expected");
+
+  let [resultSubject, resultData] = yield promiseResult;
+  Assert.equal(resultData, expectedData.data,
+    "Data for current test should be what is expected");
+
+  // Make sure folder ID is what is expected.  For importing HTML into a
+  // folder, this will be an integer, otherwise null.
+  if (resultSubject) {
+    Assert.equal(aSubject.QueryInterface(Ci.nsISupportsPRInt64).data,
+                expectedData.folderId);
+  } else {
+    Assert.equal(expectedData.folderId, null);
+  }
+}
+
+/**
+ * Run after every test cases.
+ */
+function* teardown(file, begin, success, fail) {
+  // On restore failed, file may not exist, so wrap in try-catch.
+  try {
+    yield OS.File.remove(file, {ignoreAbsent: true});
+  } catch (e) {}
+
+  // clean up bookmarks
+  yield PlacesUtils.bookmarks.eraseEverything();
+}
+
+add_task(function* test_json_restore_normal() {
+  // data: the data passed to nsIObserver.observe() corresponding to the test
+  // folderId: for HTML restore into a folder, the folder ID to restore into;
+  //           otherwise, set it to null
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_JSON,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(true);
+
+  do_print("JSON restore: normal restore should succeed");
+  let file = yield promiseFile("bookmarks-test_restoreNotification.json");
+  yield addBookmarks();
+
+  yield BookmarkJSONUtils.exportToFile(file);
+  yield PlacesUtils.bookmarks.eraseEverything();
+  try {
+    yield BookmarkJSONUtils.importFromFile(file, true);
+  } catch (e) {
+    do_throw("  Restore should not have failed" + e);
+  }
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
+
+add_task(function* test_json_restore_empty() {
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_JSON,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(true);
+
+  do_print("JSON restore: empty file should succeed");
+  let file = yield promiseFile("bookmarks-test_restoreNotification.json");
+  try {
+    yield BookmarkJSONUtils.importFromFile(file, true);
+  } catch (e) {
+    do_throw("  Restore should not have failed" + e);
+  }
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
+
+add_task(function* test_json_restore_nonexist() {
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_JSON,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(false);
+
+  do_print("JSON restore: nonexistent file should fail");
+  let file = Services.dirsvc.get("ProfD", Ci.nsILocalFile);
+  file.append("this file doesn't exist because nobody created it 1");
+  try {
+    yield BookmarkJSONUtils.importFromFile(file, true);
+    do_throw("  Restore should have failed");
+  } catch (e) {}
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
+
+add_task(function* test_html_restore_normal() {
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_HTML,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(true);
+
+  do_print("HTML restore: normal restore should succeed");
+  let file = yield promiseFile("bookmarks-test_restoreNotification.html");
+  yield addBookmarks();
+  yield BookmarkHTMLUtils.exportToFile(file);
+  yield PlacesUtils.bookmarks.eraseEverything();
+  try {
+    BookmarkHTMLUtils.importFromFile(file, false)
+                     .then(null, do_report_unexpected_exception);
+  } catch (e) {
+    do_throw("  Restore should not have failed");
+  }
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
+
+add_task(function* test_html_restore_empty() {
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_HTML,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(true);
+
+  do_print("HTML restore: empty file should succeed");
+  let file = yield promiseFile("bookmarks-test_restoreNotification.init.html");
+  try {
+    BookmarkHTMLUtils.importFromFile(file, false)
+                     .then(null, do_report_unexpected_exception);
+  } catch (e) {
+    do_throw("  Restore should not have failed");
+  }
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
+
+add_task(function* test_html_restore_nonexist() {
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_HTML,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(false);
+
+  do_print("HTML restore: nonexistent file should fail");
+  let file = Services.dirsvc.get("ProfD", Ci.nsILocalFile);
+  file.append("this file doesn't exist because nobody created it 2");
+  try {
+    yield BookmarkHTMLUtils.importFromFile(file, false);
+    do_throw("Should fail!");
+  } catch (e) {}
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
+
+add_task(function* test_html_init_restore_normal() {
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_HTML_INIT,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(true);
+
+  do_print("HTML initial restore: normal restore should succeed");
+  let file = yield promiseFile("bookmarks-test_restoreNotification.init.html");
+  yield addBookmarks();
+  yield BookmarkHTMLUtils.exportToFile(file);
+  yield PlacesUtils.bookmarks.eraseEverything();
+  try {
+    BookmarkHTMLUtils.importFromFile(file, true)
+                     .then(null, do_report_unexpected_exception);
+  } catch (e) {
+    do_throw("  Restore should not have failed");
+  }
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
+
+add_task(function* test_html_init_restore_empty() {
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_HTML_INIT,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(true);
+
+  do_print("HTML initial restore: empty file should succeed");
+  let file = yield promiseFile("bookmarks-test_restoreNotification.init.html");
+  try {
+    BookmarkHTMLUtils.importFromFile(file, true)
+                     .then(null, do_report_unexpected_exception);
+  } catch (e) {
+    do_throw("  Restore should not have failed");
+  }
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
+
+add_task(function* test_html_init_restore_nonexist() {
+  let expectedData = {
+    data:       NSIOBSERVER_DATA_HTML_INIT,
+    folderId:   null
+  }
+  let expectPromises = registerObservers(false);
+
+  do_print("HTML initial restore: nonexistent file should fail");
+  let file = Services.dirsvc.get("ProfD", Ci.nsILocalFile);
+  file.append("this file doesn't exist because nobody created it 3");
+  try {
+    yield BookmarkHTMLUtils.importFromFile(file, true);
+    do_throw("Should fail!");
+  } catch (e) {}
+
+  yield checkObservers(expectPromises, expectedData);
+  yield teardown(file);
+});
diff --git a/toolkit/components/places/tests/unit/test_bookmarks_setNullTitle.js b/toolkit/components/places/tests/unit/test_bookmarks_setNullTitle.js
new file mode 100644
index 000000000..959dfe85f
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bookmarks_setNullTitle.js
@@ -0,0 +1,44 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Both SetItemtitle and insertBookmark should allow for null titles.
+ */
+
+const bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+           getService(Ci.nsINavBookmarksService);
+
+const TEST_URL = "http://www.mozilla.org";
+
+function run_test() {
+  // Insert a bookmark with an empty title.
+  var itemId = bs.insertBookmark(bs.toolbarFolder,
+                                 uri(TEST_URL),
+                                 bs.DEFAULT_INDEX,
+                                 "");
+  // Check returned title is an empty string.
+  do_check_eq(bs.getItemTitle(itemId), "");
+  // Set title to null.
+  bs.setItemTitle(itemId, null);
+  // Check returned title is null.
+  do_check_eq(bs.getItemTitle(itemId), null);
+  // Cleanup.
+  bs.removeItem(itemId);
+
+  // Insert a bookmark with a null title.
+  itemId = bs.insertBookmark(bs.toolbarFolder,
+                             uri(TEST_URL),
+                             bs.DEFAULT_INDEX,
+                             null);
+  // Check returned title is null.
+  do_check_eq(bs.getItemTitle(itemId), null);
+  // Set title to an empty string.
+  bs.setItemTitle(itemId, "");
+  // Check returned title is an empty string.
+  do_check_eq(bs.getItemTitle(itemId), "");
+  // Cleanup.
+  bs.removeItem(itemId);
+}
diff --git a/toolkit/components/places/tests/unit/test_broken_folderShortcut_result.js b/toolkit/components/places/tests/unit/test_broken_folderShortcut_result.js
new file mode 100644
index 000000000..b67e141e6
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_broken_folderShortcut_result.js
@@ -0,0 +1,79 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  PlacesUtils.bookmarks.insertBookmark(
+    PlacesUtils.unfiledBookmarksFolderId, NetUtil.newURI("http://1.moz.org/"),
+    PlacesUtils.bookmarks.DEFAULT_INDEX, "Bookmark 1"
+  );
+  let id1 = PlacesUtils.bookmarks.insertBookmark(
+    PlacesUtils.unfiledBookmarksFolderId, NetUtil.newURI("place:folder=1234"),
+    PlacesUtils.bookmarks.DEFAULT_INDEX, "Shortcut 1"
+  );
+  let id2 = PlacesUtils.bookmarks.insertBookmark(
+    PlacesUtils.unfiledBookmarksFolderId, NetUtil.newURI("place:folder=-1"),
+    PlacesUtils.bookmarks.DEFAULT_INDEX, "Shortcut 2"
+  );
+  PlacesUtils.bookmarks.insertBookmark(
+    PlacesUtils.unfiledBookmarksFolderId, NetUtil.newURI("http://2.moz.org/"),
+    PlacesUtils.bookmarks.DEFAULT_INDEX, "Bookmark 2"
+  );
+
+  // Add also a simple visit.
+  yield PlacesTestUtils.addVisits(uri(("http://3.moz.org/")));
+
+  // Query containing a broken folder shortcuts among results.
+  let query = PlacesUtils.history.getNewQuery();
+  query.setFolders([PlacesUtils.unfiledBookmarksFolderId], 1);
+  let options = PlacesUtils.history.getNewQueryOptions();
+  let root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  do_check_eq(root.childCount, 4);
+
+  let shortcut = root.getChild(1);
+  do_check_eq(shortcut.uri, "place:folder=1234");
+  PlacesUtils.asContainer(shortcut);
+  shortcut.containerOpen = true;
+  do_check_eq(shortcut.childCount, 0);
+  shortcut.containerOpen = false;
+  // Remove the broken shortcut while the containing result is open.
+  PlacesUtils.bookmarks.removeItem(id1);
+  do_check_eq(root.childCount, 3);
+
+  shortcut = root.getChild(1);
+  do_check_eq(shortcut.uri, "place:folder=-1");
+  PlacesUtils.asContainer(shortcut);
+  shortcut.containerOpen = true;
+  do_check_eq(shortcut.childCount, 0);
+  shortcut.containerOpen = false;
+  // Remove the broken shortcut while the containing result is open.
+  PlacesUtils.bookmarks.removeItem(id2);
+  do_check_eq(root.childCount, 2);
+
+  root.containerOpen = false;
+
+  // Broken folder shortcut as root node.
+  query = PlacesUtils.history.getNewQuery();
+  query.setFolders([1234], 1);
+  options = PlacesUtils.history.getNewQueryOptions();
+  root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 0);
+  root.containerOpen = false;
+
+  // Broken folder shortcut as root node with folder=-1.
+  query = PlacesUtils.history.getNewQuery();
+  query.setFolders([-1], 1);
+  options = PlacesUtils.history.getNewQueryOptions();
+  root = PlacesUtils.history.executeQuery(query, options).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 0);
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_browserhistory.js b/toolkit/components/places/tests/unit/test_browserhistory.js
new file mode 100644
index 000000000..5f88c26e3
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_browserhistory.js
@@ -0,0 +1,129 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const TEST_URI = NetUtil.newURI("http://mozilla.com/");
+const TEST_SUBDOMAIN_URI = NetUtil.newURI("http://foobar.mozilla.com/");
+
+add_task(function* test_addPage() {
+  yield PlacesTestUtils.addVisits(TEST_URI);
+  do_check_eq(1, PlacesUtils.history.hasHistoryEntries);
+});
+
+add_task(function* test_removePage() {
+  PlacesUtils.bhistory.removePage(TEST_URI);
+  do_check_eq(0, PlacesUtils.history.hasHistoryEntries);
+});
+
+add_task(function* test_removePages() {
+  let pages = [];
+  for (let i = 0; i < 8; i++) {
+    pages.push(NetUtil.newURI(TEST_URI.spec + i));
+  }
+
+  yield PlacesTestUtils.addVisits(pages.map(uri => ({ uri: uri })));
+  // Bookmarked item should not be removed from moz_places.
+  const ANNO_INDEX = 1;
+  const ANNO_NAME = "testAnno";
+  const ANNO_VALUE = "foo";
+  const BOOKMARK_INDEX = 2;
+  PlacesUtils.annotations.setPageAnnotation(pages[ANNO_INDEX],
+                                            ANNO_NAME, ANNO_VALUE, 0,
+                                            Ci.nsIAnnotationService.EXPIRE_NEVER);
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       pages[BOOKMARK_INDEX],
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "test bookmark");
+  PlacesUtils.annotations.setPageAnnotation(pages[BOOKMARK_INDEX],
+                                            ANNO_NAME, ANNO_VALUE, 0,
+                                            Ci.nsIAnnotationService.EXPIRE_NEVER);
+
+  PlacesUtils.bhistory.removePages(pages, pages.length);
+  do_check_eq(0, PlacesUtils.history.hasHistoryEntries);
+
+  // Check that the bookmark and its annotation still exist.
+  do_check_true(PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId, 0) > 0);
+  do_check_eq(PlacesUtils.annotations.getPageAnnotation(pages[BOOKMARK_INDEX], ANNO_NAME),
+              ANNO_VALUE);
+
+  // Check the annotation on the non-bookmarked page does not exist anymore.
+  try {
+    PlacesUtils.annotations.getPageAnnotation(pages[ANNO_INDEX], ANNO_NAME);
+    do_throw("did not expire expire_never anno on a not bookmarked item");
+  } catch (ex) {}
+
+  // Cleanup.
+  PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.unfiledBookmarksFolderId);
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_removePagesByTimeframe() {
+  let visits = [];
+  let startDate = (Date.now() - 10000) * 1000;
+  for (let i = 0; i < 10; i++) {
+    visits.push({
+      uri: NetUtil.newURI(TEST_URI.spec + i),
+      visitDate: startDate + i * 1000
+    });
+  }
+
+  yield PlacesTestUtils.addVisits(visits);
+
+  // Delete all pages except the first and the last.
+  PlacesUtils.bhistory.removePagesByTimeframe(startDate + 1000, startDate + 8000);
+
+  // Check that we have removed the correct pages.
+  for (let i = 0; i < 10; i++) {
+    do_check_eq(page_in_database(NetUtil.newURI(TEST_URI.spec + i)) == 0,
+                i > 0 && i < 9);
+  }
+
+  // Clear remaining items and check that all pages have been removed.
+  PlacesUtils.bhistory.removePagesByTimeframe(startDate, startDate + 9000);
+  do_check_eq(0, PlacesUtils.history.hasHistoryEntries);
+});
+
+add_task(function* test_removePagesFromHost() {
+  yield PlacesTestUtils.addVisits(TEST_URI);
+  PlacesUtils.bhistory.removePagesFromHost("mozilla.com", true);
+  do_check_eq(0, PlacesUtils.history.hasHistoryEntries);
+});
+
+add_task(function* test_removePagesFromHost_keepSubdomains() {
+  yield PlacesTestUtils.addVisits([{ uri: TEST_URI }, { uri: TEST_SUBDOMAIN_URI }]);
+  PlacesUtils.bhistory.removePagesFromHost("mozilla.com", false);
+  do_check_eq(1, PlacesUtils.history.hasHistoryEntries);
+});
+
+add_task(function* test_history_clear() {
+  yield PlacesTestUtils.clearHistory();
+  do_check_eq(0, PlacesUtils.history.hasHistoryEntries);
+});
+
+add_task(function* test_getObservers() {
+  // Ensure that getObservers() invalidates the hasHistoryEntries cache.
+  yield PlacesTestUtils.addVisits(TEST_URI);
+  do_check_eq(1, PlacesUtils.history.hasHistoryEntries);
+  // This is just for testing purposes, never do it.
+  return new Promise((resolve, reject) => {
+    DBConn().executeSimpleSQLAsync("DELETE FROM moz_historyvisits", {
+      handleError: function(error) {
+        reject(error);
+      },
+      handleResult: function(result) {
+      },
+      handleCompletion: function(result) {
+        // Just invoking getObservers should be enough to invalidate the cache.
+        PlacesUtils.history.getObservers();
+        do_check_eq(0, PlacesUtils.history.hasHistoryEntries);
+        resolve();
+      }
+    });
+  });
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_bug636917_isLivemark.js b/toolkit/components/places/tests/unit/test_bug636917_isLivemark.js
new file mode 100644
index 000000000..a7ad1257a
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_bug636917_isLivemark.js
@@ -0,0 +1,35 @@
+// Test that asking for a livemark in a annotationChanged notification works.
+add_task(function* () {
+  let annoPromise = new Promise(resolve => {
+    let annoObserver = {
+      onItemAnnotationSet(id, name) {
+        if (name == PlacesUtils.LMANNO_FEEDURI) {
+          PlacesUtils.annotations.removeObserver(this);
+          resolve();
+        }
+      },
+      onItemAnnotationRemoved() {},
+      onPageAnnotationSet() {},
+      onPageAnnotationRemoved() {},
+      QueryInterface: XPCOMUtils.generateQI([
+        Ci.nsIAnnotationObserver
+      ]),
+    };
+    PlacesUtils.annotations.addObserver(annoObserver, false);
+  });
+
+
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "livemark title"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , index: PlacesUtils.bookmarks.DEFAULT_INDEX
+    , siteURI: uri("http://example.com/")
+    , feedURI: uri("http://example.com/rdf")
+    });
+
+  yield annoPromise;
+
+  livemark = yield PlacesUtils.livemarks.getLivemark({ guid: livemark.guid });
+  Assert.ok(livemark);
+  yield PlacesUtils.livemarks.removeLivemark({ guid: livemark.guid });
+});
diff --git a/toolkit/components/places/tests/unit/test_childlessTags.js b/toolkit/components/places/tests/unit/test_childlessTags.js
new file mode 100644
index 000000000..4c3e38fa4
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_childlessTags.js
@@ -0,0 +1,117 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Ensures that removal of a bookmark untags the bookmark if it's no longer
+ * contained in any regular, non-tag folders.  See bug 444849.
+ */
+
+// Add your tests here.  Each is an object with a summary string |desc| and a
+// method run() that's called to run the test.
+var tests = [
+  {
+    desc: "Removing a tagged bookmark should cause the tag to be removed.",
+    run:   function () {
+      print("  Make a bookmark.");
+      var bmId = bmsvc.insertBookmark(bmsvc.unfiledBookmarksFolder,
+                                      BOOKMARK_URI,
+                                      bmsvc.DEFAULT_INDEX,
+                                      "test bookmark");
+      do_check_true(bmId > 0);
+
+      print("  Tag it up.");
+      var tags = ["foo", "bar"];
+      tagssvc.tagURI(BOOKMARK_URI, tags);
+      ensureTagsExist(tags);
+
+      print("  Remove the bookmark.  The tags should no longer exist.");
+      bmsvc.removeItem(bmId);
+      ensureTagsExist([]);
+    }
+  },
+
+  {
+    desc: "Removing a folder containing a tagged bookmark should cause the " +
+          "tag to be removed.",
+    run:   function () {
+      print("  Make a folder.");
+      var folderId = bmsvc.createFolder(bmsvc.unfiledBookmarksFolder,
+                                        "test folder",
+                                        bmsvc.DEFAULT_INDEX);
+      do_check_true(folderId > 0);
+
+      print("  Stick a bookmark in the folder.");
+      var bmId = bmsvc.insertBookmark(folderId,
+                                      BOOKMARK_URI,
+                                      bmsvc.DEFAULT_INDEX,
+                                      "test bookmark");
+      do_check_true(bmId > 0);
+
+      print("  Tag the bookmark.");
+      var tags = ["foo", "bar"];
+      tagssvc.tagURI(BOOKMARK_URI, tags);
+      ensureTagsExist(tags);
+
+      print("  Remove the folder.  The tags should no longer exist.");
+      bmsvc.removeItem(folderId);
+      ensureTagsExist([]);
+    }
+  }
+];
+
+var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+            getService(Ci.nsINavBookmarksService);
+
+var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+              getService(Ci.nsINavHistoryService);
+
+var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+              getService(Ci.nsITaggingService);
+
+const BOOKMARK_URI = uri("http://example.com/");
+
+/**
+ * Runs a tag query and ensures that the tags returned are those and only those
+ * in aTags.  aTags may be empty, in which case this function ensures that no
+ * tags exist.
+ *
+ * @param aTags
+ *        An array of tags (strings)
+ */
+function ensureTagsExist(aTags) {
+  var query = histsvc.getNewQuery();
+  var opts = histsvc.getNewQueryOptions();
+  opts.resultType = opts.RESULTS_AS_TAG_QUERY;
+  var resultRoot = histsvc.executeQuery(query, opts).root;
+
+  // Dupe aTags.
+  var tags = aTags.slice(0);
+
+  resultRoot.containerOpen = true;
+
+  // Ensure that the number of tags returned from the query is the same as the
+  // number in |tags|.
+  do_check_eq(resultRoot.childCount, tags.length);
+
+  // For each tag result from the query, ensure that it's contained in |tags|.
+  // Remove the tag from |tags| so that we ensure the sets are equal.
+  for (let i = 0; i < resultRoot.childCount; i++) {
+    var tag = resultRoot.getChild(i).title;
+    var indexOfTag = tags.indexOf(tag);
+    do_check_true(indexOfTag >= 0);
+    tags.splice(indexOfTag, 1);
+  }
+
+  resultRoot.containerOpen = false;
+}
+
+function run_test()
+{
+  tests.forEach(function (test) {
+    print("Running test: " + test.desc);
+    test.run();
+  });
+}
diff --git a/toolkit/components/places/tests/unit/test_corrupt_telemetry.js b/toolkit/components/places/tests/unit/test_corrupt_telemetry.js
new file mode 100644
index 000000000..cd9e9ec0c
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_corrupt_telemetry.js
@@ -0,0 +1,31 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Tests that history initialization correctly handles a request to forcibly
+// replace the current database.
+
+add_task(function* () {
+  let profileDBPath = yield OS.Path.join(OS.Constants.Path.profileDir, "places.sqlite");
+  yield OS.File.remove(profileDBPath, {ignoreAbsent: true});
+  // Ensure that our database doesn't already exist.
+  Assert.ok(!(yield OS.File.exists(profileDBPath)), "places.sqlite shouldn't exist");
+  let dir = yield OS.File.getCurrentDirectory();
+  let src = OS.Path.join(dir, "corruptDB.sqlite");
+  yield OS.File.copy(src, profileDBPath);
+  Assert.ok(yield OS.File.exists(profileDBPath), "places.sqlite should exist");
+
+  let count = Services.telemetry
+                      .getHistogramById("PLACES_DATABASE_CORRUPTION_HANDLING_STAGE")
+                      .snapshot()
+                      .counts[3];
+  Assert.equal(count, 0, "There should be no telemetry");
+
+  do_check_eq(PlacesUtils.history.databaseStatus,
+              PlacesUtils.history.DATABASE_STATUS_CORRUPT);
+
+  count = Services.telemetry
+                  .getHistogramById("PLACES_DATABASE_CORRUPTION_HANDLING_STAGE")
+                  .snapshot()
+                  .counts[3];
+  Assert.equal(count, 1, "Telemetry should have been added");
+});
diff --git a/toolkit/components/places/tests/unit/test_crash_476292.js b/toolkit/components/places/tests/unit/test_crash_476292.js
new file mode 100644
index 000000000..8f0862022
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_crash_476292.js
@@ -0,0 +1,28 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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 tests a crash during startup found in bug 476292 that was caused by
+ * getting the bookmarks service during nsNavHistory::Init when the bookmarks
+ * service was created before the history service was.
+ */
+
+function run_test()
+{
+  // First, we need to move our old database file into our test profile
+  // directory.  This will trigger DATABASE_STATUS_UPGRADED (CREATE is not
+  // sufficient since there will be no entries to update frecencies for, which
+  // causes us to get the bookmarks service in the first place).
+  let dbFile = do_get_file("bug476292.sqlite");
+  let profD = Cc["@mozilla.org/file/directory_service;1"].
+             getService(Ci.nsIProperties).
+             get(NS_APP_USER_PROFILE_50_DIR, Ci.nsIFile);
+  dbFile.copyTo(profD, "places.sqlite");
+
+  // Now get the bookmarks service.  This will crash when the bug exists.
+  Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+    getService(Ci.nsINavBookmarksService);
+}
diff --git a/toolkit/components/places/tests/unit/test_database_replaceOnStartup.js b/toolkit/components/places/tests/unit/test_database_replaceOnStartup.js
new file mode 100644
index 000000000..e83d0fdae
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_database_replaceOnStartup.js
@@ -0,0 +1,46 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Tests that history initialization correctly handles a request to forcibly
+// replace the current database.
+
+function run_test() {
+  // Ensure that our database doesn't already exist.
+  let dbFile = gProfD.clone();
+  dbFile.append("places.sqlite");
+  do_check_false(dbFile.exists());
+
+  dbFile = gProfD.clone();
+  dbFile.append("places.sqlite.corrupt");
+  do_check_false(dbFile.exists());
+
+  let file = do_get_file("default.sqlite");
+  file.copyToFollowingLinks(gProfD, "places.sqlite");
+  file = gProfD.clone();
+  file.append("places.sqlite");
+
+  // Create some unique stuff to check later.
+  let db = Services.storage.openUnsharedDatabase(file);
+  db.executeSimpleSQL("CREATE TABLE test (id INTEGER PRIMARY KEY)");
+  db.close();
+
+  Services.prefs.setBoolPref("places.database.replaceOnStartup", true);
+  do_check_eq(PlacesUtils.history.databaseStatus,
+              PlacesUtils.history.DATABASE_STATUS_CORRUPT);
+
+  dbFile = gProfD.clone();
+  dbFile.append("places.sqlite");
+  do_check_true(dbFile.exists());
+
+  // Check the new database is really a new one.
+  db = Services.storage.openUnsharedDatabase(file);
+  try {
+    db.executeSimpleSQL("DELETE * FROM test");
+    do_throw("The new database should not have our unique content");
+  } catch (ex) {}
+  db.close();
+
+  dbFile = gProfD.clone();
+  dbFile.append("places.sqlite.corrupt");
+  do_check_true(dbFile.exists());
+}
diff --git a/toolkit/components/places/tests/unit/test_download_history.js b/toolkit/components/places/tests/unit/test_download_history.js
new file mode 100644
index 000000000..643360b20
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_download_history.js
@@ -0,0 +1,283 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests the nsIDownloadHistory Places implementation.
+ */
+
+XPCOMUtils.defineLazyServiceGetter(this, "gDownloadHistory",
+                                   "@mozilla.org/browser/download-history;1",
+                                   "nsIDownloadHistory");
+
+const DOWNLOAD_URI = NetUtil.newURI("http://www.example.com/");
+const REFERRER_URI = NetUtil.newURI("http://www.example.org/");
+const PRIVATE_URI = NetUtil.newURI("http://www.example.net/");
+
+/**
+ * Waits for the first visit notification to be received.
+ *
+ * @param aCallback
+ *        Callback function to be called with the same arguments of onVisit.
+ */
+function waitForOnVisit(aCallback) {
+  let historyObserver = {
+    __proto__: NavHistoryObserver.prototype,
+    onVisit: function HO_onVisit() {
+      PlacesUtils.history.removeObserver(this);
+      aCallback.apply(null, arguments);
+    }
+  };
+  PlacesUtils.history.addObserver(historyObserver, false);
+}
+
+/**
+ * Waits for the first onDeleteURI notification to be received.
+ *
+ * @param aCallback
+ *        Callback function to be called with the same arguments of onDeleteURI.
+ */
+function waitForOnDeleteURI(aCallback) {
+  let historyObserver = {
+    __proto__: NavHistoryObserver.prototype,
+    onDeleteURI: function HO_onDeleteURI() {
+      PlacesUtils.history.removeObserver(this);
+      aCallback.apply(null, arguments);
+    }
+  };
+  PlacesUtils.history.addObserver(historyObserver, false);
+}
+
+/**
+ * Waits for the first onDeleteVisits notification to be received.
+ *
+ * @param aCallback
+ *        Callback function to be called with the same arguments of onDeleteVisits.
+ */
+function waitForOnDeleteVisits(aCallback) {
+  let historyObserver = {
+    __proto__: NavHistoryObserver.prototype,
+    onDeleteVisits: function HO_onDeleteVisits() {
+      PlacesUtils.history.removeObserver(this);
+      aCallback.apply(null, arguments);
+    }
+  };
+  PlacesUtils.history.addObserver(historyObserver, false);
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_test(function test_dh_is_from_places()
+{
+  // Test that this nsIDownloadHistory is the one places implements.
+  do_check_true(gDownloadHistory instanceof Ci.mozIAsyncHistory);
+
+  run_next_test();
+});
+
+add_test(function test_dh_addRemoveDownload()
+{
+  waitForOnVisit(function DHAD_onVisit(aURI) {
+    do_check_true(aURI.equals(DOWNLOAD_URI));
+
+    // Verify that the URI is already available in results at this time.
+    do_check_true(!!page_in_database(DOWNLOAD_URI));
+
+    waitForOnDeleteURI(function DHRAD_onDeleteURI(aDeletedURI) {
+      do_check_true(aDeletedURI.equals(DOWNLOAD_URI));
+
+      // Verify that the URI is already available in results at this time.
+      do_check_false(!!page_in_database(DOWNLOAD_URI));
+
+      run_next_test();
+    });
+    gDownloadHistory.removeAllDownloads();
+  });
+
+  gDownloadHistory.addDownload(DOWNLOAD_URI, null, Date.now() * 1000);
+});
+
+add_test(function test_dh_addMultiRemoveDownload()
+{
+  PlacesTestUtils.addVisits({
+    uri: DOWNLOAD_URI,
+    transition: TRANSITION_TYPED
+  }).then(function () {
+    waitForOnVisit(function DHAD_onVisit(aURI) {
+      do_check_true(aURI.equals(DOWNLOAD_URI));
+      do_check_true(!!page_in_database(DOWNLOAD_URI));
+
+      waitForOnDeleteVisits(function DHRAD_onDeleteVisits(aDeletedURI) {
+        do_check_true(aDeletedURI.equals(DOWNLOAD_URI));
+        do_check_true(!!page_in_database(DOWNLOAD_URI));
+
+        PlacesTestUtils.clearHistory().then(run_next_test);
+      });
+      gDownloadHistory.removeAllDownloads();
+    });
+
+    gDownloadHistory.addDownload(DOWNLOAD_URI, null, Date.now() * 1000);
+  });
+});
+
+add_test(function test_dh_addBookmarkRemoveDownload()
+{
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       DOWNLOAD_URI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "A bookmark");
+  waitForOnVisit(function DHAD_onVisit(aURI) {
+    do_check_true(aURI.equals(DOWNLOAD_URI));
+    do_check_true(!!page_in_database(DOWNLOAD_URI));
+
+    waitForOnDeleteVisits(function DHRAD_onDeleteVisits(aDeletedURI) {
+      do_check_true(aDeletedURI.equals(DOWNLOAD_URI));
+      do_check_true(!!page_in_database(DOWNLOAD_URI));
+
+      PlacesTestUtils.clearHistory().then(run_next_test);
+    });
+    gDownloadHistory.removeAllDownloads();
+  });
+
+  gDownloadHistory.addDownload(DOWNLOAD_URI, null, Date.now() * 1000);
+});
+
+add_test(function test_dh_addDownload_referrer()
+{
+  waitForOnVisit(function DHAD_prepareReferrer(aURI, aVisitID) {
+    do_check_true(aURI.equals(REFERRER_URI));
+    let referrerVisitId = aVisitID;
+
+    waitForOnVisit(function DHAD_onVisit(aVisitedURI, unused, unused2, unused3,
+                                         aReferringID) {
+      do_check_true(aVisitedURI.equals(DOWNLOAD_URI));
+      do_check_eq(aReferringID, referrerVisitId);
+
+      // Verify that the URI is already available in results at this time.
+      do_check_true(!!page_in_database(DOWNLOAD_URI));
+
+      PlacesTestUtils.clearHistory().then(run_next_test);
+    });
+
+    gDownloadHistory.addDownload(DOWNLOAD_URI, REFERRER_URI, Date.now() * 1000);
+  });
+
+  // Note that we don't pass the optional callback argument here because we must
+  // ensure that we receive the onVisit notification before we call addDownload.
+  PlacesUtils.asyncHistory.updatePlaces({
+    uri: REFERRER_URI,
+    visits: [{
+      transitionType: Ci.nsINavHistoryService.TRANSITION_TYPED,
+      visitDate: Date.now() * 1000
+    }]
+  });
+});
+
+add_test(function test_dh_addDownload_disabledHistory()
+{
+  waitForOnVisit(function DHAD_onVisit(aURI) {
+    // We should only receive the notification for the non-private URI.  This
+    // test is based on the assumption that visit notifications are received in
+    // the same order of the addDownload calls, which is currently true because
+    // database access is serialized on the same worker thread.
+    do_check_true(aURI.equals(DOWNLOAD_URI));
+
+    do_check_true(!!page_in_database(DOWNLOAD_URI));
+    do_check_false(!!page_in_database(PRIVATE_URI));
+
+    PlacesTestUtils.clearHistory().then(run_next_test);
+  });
+
+  Services.prefs.setBoolPref("places.history.enabled", false);
+  gDownloadHistory.addDownload(PRIVATE_URI, REFERRER_URI, Date.now() * 1000);
+
+  // The addDownload functions calls CanAddURI synchronously, thus we can set
+  // the preference back to true immediately (not all apps enable places by
+  // default).
+  Services.prefs.setBoolPref("places.history.enabled", true);
+  gDownloadHistory.addDownload(DOWNLOAD_URI, REFERRER_URI, Date.now() * 1000);
+});
+
+/**
+ * Tests that nsIDownloadHistory::AddDownload saves the additional download
+ * details if the optional destination URL is specified.
+ */
+add_test(function test_dh_details()
+{
+  const REMOTE_URI = NetUtil.newURI("http://localhost/");
+  const SOURCE_URI = NetUtil.newURI("http://example.com/test_dh_details");
+  const DEST_FILE_NAME = "dest.txt";
+
+  // We must build a real, valid file URI for the destination.
+  let destFileUri = NetUtil.newURI(FileUtils.getFile("TmpD", [DEST_FILE_NAME]));
+
+  let titleSet = false;
+  let destinationFileUriSet = false;
+  let destinationFileNameSet = false;
+
+  function checkFinished()
+  {
+    if (titleSet && destinationFileUriSet && destinationFileNameSet) {
+      PlacesUtils.annotations.removeObserver(annoObserver);
+      PlacesUtils.history.removeObserver(historyObserver);
+
+      PlacesTestUtils.clearHistory().then(run_next_test);
+    }
+  }
+
+  let annoObserver = {
+    onPageAnnotationSet: function AO_onPageAnnotationSet(aPage, aName)
+    {
+      if (aPage.equals(SOURCE_URI)) {
+        let value = PlacesUtils.annotations.getPageAnnotation(aPage, aName);
+        switch (aName)
+        {
+          case "downloads/destinationFileURI":
+            destinationFileUriSet = true;
+            do_check_eq(value, destFileUri.spec);
+            break;
+          case "downloads/destinationFileName":
+            destinationFileNameSet = true;
+            do_check_eq(value, DEST_FILE_NAME);
+            break;
+        }
+        checkFinished();
+      }
+    },
+    onItemAnnotationSet: function() {},
+    onPageAnnotationRemoved: function() {},
+    onItemAnnotationRemoved: function() {}
+  }
+
+  let historyObserver = {
+    onBeginUpdateBatch: function() {},
+    onEndUpdateBatch: function() {},
+    onVisit: function() {},
+    onTitleChanged: function HO_onTitleChanged(aURI, aPageTitle)
+    {
+      if (aURI.equals(SOURCE_URI)) {
+        titleSet = true;
+        do_check_eq(aPageTitle, DEST_FILE_NAME);
+        checkFinished();
+      }
+    },
+    onDeleteURI: function() {},
+    onClearHistory: function() {},
+    onPageChanged: function() {},
+    onDeleteVisits: function() {}
+  };
+
+  PlacesUtils.annotations.addObserver(annoObserver, false);
+  PlacesUtils.history.addObserver(historyObserver, false);
+
+  // Both null values and remote URIs should not cause errors.
+  gDownloadHistory.addDownload(SOURCE_URI, null, Date.now() * 1000);
+  gDownloadHistory.addDownload(SOURCE_URI, null, Date.now() * 1000, null);
+  gDownloadHistory.addDownload(SOURCE_URI, null, Date.now() * 1000, REMOTE_URI);
+
+  // Valid local file URIs should cause the download details to be saved.
+  gDownloadHistory.addDownload(SOURCE_URI, null, Date.now() * 1000,
+                               destFileUri);
+});
diff --git a/toolkit/components/places/tests/unit/test_frecency.js b/toolkit/components/places/tests/unit/test_frecency.js
new file mode 100644
index 000000000..a04befe00
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_frecency.js
@@ -0,0 +1,294 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Test for bug 406358 to make sure frecency works for empty input/search, but
+ * this also tests for non-empty inputs as well. Because the interactions among
+ * *DIFFERENT* visit counts and visit dates is not well defined, this test
+ * holds one of the two values constant when modifying the other.
+ *
+ * Also test bug 419068 to make sure tagged pages don't necessarily have to be
+ * first in the results.
+ *
+ * Also test bug 426166 to make sure that the results of autocomplete searches
+ * are stable.  Note that failures of this test will be intermittent by nature
+ * since we are testing to make sure that the unstable sort algorithm used
+ * by SQLite is not changing the order of the results on us.
+ */
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+function ensure_results(uris, searchTerm)
+{
+  PlacesTestUtils.promiseAsyncUpdates()
+                 .then(() => ensure_results_internal(uris, searchTerm));
+}
+
+function ensure_results_internal(uris, searchTerm)
+{
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput(["unifiedcomplete"]);
+
+  controller.input = input;
+
+  var numSearchesStarted = 0;
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  input.onSearchComplete = function() {
+    do_check_eq(numSearchesStarted, 1);
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+    do_check_eq(controller.matchCount, uris.length);
+    for (var i=0; i<controller.matchCount; i++) {
+      do_check_eq(controller.getValueAt(i), uris[i].spec);
+    }
+
+    deferEnsureResults.resolve();
+  };
+
+  controller.startSearch(searchTerm);
+}
+
+// Get history service
+try {
+  var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+                getService(Ci.nsINavHistoryService);
+  var bhist = histsvc.QueryInterface(Ci.nsIBrowserHistory);
+  var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+                getService(Ci.nsITaggingService);
+  var bmksvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+                getService(Ci.nsINavBookmarksService);
+} catch (ex) {
+  do_throw("Could not get history service\n");
+}
+
+function* task_setCountDate(aURI, aCount, aDate)
+{
+  // We need visits so that frecency can be computed over multiple visits
+  let visits = [];
+  for (let i = 0; i < aCount; i++) {
+    visits.push({ uri: aURI, visitDate: aDate, transition: TRANSITION_TYPED });
+  }
+  yield PlacesTestUtils.addVisits(visits);
+}
+
+function setBookmark(aURI)
+{
+  bmksvc.insertBookmark(bmksvc.bookmarksMenuFolder, aURI, -1, "bleh");
+}
+
+function tagURI(aURI, aTags) {
+  bmksvc.insertBookmark(bmksvc.unfiledBookmarksFolder, aURI,
+                        bmksvc.DEFAULT_INDEX, "bleh");
+  tagssvc.tagURI(aURI, aTags);
+}
+
+var uri1 = uri("http://site.tld/1");
+var uri2 = uri("http://site.tld/2");
+var uri3 = uri("http://aaaaaaaaaa/1");
+var uri4 = uri("http://aaaaaaaaaa/2");
+
+// d1 is younger (should show up higher) than d2 (PRTime is in usecs not msec)
+// Make sure the dates fall into different frecency buckets
+var d1 = new Date(Date.now() - 1000 * 60 * 60) * 1000;
+var d2 = new Date(Date.now() - 1000 * 60 * 60 * 24 * 10) * 1000;
+// c1 is larger (should show up higher) than c2
+var c1 = 10;
+var c2 = 1;
+
+var tests = [
+// test things without a search term
+function*() {
+  print("TEST-INFO | Test 0: same count, different date");
+  yield task_setCountDate(uri1, c1, d1);
+  yield task_setCountDate(uri2, c1, d2);
+  tagURI(uri1, ["site"]);
+  ensure_results([uri1, uri2], "");
+},
+function*() {
+  print("TEST-INFO | Test 1: same count, different date");
+  yield task_setCountDate(uri1, c1, d2);
+  yield task_setCountDate(uri2, c1, d1);
+  tagURI(uri1, ["site"]);
+  ensure_results([uri2, uri1], "");
+},
+function*() {
+  print("TEST-INFO | Test 2: different count, same date");
+  yield task_setCountDate(uri1, c1, d1);
+  yield task_setCountDate(uri2, c2, d1);
+  tagURI(uri1, ["site"]);
+  ensure_results([uri1, uri2], "");
+},
+function*() {
+  print("TEST-INFO | Test 3: different count, same date");
+  yield task_setCountDate(uri1, c2, d1);
+  yield task_setCountDate(uri2, c1, d1);
+  tagURI(uri1, ["site"]);
+  ensure_results([uri2, uri1], "");
+},
+
+// test things with a search term
+function*() {
+  print("TEST-INFO | Test 4: same count, different date");
+  yield task_setCountDate(uri1, c1, d1);
+  yield task_setCountDate(uri2, c1, d2);
+  tagURI(uri1, ["site"]);
+  ensure_results([uri1, uri2], "site");
+},
+function*() {
+  print("TEST-INFO | Test 5: same count, different date");
+  yield task_setCountDate(uri1, c1, d2);
+  yield task_setCountDate(uri2, c1, d1);
+  tagURI(uri1, ["site"]);
+  ensure_results([uri2, uri1], "site");
+},
+function*() {
+  print("TEST-INFO | Test 6: different count, same date");
+  yield task_setCountDate(uri1, c1, d1);
+  yield task_setCountDate(uri2, c2, d1);
+  tagURI(uri1, ["site"]);
+  ensure_results([uri1, uri2], "site");
+},
+function*() {
+  print("TEST-INFO | Test 7: different count, same date");
+  yield task_setCountDate(uri1, c2, d1);
+  yield task_setCountDate(uri2, c1, d1);
+  tagURI(uri1, ["site"]);
+  ensure_results([uri2, uri1], "site");
+},
+// There are multiple tests for 8, hence the multiple functions
+// Bug 426166 section
+function*() {
+  print("TEST-INFO | Test 8.1a: same count, same date");
+  setBookmark(uri3);
+  setBookmark(uri4);
+  ensure_results([uri4, uri3], "a");
+},
+function*() {
+  print("TEST-INFO | Test 8.1b: same count, same date");
+  setBookmark(uri3);
+  setBookmark(uri4);
+  ensure_results([uri4, uri3], "aa");
+},
+function*() {
+  print("TEST-INFO | Test 8.2: same count, same date");
+  setBookmark(uri3);
+  setBookmark(uri4);
+  ensure_results([uri4, uri3], "aaa");
+},
+function*() {
+  print("TEST-INFO | Test 8.3: same count, same date");
+  setBookmark(uri3);
+  setBookmark(uri4);
+  ensure_results([uri4, uri3], "aaaa");
+},
+function*() {
+  print("TEST-INFO | Test 8.4: same count, same date");
+  setBookmark(uri3);
+  setBookmark(uri4);
+  ensure_results([uri4, uri3], "aaa");
+},
+function*() {
+  print("TEST-INFO | Test 8.5: same count, same date");
+  setBookmark(uri3);
+  setBookmark(uri4);
+  ensure_results([uri4, uri3], "aa");
+},
+function*() {
+  print("TEST-INFO | Test 8.6: same count, same date");
+  setBookmark(uri3);
+  setBookmark(uri4);
+  ensure_results([uri4, uri3], "a");
+}
+];
+
+/**
+ * This deferred object contains a promise that is resolved when the
+ * ensure_results_internal function has finished its execution.
+ */
+var deferEnsureResults;
+
+add_task(function* test_frecency()
+{
+  // Disable autoFill for this test.
+  Services.prefs.setBoolPref("browser.urlbar.autoFill", false);
+  do_register_cleanup(() => Services.prefs.clearUserPref("browser.urlbar.autoFill"));
+  // always search in history + bookmarks, no matter what the default is
+  var prefs = Cc["@mozilla.org/preferences-service;1"].
+              getService(Ci.nsIPrefBranch);
+
+  prefs.setBoolPref("browser.urlbar.suggest.history", true);
+  prefs.setBoolPref("browser.urlbar.suggest.bookmark", true);
+  prefs.setBoolPref("browser.urlbar.suggest.openpage", false);
+  for (let test of tests) {
+    yield PlacesUtils.bookmarks.eraseEverything();
+    yield PlacesTestUtils.clearHistory();
+
+    deferEnsureResults = Promise.defer();
+    yield test();
+    yield deferEnsureResults.promise;
+  }
+  for (let type of ["history", "bookmark", "openpage"]) {
+    prefs.clearUserPref("browser.urlbar.suggest." + type);
+  }
+});
diff --git a/toolkit/components/places/tests/unit/test_frecency_observers.js b/toolkit/components/places/tests/unit/test_frecency_observers.js
new file mode 100644
index 000000000..7fadd4ae9
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_frecency_observers.js
@@ -0,0 +1,84 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test() {
+  run_next_test();
+}
+
+// Each of these tests a path that triggers a frecency update.  Together they
+// hit all sites that update a frecency.
+
+// InsertVisitedURIs::UpdateFrecency and History::InsertPlace
+add_task(function* test_InsertVisitedURIs_UpdateFrecency_and_History_InsertPlace() {
+  // InsertPlace is at the end of a path that UpdateFrecency is also on, so kill
+  // two birds with one stone and expect two notifications.  Trigger the path by
+  // adding a download.
+  let uri = NetUtil.newURI("http://example.com/a");
+  Cc["@mozilla.org/browser/download-history;1"].
+    getService(Ci.nsIDownloadHistory).
+    addDownload(uri);
+  yield Promise.all([onFrecencyChanged(uri), onFrecencyChanged(uri)]);
+});
+
+// nsNavHistory::UpdateFrecency
+add_task(function* test_nsNavHistory_UpdateFrecency() {
+  let bm = PlacesUtils.bookmarks;
+  let uri = NetUtil.newURI("http://example.com/b");
+  bm.insertBookmark(bm.unfiledBookmarksFolder, uri,
+                    Ci.nsINavBookmarksService.DEFAULT_INDEX, "test");
+  yield onFrecencyChanged(uri);
+});
+
+// nsNavHistory::invalidateFrecencies for particular pages
+add_task(function* test_nsNavHistory_invalidateFrecencies_somePages() {
+  let uri = NetUtil.newURI("http://test-nsNavHistory-invalidateFrecencies-somePages.com/");
+  // Bookmarking the URI is enough to add it to moz_places, and importantly, it
+  // means that removePagesFromHost doesn't remove it from moz_places, so its
+  // frecency is able to be changed.
+  let bm = PlacesUtils.bookmarks;
+  bm.insertBookmark(bm.unfiledBookmarksFolder, uri,
+                    Ci.nsINavBookmarksService.DEFAULT_INDEX, "test");
+  PlacesUtils.history.removePagesFromHost(uri.host, false);
+  yield onFrecencyChanged(uri);
+});
+
+// nsNavHistory::invalidateFrecencies for all pages
+add_task(function* test_nsNavHistory_invalidateFrecencies_allPages() {
+  yield Promise.all([onManyFrecenciesChanged(), PlacesTestUtils.clearHistory()]);
+});
+
+// nsNavHistory::DecayFrecency and nsNavHistory::FixInvalidFrecencies
+add_task(function* test_nsNavHistory_DecayFrecency_and_nsNavHistory_FixInvalidFrecencies() {
+  // FixInvalidFrecencies is at the end of a path that DecayFrecency is also on,
+  // so expect two notifications.  Trigger the path by making nsNavHistory
+  // observe the idle-daily notification.
+  PlacesUtils.history.QueryInterface(Ci.nsIObserver).
+    observe(null, "idle-daily", "");
+  yield Promise.all([onManyFrecenciesChanged(), onManyFrecenciesChanged()]);
+});
+
+function onFrecencyChanged(expectedURI) {
+  let deferred = Promise.defer();
+  let obs = new NavHistoryObserver();
+  obs.onFrecencyChanged =
+    (uri, newFrecency, guid, hidden, visitDate) => {
+      PlacesUtils.history.removeObserver(obs);
+      do_check_true(!!uri);
+      do_check_true(uri.equals(expectedURI));
+      deferred.resolve();
+    };
+  PlacesUtils.history.addObserver(obs, false);
+  return deferred.promise;
+}
+
+function onManyFrecenciesChanged() {
+  let deferred = Promise.defer();
+  let obs = new NavHistoryObserver();
+  obs.onManyFrecenciesChanged = () => {
+    PlacesUtils.history.removeObserver(obs);
+    do_check_true(true);
+    deferred.resolve();
+  };
+  PlacesUtils.history.addObserver(obs, false);
+  return deferred.promise;
+}
diff --git a/toolkit/components/places/tests/unit/test_frecency_zero_updated.js b/toolkit/components/places/tests/unit/test_frecency_zero_updated.js
new file mode 100644
index 000000000..e60030ca5
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_frecency_zero_updated.js
@@ -0,0 +1,30 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Tests a zero frecency is correctly updated when inserting new valid visits.
+
+function run_test()
+{
+  run_next_test()
+}
+
+add_task(function* ()
+{
+  const TEST_URI = NetUtil.newURI("http://example.com/");
+  let id = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                TEST_URI,
+                                                PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                "A title");
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_check_true(frecencyForUrl(TEST_URI) > 0);
+
+  // Removing the bookmark should leave an orphan page with zero frecency.
+  // Note this would usually be expired later by expiration.
+  PlacesUtils.bookmarks.removeItem(id);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_check_eq(frecencyForUrl(TEST_URI), 0);
+
+  // Now add a valid visit to the page, frecency should increase.
+  yield PlacesTestUtils.addVisits({ uri: TEST_URI });
+  do_check_true(frecencyForUrl(TEST_URI) > 0);
+});
diff --git a/toolkit/components/places/tests/unit/test_getChildIndex.js b/toolkit/components/places/tests/unit/test_getChildIndex.js
new file mode 100644
index 000000000..4cf164d45
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_getChildIndex.js
@@ -0,0 +1,69 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * vim:set ts=2 sw=2 sts=2 et:
+ * 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/. */
+
+/*
+ * Tests nsNavHistoryContainerResultNode::GetChildIndex(aNode) functionality.
+ */
+
+function run_test() {
+  // Add a bookmark to the menu.
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.bookmarksMenuFolderId,
+                                       uri("http://test.mozilla.org/bookmark/"),
+                                       Ci.nsINavBookmarksService.DEFAULT_INDEX,
+                                       "Test bookmark");
+
+  // Add a bookmark to unfiled folder.
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       uri("http://test.mozilla.org/unfiled/"),
+                                       Ci.nsINavBookmarksService.DEFAULT_INDEX,
+                                       "Unfiled bookmark");
+
+  // Get the unfiled bookmark node.
+  let unfiledNode = getNodeAt(PlacesUtils.unfiledBookmarksFolderId, 0);
+  if (!unfiledNode)
+    do_throw("Unable to find bookmark in hierarchy!");
+  do_check_eq(unfiledNode.title, "Unfiled bookmark");
+
+  let hs = PlacesUtils.history;
+  let query = hs.getNewQuery();
+  query.setFolders([PlacesUtils.bookmarksMenuFolderId], 1);
+  let options = hs.getNewQueryOptions();
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  let root = hs.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  // Check functionality for proper nodes.
+  for (let i = 0; i < root.childCount; i++) {
+    let node = root.getChild(i);
+    print("Now testing: " + node.title);
+    do_check_eq(root.getChildIndex(node), i);
+  }
+
+  // Now search for an invalid node and expect an exception.
+  try {
+    root.getChildIndex(unfiledNode);
+    do_throw("Searching for an invalid node should have thrown.");
+  } catch (ex) {
+    print("We correctly got an exception.");
+  }
+
+  root.containerOpen = false;
+}
+
+function getNodeAt(aFolderId, aIndex) {
+  let hs = PlacesUtils.history;
+  let query = hs.getNewQuery();
+  query.setFolders([aFolderId], 1);
+  let options = hs.getNewQueryOptions();
+  options.queryType = options.QUERY_TYPE_BOOKMARKS;
+  let root = hs.executeQuery(query, options).root;
+  root.containerOpen = true;
+  if (root.childCount < aIndex)
+    do_throw("Not enough children to find bookmark!");
+  let node = root.getChild(aIndex);
+  root.containerOpen = false;
+  return node;
+}
diff --git a/toolkit/components/places/tests/unit/test_getPlacesInfo.js b/toolkit/components/places/tests/unit/test_getPlacesInfo.js
new file mode 100644
index 000000000..3dfecb934
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_getPlacesInfo.js
@@ -0,0 +1,112 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function promiseGetPlacesInfo(aPlacesIdentifiers) {
+  let deferred = Promise.defer();
+  PlacesUtils.asyncHistory.getPlacesInfo(aPlacesIdentifiers, {
+    _results: [],
+    _errors: [],
+
+    handleResult: function handleResult(aPlaceInfo) {
+      this._results.push(aPlaceInfo);
+    },
+    handleError: function handleError(aResultCode, aPlaceInfo) {
+      this._errors.push({ resultCode: aResultCode, info: aPlaceInfo });
+    },
+    handleCompletion: function handleCompletion() {
+      deferred.resolve({ errors: this._errors, results: this._results });
+    }
+  });
+
+  return deferred.promise;
+}
+
+function ensurePlacesInfoObjectsAreEqual(a, b) {
+  do_check_true(a.uri.equals(b.uri));
+  do_check_eq(a.title, b.title);
+  do_check_eq(a.guid, b.guid);
+  do_check_eq(a.placeId, b.placeId);
+}
+
+function* test_getPlacesInfoExistentPlace() {
+  let testURI = NetUtil.newURI("http://www.example.tld");
+  yield PlacesTestUtils.addVisits(testURI);
+
+  let getPlacesInfoResult = yield promiseGetPlacesInfo([testURI]);
+  do_check_eq(getPlacesInfoResult.results.length, 1);
+  do_check_eq(getPlacesInfoResult.errors.length, 0);
+
+  let placeInfo = getPlacesInfoResult.results[0];
+  do_check_true(placeInfo instanceof Ci.mozIPlaceInfo);
+
+  do_check_true(placeInfo.uri.equals(testURI));
+  do_check_eq(placeInfo.title, "test visit for " + testURI.spec);
+  do_check_true(placeInfo.guid.length > 0);
+  do_check_eq(placeInfo.visits, null);
+}
+add_task(test_getPlacesInfoExistentPlace);
+
+function* test_getPlacesInfoNonExistentPlace() {
+  let testURI = NetUtil.newURI("http://www.example_non_existent.tld");
+  let getPlacesInfoResult = yield promiseGetPlacesInfo(testURI);
+  do_check_eq(getPlacesInfoResult.results.length, 0);
+  do_check_eq(getPlacesInfoResult.errors.length, 1);
+}
+add_task(test_getPlacesInfoNonExistentPlace);
+
+function* test_promisedHelper() {
+  let uri = NetUtil.newURI("http://www.helper_existent_example.tld");
+  yield PlacesTestUtils.addVisits(uri);
+  let placeInfo = yield PlacesUtils.promisePlaceInfo(uri);
+  do_check_true(placeInfo instanceof Ci.mozIPlaceInfo);
+
+  uri = NetUtil.newURI("http://www.helper_non_existent_example.tld");
+  try {
+    yield PlacesUtils.promisePlaceInfo(uri);
+    do_throw("PlacesUtils.promisePlaceInfo should have rejected the promise");
+  }
+  catch (ex) { }
+}
+add_task(test_promisedHelper);
+
+function* test_infoByGUID() {
+  let testURI = NetUtil.newURI("http://www.guid_example.tld");
+  yield PlacesTestUtils.addVisits(testURI);
+
+  let placeInfoByURI = yield PlacesUtils.promisePlaceInfo(testURI);
+  let placeInfoByGUID = yield PlacesUtils.promisePlaceInfo(placeInfoByURI.guid);
+  ensurePlacesInfoObjectsAreEqual(placeInfoByURI, placeInfoByGUID);
+}
+add_task(test_infoByGUID);
+
+function* test_invalid_guid() {
+  try {
+    yield PlacesUtils.promisePlaceInfo("###");
+    do_throw("getPlacesInfo should fail for invalid guids")
+  }
+  catch (ex) { }
+}
+add_task(test_invalid_guid);
+
+function* test_mixed_selection() {
+  let placeInfo1, placeInfo2;
+  let uri = NetUtil.newURI("http://www.mixed_selection_test_1.tld");
+  yield PlacesTestUtils.addVisits(uri);
+  placeInfo1 = yield PlacesUtils.promisePlaceInfo(uri);
+
+  uri = NetUtil.newURI("http://www.mixed_selection_test_2.tld");
+  yield PlacesTestUtils.addVisits(uri);
+  placeInfo2 = yield PlacesUtils.promisePlaceInfo(uri);
+
+  let getPlacesInfoResult = yield promiseGetPlacesInfo([placeInfo1.uri, placeInfo2.guid]);
+  do_check_eq(getPlacesInfoResult.results.length, 2);
+  do_check_eq(getPlacesInfoResult.errors.length, 0);
+
+  do_check_eq(getPlacesInfoResult.results[0].uri.spec, placeInfo1.uri.spec);
+  do_check_eq(getPlacesInfoResult.results[1].guid, placeInfo2.guid);
+}
+add_task(test_mixed_selection);
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_history.js b/toolkit/components/places/tests/unit/test_history.js
new file mode 100644
index 000000000..8d194cde1
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_history.js
@@ -0,0 +1,184 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get history services
+var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+              getService(Ci.nsINavHistoryService);
+
+/**
+ * Checks to see that a URI is in the database.
+ *
+ * @param aURI
+ *        The URI to check.
+ * @returns true if the URI is in the DB, false otherwise.
+ */
+function uri_in_db(aURI) {
+  var options = histsvc.getNewQueryOptions();
+  options.maxResults = 1;
+  options.resultType = options.RESULTS_AS_URI
+  var query = histsvc.getNewQuery();
+  query.uri = aURI;
+  var result = histsvc.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var cc = root.childCount;
+  root.containerOpen = false;
+  return (cc == 1);
+}
+
+// main
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  // we have a new profile, so we should have imported bookmarks
+  do_check_eq(histsvc.databaseStatus, histsvc.DATABASE_STATUS_CREATE);
+
+  // add a visit
+  var testURI = uri("http://mozilla.com");
+  yield PlacesTestUtils.addVisits(testURI);
+
+  // now query for the visit, setting sorting and limit such that
+  // we should retrieve only the visit we just added
+  var options = histsvc.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  options.maxResults = 1;
+  // TODO: using full visit crashes in xpcshell test
+  // options.resultType = options.RESULTS_AS_FULL_VISIT;
+  options.resultType = options.RESULTS_AS_VISIT;
+  var query = histsvc.getNewQuery();
+  var result = histsvc.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var cc = root.childCount;
+  for (var i=0; i < cc; ++i) {
+    var node = root.getChild(i);
+    // test node properties in RESULTS_AS_VISIT
+    do_check_eq(node.uri, testURI.spec);
+    do_check_eq(node.type, Ci.nsINavHistoryResultNode.RESULT_TYPE_URI);
+    // TODO: change query type to RESULTS_AS_FULL_VISIT and test this
+    // do_check_eq(node.transitionType, histsvc.TRANSITION_TYPED);
+  }
+  root.containerOpen = false;
+
+  // add another visit for the same URI, and a third visit for a different URI
+  var testURI2 = uri("http://google.com/");
+  yield PlacesTestUtils.addVisits(testURI);
+  yield PlacesTestUtils.addVisits(testURI2);
+
+  options.maxResults = 5;
+  options.resultType = options.RESULTS_AS_URI;
+
+  // test minVisits
+  query.minVisits = 0;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 2);
+  result.root.containerOpen = false;
+  query.minVisits = 1;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 2);
+  result.root.containerOpen = false;
+  query.minVisits = 2;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 1);
+  query.minVisits = 3;
+  result.root.containerOpen = false;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 0);
+  result.root.containerOpen = false;
+
+  // test maxVisits
+  query.minVisits = -1;
+  query.maxVisits = -1;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 2);
+  result.root.containerOpen = false;
+  query.maxVisits = 0;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 0);
+  result.root.containerOpen = false;
+  query.maxVisits = 1;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 1);
+  result.root.containerOpen = false;
+  query.maxVisits = 2;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 2);
+  result.root.containerOpen = false;
+  query.maxVisits = 3;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 2);
+  result.root.containerOpen = false;
+
+  // test annotation-based queries
+  var annos = Cc["@mozilla.org/browser/annotation-service;1"].
+              getService(Ci.nsIAnnotationService);
+  annos.setPageAnnotation(uri("http://mozilla.com/"), "testAnno", 0, 0,
+                          Ci.nsIAnnotationService.EXPIRE_NEVER);
+  query.annotation = "testAnno";
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 1);
+  do_check_eq(result.root.getChild(0).uri, "http://mozilla.com/");
+  result.root.containerOpen = false;
+
+  // test annotationIsNot
+  query.annotationIsNot = true;
+  result = histsvc.executeQuery(query, options);
+  result.root.containerOpen = true;
+  do_check_eq(result.root.childCount, 1);
+  do_check_eq(result.root.getChild(0).uri, "http://google.com/");
+  result.root.containerOpen = false;
+
+  // By default history is enabled.
+  do_check_true(!histsvc.historyDisabled);
+
+  // test getPageTitle
+  yield PlacesTestUtils.addVisits({ uri: uri("http://example.com"), title: "title" });
+  let placeInfo = yield PlacesUtils.promisePlaceInfo(uri("http://example.com"));
+  do_check_eq(placeInfo.title, "title");
+
+  // query for the visit
+  do_check_true(uri_in_db(testURI));
+
+  // test for schema changes in bug 373239
+  // get direct db connection
+  var db = histsvc.QueryInterface(Ci.nsPIPlacesDatabase).DBConnection;
+  var q = "SELECT id FROM moz_bookmarks";
+  var statement;
+  try {
+     statement = db.createStatement(q);
+  } catch (ex) {
+    do_throw("bookmarks table does not have id field, schema is too old!");
+  }
+  finally {
+    statement.finalize();
+  }
+
+  // bug 394741 - regressed history text searches
+  yield PlacesTestUtils.addVisits(uri("http://mozilla.com"));
+  options = histsvc.getNewQueryOptions();
+  // options.resultType = options.RESULTS_AS_VISIT;
+  query = histsvc.getNewQuery();
+  query.searchTerms = "moz";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_true(root.childCount > 0);
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_history_autocomplete_tags.js b/toolkit/components/places/tests/unit/test_history_autocomplete_tags.js
new file mode 100644
index 000000000..a5e0e1cb1
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_history_autocomplete_tags.js
@@ -0,0 +1,185 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var current_test = 0;
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+// Get tagging service
+try {
+  var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+                getService(Ci.nsITaggingService);
+} catch (ex) {
+  do_throw("Could not get tagging service\n");
+}
+
+function ensure_tag_results(uris, searchTerm)
+{
+  print("Searching for '" + searchTerm + "'");
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput(["unifiedcomplete"]);
+
+  controller.input = input;
+
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  var numSearchesStarted = 0;
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  input.onSearchComplete = function() {
+    do_check_eq(numSearchesStarted, 1);
+    do_check_eq(controller.searchStatus,
+                uris.length ?
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH :
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH);
+    do_check_eq(controller.matchCount, uris.length);
+    let vals = [];
+    for (let i=0; i<controller.matchCount; i++) {
+      // Keep the URL for later because order of tag results is undefined
+      vals.push(controller.getValueAt(i));
+      do_check_eq(controller.getStyleAt(i), "bookmark-tag");
+    }
+    // Sort the results then check if we have the right items
+    vals.sort().forEach((val, i) => do_check_eq(val, uris[i].spec))
+
+    if (current_test < (tests.length - 1)) {
+      current_test++;
+      tests[current_test]();
+    }
+
+    do_test_finished();
+  };
+
+  controller.startSearch(searchTerm);
+}
+
+var uri1 = uri("http://site.tld/1/aaa");
+var uri2 = uri("http://site.tld/2/bbb");
+var uri3 = uri("http://site.tld/3/aaa");
+var uri4 = uri("http://site.tld/4/bbb");
+var uri5 = uri("http://site.tld/5/aaa");
+var uri6 = uri("http://site.tld/6/bbb");
+
+var tests = [
+  () => ensure_tag_results([uri1, uri4, uri6], "foo"),
+  () => ensure_tag_results([uri1], "foo aaa"),
+  () => ensure_tag_results([uri4, uri6], "foo bbb"),
+  () => ensure_tag_results([uri2, uri4, uri5, uri6], "bar"),
+  () => ensure_tag_results([uri5], "bar aaa"),
+  () => ensure_tag_results([uri2, uri4, uri6], "bar bbb"),
+  () => ensure_tag_results([uri3, uri5, uri6], "cheese"),
+  () => ensure_tag_results([uri3, uri5], "chees aaa"),
+  () => ensure_tag_results([uri6], "chees bbb"),
+  () => ensure_tag_results([uri4, uri6], "fo bar"),
+  () => ensure_tag_results([], "fo bar aaa"),
+  () => ensure_tag_results([uri4, uri6], "fo bar bbb"),
+  () => ensure_tag_results([uri4, uri6], "ba foo"),
+  () => ensure_tag_results([], "ba foo aaa"),
+  () => ensure_tag_results([uri4, uri6], "ba foo bbb"),
+  () => ensure_tag_results([uri5, uri6], "ba chee"),
+  () => ensure_tag_results([uri5], "ba chee aaa"),
+  () => ensure_tag_results([uri6], "ba chee bbb"),
+  () => ensure_tag_results([uri5, uri6], "cheese bar"),
+  () => ensure_tag_results([uri5], "cheese bar aaa"),
+  () => ensure_tag_results([uri6], "chees bar bbb"),
+  () => ensure_tag_results([uri6], "cheese bar foo"),
+  () => ensure_tag_results([], "foo bar cheese aaa"),
+  () => ensure_tag_results([uri6], "foo bar cheese bbb"),
+];
+
+/**
+ * Properly tags a uri adding it to bookmarks.
+ *
+ * @param aURI
+ *        The nsIURI to tag.
+ * @param aTags
+ *        The tags to add.
+ */
+function tagURI(aURI, aTags) {
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       aURI,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "A title");
+  tagssvc.tagURI(aURI, aTags);
+}
+
+/**
+ * Test history autocomplete
+ */
+function run_test() {
+  // always search in history + bookmarks, no matter what the default is
+  var prefs = Cc["@mozilla.org/preferences-service;1"].
+              getService(Ci.nsIPrefBranch);
+  prefs.setIntPref("browser.urlbar.search.sources", 3);
+  prefs.setIntPref("browser.urlbar.default.behavior", 0);
+
+  tagURI(uri1, ["foo"]);
+  tagURI(uri2, ["bar"]);
+  tagURI(uri3, ["cheese"]);
+  tagURI(uri4, ["foo bar"]);
+  tagURI(uri5, ["bar cheese"]);
+  tagURI(uri6, ["foo bar cheese"]);
+
+  tests[0]();
+}
diff --git a/toolkit/components/places/tests/unit/test_history_catobs.js b/toolkit/components/places/tests/unit/test_history_catobs.js
new file mode 100644
index 000000000..e0a81d67b
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_history_catobs.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* () {
+  do_load_manifest("nsDummyObserver.manifest");
+
+  let dummyCreated = false;
+  let dummyReceivedOnVisit = false;
+
+  Services.obs.addObserver(function created() {
+    Services.obs.removeObserver(created, "dummy-observer-created");
+    dummyCreated = true;
+  }, "dummy-observer-created", false);
+  Services.obs.addObserver(function visited() {
+    Services.obs.removeObserver(visited, "dummy-observer-visited");
+    dummyReceivedOnVisit = true;
+  }, "dummy-observer-visited", false);
+
+  let initialObservers = PlacesUtils.history.getObservers();
+
+  // Add a common observer, it should be invoked after the category observer.
+  let notificationsPromised = new Promise((resolve, reject) => {
+    PlacesUtils.history.addObserver({
+      __proto__: NavHistoryObserver.prototype,
+      onVisit() {
+        let observers = PlacesUtils.history.getObservers();
+        Assert.equal(observers.length, initialObservers.length + 1);
+
+        // Check the common observer is the last one.
+        for (let i = 0; i < initialObservers.length; ++i) {
+          Assert.equal(initialObservers[i], observers[i]);
+        }
+
+        PlacesUtils.history.removeObserver(this);
+        observers = PlacesUtils.history.getObservers();
+        Assert.equal(observers.length, initialObservers.length);
+
+        // Check the category observer has been invoked before this one.
+        Assert.ok(dummyCreated);
+        Assert.ok(dummyReceivedOnVisit);
+        resolve();
+      }
+    }, false);
+  });
+
+  // Add a visit.
+  yield PlacesTestUtils.addVisits(uri("http://typed.mozilla.org"));
+
+  yield notificationsPromised;
+});
diff --git a/toolkit/components/places/tests/unit/test_history_clear.js b/toolkit/components/places/tests/unit/test_history_clear.js
new file mode 100644
index 000000000..56d34994f
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_history_clear.js
@@ -0,0 +1,169 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var mDBConn = DBConn();
+
+function promiseOnClearHistoryObserved() {
+  let deferred = Promise.defer();
+
+  let historyObserver = {
+    onBeginUpdateBatch: function() {},
+    onEndUpdateBatch: function() {},
+    onVisit: function() {},
+    onTitleChanged: function() {},
+    onDeleteURI: function(aURI) {},
+    onPageChanged: function() {},
+    onDeleteVisits: function() {},
+
+    onClearHistory: function() {
+      PlacesUtils.history.removeObserver(this, false);
+      deferred.resolve();
+    },
+
+    QueryInterface: XPCOMUtils.generateQI([
+      Ci.nsINavHistoryObserver,
+    ])
+  }
+  PlacesUtils.history.addObserver(historyObserver, false);
+  return deferred.promise;
+}
+
+// This global variable is a promise object, initialized in run_test and waited
+// upon in the first asynchronous test.  It is resolved when the
+// "places-init-complete" notification is received. We cannot initialize it in
+// the asynchronous test, because then it's too late to register the observer.
+var promiseInit;
+
+function run_test() {
+  // places-init-complete is notified after run_test, and it will
+  // run a first frecency fix through async statements.
+  // To avoid random failures we have to run after all of this.
+  promiseInit = promiseTopicObserved(PlacesUtils.TOPIC_INIT_COMPLETE);
+
+  run_next_test();
+}
+
+add_task(function* test_history_clear()
+{
+  yield promiseInit;
+
+  yield PlacesTestUtils.addVisits([
+    { uri: uri("http://typed.mozilla.org/"),
+      transition: TRANSITION_TYPED },
+    { uri: uri("http://link.mozilla.org/"),
+      transition: TRANSITION_LINK },
+    { uri: uri("http://download.mozilla.org/"),
+      transition: TRANSITION_DOWNLOAD },
+    { uri: uri("http://redir_temp.mozilla.org/"),
+      transition: TRANSITION_REDIRECT_TEMPORARY,
+      referrer: "http://link.mozilla.org/"},
+    { uri: uri("http://redir_perm.mozilla.org/"),
+      transition: TRANSITION_REDIRECT_PERMANENT,
+      referrer: "http://link.mozilla.org/"},
+  ]);
+
+  // add a place: bookmark
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       uri("place:folder=4"),
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "shortcut");
+
+  // Add an expire never annotation
+  // Actually expire never annotations are removed as soon as a page is removed
+  // from the database, so this should act as a normal visit.
+  PlacesUtils.annotations.setPageAnnotation(uri("http://download.mozilla.org/"),
+                                            "never", "never", 0,
+                                            PlacesUtils.annotations.EXPIRE_NEVER);
+
+  // Add a bookmark
+  // Bookmarked page should have history cleared and frecency = -1
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       uri("http://typed.mozilla.org/"),
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "bookmark");
+
+  yield PlacesTestUtils.addVisits([
+    { uri: uri("http://typed.mozilla.org/"),
+      transition: TRANSITION_BOOKMARK },
+    { uri: uri("http://frecency.mozilla.org/"),
+      transition: TRANSITION_LINK },
+  ]);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  // Clear history and wait for the onClearHistory notification.
+  let promiseWaitClearHistory = promiseOnClearHistoryObserved();
+  PlacesUtils.history.clear();
+  yield promiseWaitClearHistory;
+
+  // check browserHistory returns no entries
+  do_check_eq(0, PlacesUtils.history.hasHistoryEntries);
+
+  yield promiseTopicObserved(PlacesUtils.TOPIC_EXPIRATION_FINISHED);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  // Check that frecency for not cleared items (bookmarks) has been converted
+  // to -1.
+  stmt = mDBConn.createStatement(
+    "SELECT h.id FROM moz_places h WHERE h.frecency > 0 ");
+  do_check_false(stmt.executeStep());
+  stmt.finalize();
+
+  stmt = mDBConn.createStatement(
+    `SELECT h.id FROM moz_places h WHERE h.frecency < 0
+       AND EXISTS (SELECT id FROM moz_bookmarks WHERE fk = h.id) LIMIT 1`);
+  do_check_true(stmt.executeStep());
+  stmt.finalize();
+
+  // Check that all visit_counts have been brought to 0
+  stmt = mDBConn.createStatement(
+    "SELECT id FROM moz_places WHERE visit_count <> 0 LIMIT 1");
+  do_check_false(stmt.executeStep());
+  stmt.finalize();
+
+  // Check that history tables are empty
+  stmt = mDBConn.createStatement(
+    "SELECT * FROM (SELECT id FROM moz_historyvisits LIMIT 1)");
+  do_check_false(stmt.executeStep());
+  stmt.finalize();
+
+  // Check that all moz_places entries except bookmarks and place: have been removed
+  stmt = mDBConn.createStatement(
+    `SELECT h.id FROM moz_places h WHERE
+       url_hash NOT BETWEEN hash('place', 'prefix_lo') AND hash('place', 'prefix_hi')
+       AND NOT EXISTS (SELECT id FROM moz_bookmarks WHERE fk = h.id) LIMIT 1`);
+  do_check_false(stmt.executeStep());
+  stmt.finalize();
+
+  // Check that we only have favicons for retained places
+  stmt = mDBConn.createStatement(
+    `SELECT f.id FROM moz_favicons f WHERE NOT EXISTS
+       (SELECT id FROM moz_places WHERE favicon_id = f.id) LIMIT 1`);
+  do_check_false(stmt.executeStep());
+  stmt.finalize();
+
+  // Check that we only have annotations for retained places
+  stmt = mDBConn.createStatement(
+    `SELECT a.id FROM moz_annos a WHERE NOT EXISTS
+       (SELECT id FROM moz_places WHERE id = a.place_id) LIMIT 1`);
+  do_check_false(stmt.executeStep());
+  stmt.finalize();
+
+  // Check that we only have inputhistory for retained places
+  stmt = mDBConn.createStatement(
+    `SELECT i.place_id FROM moz_inputhistory i WHERE NOT EXISTS
+       (SELECT id FROM moz_places WHERE id = i.place_id) LIMIT 1`);
+  do_check_false(stmt.executeStep());
+  stmt.finalize();
+
+  // Check that place:uris have frecency 0
+  stmt = mDBConn.createStatement(
+    `SELECT h.id FROM moz_places h
+     WHERE url_hash BETWEEN hash('place', 'prefix_lo')
+                        AND hash('place', 'prefix_hi')
+       AND h.frecency <> 0 LIMIT 1`);
+  do_check_false(stmt.executeStep());
+  stmt.finalize();
+});
diff --git a/toolkit/components/places/tests/unit/test_history_notifications.js b/toolkit/components/places/tests/unit/test_history_notifications.js
new file mode 100644
index 000000000..4e1e635a0
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_history_notifications.js
@@ -0,0 +1,38 @@
+const NS_PLACES_INIT_COMPLETE_TOPIC = "places-init-complete";
+const NS_PLACES_DATABASE_LOCKED_TOPIC = "places-database-locked";
+
+add_task(function* () {
+  // Create a dummy places.sqlite and open an unshared connection on it
+  let db = Services.dirsvc.get('ProfD', Ci.nsIFile);
+  db.append("places.sqlite");
+  let dbConn = Services.storage.openUnsharedDatabase(db);
+  Assert.ok(db.exists(), "The database should have been created");
+
+  // We need an exclusive lock on the db
+  dbConn.executeSimpleSQL("PRAGMA locking_mode = EXCLUSIVE");
+  // Exclusive locking is lazy applied, we need to make a write to activate it
+  dbConn.executeSimpleSQL("PRAGMA USER_VERSION = 1");
+
+  // Try to create history service while the db is locked
+  let promiseLocked = promiseTopicObserved(NS_PLACES_DATABASE_LOCKED_TOPIC);
+  Assert.throws(() => Cc["@mozilla.org/browser/nav-history-service;1"]
+                        .getService(Ci.nsINavHistoryService),
+                /NS_ERROR_XPC_GS_RETURNED_FAILURE/);
+  yield promiseLocked;
+
+  // Close our connection and try to cleanup the file (could fail on Windows)
+  dbConn.close();
+  if (db.exists()) {
+    try {
+      db.remove(false);
+    } catch (e) {
+      do_print("Unable to remove dummy places.sqlite");
+    }
+  }
+
+  // Create history service correctly
+  let promiseComplete = promiseTopicObserved(NS_PLACES_INIT_COMPLETE_TOPIC);
+  Cc["@mozilla.org/browser/nav-history-service;1"]
+    .getService(Ci.nsINavHistoryService);
+  yield promiseComplete;
+});
diff --git a/toolkit/components/places/tests/unit/test_history_observer.js b/toolkit/components/places/tests/unit/test_history_observer.js
new file mode 100644
index 000000000..c101cfb61
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_history_observer.js
@@ -0,0 +1,215 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Generic nsINavHistoryObserver that doesn't implement anything, but provides
+ * dummy methods to prevent errors about an object not having a certain method.
+ */
+function NavHistoryObserver() {
+}
+NavHistoryObserver.prototype = {
+  onBeginUpdateBatch: function() { },
+  onEndUpdateBatch: function() { },
+  onVisit: function() { },
+  onTitleChanged: function() { },
+  onDeleteURI: function() { },
+  onClearHistory: function() { },
+  onPageChanged: function() { },
+  onDeleteVisits: function() { },
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver])
+};
+
+/**
+ * Registers a one-time history observer for and calls the callback
+ * when the specified nsINavHistoryObserver method is called.
+ * Returns a promise that is resolved when the callback returns.
+ */
+function onNotify(callback) {
+  return new Promise(resolve => {
+    let obs = new NavHistoryObserver();
+    obs[callback.name] = function () {
+      PlacesUtils.history.removeObserver(this);
+      callback.apply(this, arguments);
+      resolve();
+    };
+    PlacesUtils.history.addObserver(obs, false);
+  });
+}
+
+/**
+ * Asynchronous task that adds a visit to the history database.
+ */
+function* task_add_visit(uri, timestamp, transition) {
+  uri = uri || NetUtil.newURI("http://firefox.com/");
+  timestamp = timestamp || Date.now() * 1000;
+  yield PlacesTestUtils.addVisits({
+    uri: uri,
+    transition: transition || TRANSITION_TYPED,
+    visitDate: timestamp
+  });
+  return [uri, timestamp];
+}
+
+add_task(function* test_onVisit() {
+  let promiseNotify = onNotify(function onVisit(aURI, aVisitID, aTime,
+                                                aSessionID, aReferringID,
+                                                aTransitionType, aGUID,
+                                                aHidden, aVisitCount, aTyped) {
+    Assert.ok(aURI.equals(testuri));
+    Assert.ok(aVisitID > 0);
+    Assert.equal(aTime, testtime);
+    Assert.equal(aSessionID, 0);
+    Assert.equal(aReferringID, 0);
+    Assert.equal(aTransitionType, TRANSITION_TYPED);
+    do_check_guid_for_uri(aURI, aGUID);
+    Assert.ok(!aHidden);
+    Assert.equal(aVisitCount, 1);
+    Assert.equal(aTyped, 1);
+  });
+  let testuri = NetUtil.newURI("http://firefox.com/");
+  let testtime = Date.now() * 1000;
+  yield task_add_visit(testuri, testtime);
+  yield promiseNotify;
+});
+
+add_task(function* test_onVisit() {
+  let promiseNotify = onNotify(function onVisit(aURI, aVisitID, aTime,
+                                                aSessionID, aReferringID,
+                                                aTransitionType, aGUID,
+                                                aHidden, aVisitCount, aTyped) {
+    Assert.ok(aURI.equals(testuri));
+    Assert.ok(aVisitID > 0);
+    Assert.equal(aTime, testtime);
+    Assert.equal(aSessionID, 0);
+    Assert.equal(aReferringID, 0);
+    Assert.equal(aTransitionType, TRANSITION_FRAMED_LINK);
+    do_check_guid_for_uri(aURI, aGUID);
+    Assert.ok(aHidden);
+    Assert.equal(aVisitCount, 1);
+    Assert.equal(aTyped, 0);
+  });
+  let testuri = NetUtil.newURI("http://hidden.firefox.com/");
+  let testtime = Date.now() * 1000;
+  yield task_add_visit(testuri, testtime, TRANSITION_FRAMED_LINK);
+  yield promiseNotify;
+});
+
+add_task(function* test_multiple_onVisit() {
+  let testuri = NetUtil.newURI("http://self.firefox.com/");
+  let promiseNotifications = new Promise(resolve => {
+    let observer = {
+      _c: 0,
+      __proto__: NavHistoryObserver.prototype,
+      onVisit(uri, id, time, unused, referrerId, transition, guid,
+              hidden, visitCount, typed) {
+        Assert.ok(testuri.equals(uri));
+        Assert.ok(id > 0);
+        Assert.ok(time > 0);
+        Assert.ok(!hidden);
+        do_check_guid_for_uri(uri, guid);
+        switch (++this._c) {
+          case 1:
+            Assert.equal(referrerId, 0);
+            Assert.equal(transition, TRANSITION_LINK);
+            Assert.equal(visitCount, 1);
+            Assert.equal(typed, 0);
+            break;
+          case 2:
+            Assert.ok(referrerId > 0);
+            Assert.equal(transition, TRANSITION_LINK);
+            Assert.equal(visitCount, 2);
+            Assert.equal(typed, 0);
+            break;
+          case 3:
+            Assert.equal(referrerId, 0);
+            Assert.equal(transition, TRANSITION_TYPED);
+            Assert.equal(visitCount, 3);
+            Assert.equal(typed, 1);
+
+            PlacesUtils.history.removeObserver(observer, false);
+            resolve();
+            break;
+        }
+      }
+    };
+    PlacesUtils.history.addObserver(observer, false);
+  });
+  yield PlacesTestUtils.addVisits([
+    { uri: testuri, transition: TRANSITION_LINK },
+    { uri: testuri, referrer: testuri, transition: TRANSITION_LINK },
+    { uri: testuri, transition: TRANSITION_TYPED },
+  ]);
+  yield promiseNotifications;
+});
+
+add_task(function* test_onDeleteURI() {
+  let promiseNotify = onNotify(function onDeleteURI(aURI, aGUID, aReason) {
+    Assert.ok(aURI.equals(testuri));
+    // Can't use do_check_guid_for_uri() here because the visit is already gone.
+    Assert.equal(aGUID, testguid);
+    Assert.equal(aReason, Ci.nsINavHistoryObserver.REASON_DELETED);
+  });
+  let [testuri] = yield task_add_visit();
+  let testguid = do_get_guid_for_uri(testuri);
+  PlacesUtils.bhistory.removePage(testuri);
+  yield promiseNotify;
+});
+
+add_task(function* test_onDeleteVisits() {
+  let promiseNotify = onNotify(function onDeleteVisits(aURI, aVisitTime, aGUID,
+                                                       aReason) {
+    Assert.ok(aURI.equals(testuri));
+    // Can't use do_check_guid_for_uri() here because the visit is already gone.
+    Assert.equal(aGUID, testguid);
+    Assert.equal(aReason, Ci.nsINavHistoryObserver.REASON_DELETED);
+    Assert.equal(aVisitTime, 0); // All visits have been removed.
+  });
+  let msecs24hrsAgo = Date.now() - (86400 * 1000);
+  let [testuri] = yield task_add_visit(undefined, msecs24hrsAgo * 1000);
+  // Add a bookmark so the page is not removed.
+  PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                       testuri,
+                                       PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                       "test");
+  let testguid = do_get_guid_for_uri(testuri);
+  PlacesUtils.bhistory.removePage(testuri);
+  yield promiseNotify;
+});
+
+add_task(function* test_onTitleChanged() {
+  let promiseNotify = onNotify(function onTitleChanged(aURI, aTitle, aGUID) {
+    Assert.ok(aURI.equals(testuri));
+    Assert.equal(aTitle, title);
+    do_check_guid_for_uri(aURI, aGUID);
+  });
+
+  let [testuri] = yield task_add_visit();
+  let title = "test-title";
+  yield PlacesTestUtils.addVisits({
+    uri: testuri,
+    title: title
+  });
+  yield promiseNotify;
+});
+
+add_task(function* test_onPageChanged() {
+  let promiseNotify = onNotify(function onPageChanged(aURI, aChangedAttribute,
+                                                      aNewValue, aGUID) {
+    Assert.equal(aChangedAttribute, Ci.nsINavHistoryObserver.ATTRIBUTE_FAVICON);
+    Assert.ok(aURI.equals(testuri));
+    Assert.equal(aNewValue, SMALLPNG_DATA_URI.spec);
+    do_check_guid_for_uri(aURI, aGUID);
+  });
+
+  let [testuri] = yield task_add_visit();
+
+  // The new favicon for the page must have data associated with it in order to
+  // receive the onPageChanged notification.  To keep this test self-contained,
+  // we use an URI representing the smallest possible PNG file.
+  PlacesUtils.favicons.setAndFetchFaviconForPage(testuri, SMALLPNG_DATA_URI,
+                                                 false,
+                                                 PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+                                                 null,
+                                                 Services.scriptSecurityManager.getSystemPrincipal());
+  yield promiseNotify;
+});
diff --git a/toolkit/components/places/tests/unit/test_history_sidebar.js b/toolkit/components/places/tests/unit/test_history_sidebar.js
new file mode 100644
index 000000000..1c03547d7
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_history_sidebar.js
@@ -0,0 +1,447 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get history service
+var hs = Cc["@mozilla.org/browser/nav-history-service;1"].
+         getService(Ci.nsINavHistoryService);
+var bh = hs.QueryInterface(Ci.nsIBrowserHistory);
+var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+         getService(Ci.nsINavBookmarksService);
+var ps = Cc["@mozilla.org/preferences-service;1"].
+         getService(Ci.nsIPrefBranch);
+
+/**
+ * Adds a test URI visit to the database.
+ *
+ * @param aURI
+ *        The URI to add a visit for.
+ * @param aTime
+ *        Reference "now" time.
+ * @param aDayOffset
+ *        number of days to add, pass a negative value to subtract them.
+ */
+function* task_add_normalized_visit(aURI, aTime, aDayOffset) {
+  var dateObj = new Date(aTime);
+  // Normalize to midnight
+  dateObj.setHours(0);
+  dateObj.setMinutes(0);
+  dateObj.setSeconds(0);
+  dateObj.setMilliseconds(0);
+  // Days where DST changes should be taken in count.
+  var previousDateObj = new Date(dateObj.getTime() + aDayOffset * 86400000);
+  var DSTCorrection = (dateObj.getTimezoneOffset() -
+                       previousDateObj.getTimezoneOffset()) * 60 * 1000;
+  // Substract aDayOffset
+  var PRTimeWithOffset = (previousDateObj.getTime() - DSTCorrection) * 1000;
+  var timeInMs = new Date(PRTimeWithOffset/1000);
+  print("Adding visit to " + aURI.spec + " at " + timeInMs);
+  yield PlacesTestUtils.addVisits({
+    uri: aURI,
+    visitDate: PRTimeWithOffset
+  });
+}
+
+function days_for_x_months_ago(aNowObj, aMonths) {
+  var oldTime = new Date();
+  // Set day before month, otherwise we could try to calculate 30 February, or
+  // other nonexistent days.
+  oldTime.setDate(1);
+  oldTime.setMonth(aNowObj.getMonth() - aMonths);
+  oldTime.setHours(0);
+  oldTime.setMinutes(0);
+  oldTime.setSeconds(0);
+  // Stay larger for eventual timezone issues, add 2 days.
+  return parseInt((aNowObj - oldTime) / (1000*60*60*24)) + 2;
+}
+
+var nowObj = new Date();
+// This test relies on en-US locale
+// Offset is number of days
+/* eslint-disable comma-spacing */
+var containers = [
+  { label: "Today"               , offset: 0                                 , visible: true },
+  { label: "Yesterday"           , offset: -1                                , visible: true },
+  { label: "Last 7 days"         , offset: -3                                , visible: true },
+  { label: "This month"          , offset: -8                                , visible: nowObj.getDate() > 8 },
+  { label: ""                    , offset: -days_for_x_months_ago(nowObj, 0) , visible: true },
+  { label: ""                    , offset: -days_for_x_months_ago(nowObj, 1) , visible: true },
+  { label: ""                    , offset: -days_for_x_months_ago(nowObj, 2) , visible: true },
+  { label: ""                    , offset: -days_for_x_months_ago(nowObj, 3) , visible: true },
+  { label: ""                    , offset: -days_for_x_months_ago(nowObj, 4) , visible: true },
+  { label: "Older than 6 months" , offset: -days_for_x_months_ago(nowObj, 5) , visible: true },
+];
+/* eslint-enable comma-spacing */
+
+var visibleContainers = containers.filter(
+  function(aContainer) { return aContainer.visible });
+
+/**
+ * Asynchronous task that fills history and checks containers' labels.
+ */
+function* task_fill_history() {
+  print("\n\n*** TEST Fill History\n");
+  // We can't use "now" because our hardcoded offsets would be invalid for some
+  // date.  So we hardcode a date.
+  for (let i = 0; i < containers.length; i++) {
+    let container = containers[i];
+    var testURI = uri("http://mirror"+i+".mozilla.com/b");
+    yield task_add_normalized_visit(testURI, nowObj.getTime(), container.offset);
+    testURI = uri("http://mirror"+i+".mozilla.com/a");
+    yield task_add_normalized_visit(testURI, nowObj.getTime(), container.offset);
+    testURI = uri("http://mirror"+i+".google.com/b");
+    yield task_add_normalized_visit(testURI, nowObj.getTime(), container.offset);
+    testURI = uri("http://mirror"+i+".google.com/a");
+    yield task_add_normalized_visit(testURI, nowObj.getTime(), container.offset);
+    // Bug 485703 - Hide date containers not containing additional entries
+    //              compared to previous ones.
+    // Check after every new container is added.
+    check_visit(container.offset);
+  }
+
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_DATE_SITE_QUERY;
+  var query = hs.getNewQuery();
+
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  var cc = root.childCount;
+  print("Found containers:");
+  var previousLabels = [];
+  for (let i = 0; i < cc; i++) {
+    let container = visibleContainers[i];
+    var node = root.getChild(i);
+    print(node.title);
+    if (container.label)
+      do_check_eq(node.title, container.label);
+    // Check labels are not repeated.
+    do_check_eq(previousLabels.indexOf(node.title), -1);
+    previousLabels.push(node.title);
+  }
+  do_check_eq(cc, visibleContainers.length);
+  root.containerOpen = false;
+}
+
+/**
+ * Bug 485703 - Hide date containers not containing additional entries compared
+ *              to previous ones.
+ */
+function check_visit(aOffset) {
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_DATE_SITE_QUERY;
+  var query = hs.getNewQuery();
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  var cc = root.childCount;
+
+  var unexpected = [];
+  switch (aOffset) {
+    case 0:
+      unexpected = ["Yesterday", "Last 7 days", "This month"];
+      break;
+    case -1:
+      unexpected = ["Last 7 days", "This month"];
+      break;
+    case -3:
+      unexpected = ["This month"];
+      break;
+    default:
+      // Other containers are tested later.
+  }
+
+  print("Found containers:");
+  for (var i = 0; i < cc; i++) {
+    var node = root.getChild(i);
+    print(node.title);
+    do_check_eq(unexpected.indexOf(node.title), -1);
+  }
+
+  root.containerOpen = false;
+}
+
+/**
+ * Queries history grouped by date and site, checking containers' labels and
+ * children.
+ */
+function test_RESULTS_AS_DATE_SITE_QUERY() {
+  print("\n\n*** TEST RESULTS_AS_DATE_SITE_QUERY\n");
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_DATE_SITE_QUERY;
+  var query = hs.getNewQuery();
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  // Check one of the days
+  var dayNode = root.getChild(0)
+                    .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  dayNode.containerOpen = true;
+  do_check_eq(dayNode.childCount, 2);
+
+  // Items should be sorted by host
+  var site1 = dayNode.getChild(0)
+                     .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(site1.title, "mirror0.google.com");
+
+  var site2 = dayNode.getChild(1)
+                     .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(site2.title, "mirror0.mozilla.com");
+
+  site1.containerOpen = true;
+  do_check_eq(site1.childCount, 2);
+
+  // Inside of host sites are sorted by title
+  var site1visit = site1.getChild(0);
+  do_check_eq(site1visit.uri, "http://mirror0.google.com/a");
+
+  // Bug 473157: changing sorting mode should not affect the containers
+  result.sortingMode = options.SORT_BY_TITLE_DESCENDING;
+
+  // Check one of the days
+  dayNode = root.getChild(0)
+                    .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  dayNode.containerOpen = true;
+  do_check_eq(dayNode.childCount, 2);
+
+  // Hosts are still sorted by title
+  site1 = dayNode.getChild(0)
+                     .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(site1.title, "mirror0.google.com");
+
+  site2 = dayNode.getChild(1)
+                     .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(site2.title, "mirror0.mozilla.com");
+
+  site1.containerOpen = true;
+  do_check_eq(site1.childCount, 2);
+
+  // But URLs are now sorted by title descending
+  site1visit = site1.getChild(0);
+  do_check_eq(site1visit.uri, "http://mirror0.google.com/b");
+
+  site1.containerOpen = false;
+  dayNode.containerOpen = false;
+  root.containerOpen = false;
+}
+
+/**
+ * Queries history grouped by date, checking containers' labels and children.
+ */
+function test_RESULTS_AS_DATE_QUERY() {
+  print("\n\n*** TEST RESULTS_AS_DATE_QUERY\n");
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_DATE_QUERY;
+  var query = hs.getNewQuery();
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  var cc = root.childCount;
+  do_check_eq(cc, visibleContainers.length);
+  print("Found containers:");
+  for (var i = 0; i < cc; i++) {
+    var container = visibleContainers[i];
+    var node = root.getChild(i);
+    print(node.title);
+    if (container.label)
+      do_check_eq(node.title, container.label);
+  }
+
+  // Check one of the days
+  var dayNode = root.getChild(0)
+                    .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  dayNode.containerOpen = true;
+  do_check_eq(dayNode.childCount, 4);
+
+  // Items should be sorted by title
+  var visit1 = dayNode.getChild(0);
+  do_check_eq(visit1.uri, "http://mirror0.google.com/a");
+
+  var visit2 = dayNode.getChild(3);
+  do_check_eq(visit2.uri, "http://mirror0.mozilla.com/b");
+
+  // Bug 473157: changing sorting mode should not affect the containers
+  result.sortingMode = options.SORT_BY_TITLE_DESCENDING;
+
+  // Check one of the days
+  dayNode = root.getChild(0)
+                    .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  dayNode.containerOpen = true;
+  do_check_eq(dayNode.childCount, 4);
+
+  // But URLs are now sorted by title descending
+  visit1 = dayNode.getChild(0);
+  do_check_eq(visit1.uri, "http://mirror0.mozilla.com/b");
+
+  visit2 = dayNode.getChild(3);
+  do_check_eq(visit2.uri, "http://mirror0.google.com/a");
+
+  dayNode.containerOpen = false;
+  root.containerOpen = false;
+}
+
+/**
+ * Queries history grouped by site, checking containers' labels and children.
+ */
+function test_RESULTS_AS_SITE_QUERY() {
+  print("\n\n*** TEST RESULTS_AS_SITE_QUERY\n");
+  // add a bookmark with a domain not in the set of visits in the db
+  var itemId = bs.insertBookmark(bs.toolbarFolder, uri("http://foobar"),
+                                 bs.DEFAULT_INDEX, "");
+
+  var options = hs.getNewQueryOptions();
+  options.resultType = options.RESULTS_AS_SITE_QUERY;
+  options.sortingMode = options.SORT_BY_TITLE_ASCENDING;
+  var query = hs.getNewQuery();
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, containers.length * 2);
+
+/* Expected results:
+    "mirror0.google.com",
+    "mirror0.mozilla.com",
+    "mirror1.google.com",
+    "mirror1.mozilla.com",
+    "mirror2.google.com",
+    "mirror2.mozilla.com",
+    "mirror3.google.com",  <== We check for this site (index 6)
+    "mirror3.mozilla.com",
+    "mirror4.google.com",
+    "mirror4.mozilla.com",
+    "mirror5.google.com",
+    "mirror5.mozilla.com",
+    ...
+*/
+
+  // Items should be sorted by host
+  var siteNode = root.getChild(6)
+                     .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(siteNode.title, "mirror3.google.com");
+
+  siteNode.containerOpen = true;
+  do_check_eq(siteNode.childCount, 2);
+
+  // Inside of host sites are sorted by title
+  var visitNode = siteNode.getChild(0);
+  do_check_eq(visitNode.uri, "http://mirror3.google.com/a");
+
+  // Bug 473157: changing sorting mode should not affect the containers
+  result.sortingMode = options.SORT_BY_TITLE_DESCENDING;
+  siteNode = root.getChild(6)
+                     .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  do_check_eq(siteNode.title, "mirror3.google.com");
+
+  siteNode.containerOpen = true;
+  do_check_eq(siteNode.childCount, 2);
+
+  // But URLs are now sorted by title descending
+  var visit = siteNode.getChild(0);
+  do_check_eq(visit.uri, "http://mirror3.google.com/b");
+
+  siteNode.containerOpen = false;
+  root.containerOpen = false;
+
+  // Cleanup.
+  bs.removeItem(itemId);
+}
+
+/**
+ * Checks that queries grouped by date do liveupdate correctly.
+ */
+function* task_test_date_liveupdate(aResultType) {
+  var midnight = nowObj;
+  midnight.setHours(0);
+  midnight.setMinutes(0);
+  midnight.setSeconds(0);
+  midnight.setMilliseconds(0);
+
+  // TEST 1. Test that the query correctly updates when it is root.
+  var options = hs.getNewQueryOptions();
+  options.resultType = aResultType;
+  var query = hs.getNewQuery();
+  var result = hs.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+
+  do_check_eq(root.childCount, visibleContainers.length);
+  // Remove "Today".
+  hs.removePagesByTimeframe(midnight.getTime() * 1000, Date.now() * 1000);
+  do_check_eq(root.childCount, visibleContainers.length - 1);
+
+  // Open "Last 7 days" container, this way we will have a container accepting
+  // the new visit, but we should still add back "Today" container.
+  var last7Days = root.getChild(1)
+                      .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  last7Days.containerOpen = true;
+
+  // Add a visit for "Today".  This should add back the missing "Today"
+  // container.
+  yield task_add_normalized_visit(uri("http://www.mozilla.org/"), nowObj.getTime(), 0);
+  do_check_eq(root.childCount, visibleContainers.length);
+
+  last7Days.containerOpen = false;
+  root.containerOpen = false;
+
+  // TEST 2. Test that the query correctly updates even if it is not root.
+  var itemId = bs.insertBookmark(bs.toolbarFolder,
+                                 uri("place:type=" + aResultType),
+                                 bs.DEFAULT_INDEX, "");
+
+  // Query toolbar and open our query container, then check again liveupdate.
+  options = hs.getNewQueryOptions();
+  query = hs.getNewQuery();
+  query.setFolders([bs.toolbarFolder], 1);
+  result = hs.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 1);
+  var dateContainer = root.getChild(0).QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  dateContainer.containerOpen = true;
+
+  do_check_eq(dateContainer.childCount, visibleContainers.length);
+  // Remove "Today".
+  hs.removePagesByTimeframe(midnight.getTime() * 1000, Date.now() * 1000);
+  do_check_eq(dateContainer.childCount, visibleContainers.length - 1);
+  // Add a visit for "Today".
+  yield task_add_normalized_visit(uri("http://www.mozilla.org/"), nowObj.getTime(), 0);
+  do_check_eq(dateContainer.childCount, visibleContainers.length);
+
+  dateContainer.containerOpen = false;
+  root.containerOpen = false;
+
+  // Cleanup.
+  bs.removeItem(itemId);
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_history_sidebar()
+{
+  // If we're dangerously close to a date change, just bail out.
+  if (nowObj.getHours() == 23 && nowObj.getMinutes() >= 50) {
+    return;
+  }
+
+  yield task_fill_history();
+  test_RESULTS_AS_DATE_SITE_QUERY();
+  test_RESULTS_AS_DATE_QUERY();
+  test_RESULTS_AS_SITE_QUERY();
+
+  yield task_test_date_liveupdate(Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY);
+  yield task_test_date_liveupdate(Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY);
+
+  // The remaining views are
+  //   RESULTS_AS_URI + SORT_BY_VISITCOUNT_DESCENDING
+  //   ->  test_399266.js
+  //   RESULTS_AS_URI + SORT_BY_DATE_DESCENDING
+  //   ->  test_385397.js
+});
diff --git a/toolkit/components/places/tests/unit/test_hosts_triggers.js b/toolkit/components/places/tests/unit/test_hosts_triggers.js
new file mode 100644
index 000000000..9c3359e76
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_hosts_triggers.js
@@ -0,0 +1,226 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests the validity of various triggers that add remove hosts from moz_hosts
+ */
+
+XPCOMUtils.defineLazyServiceGetter(this, "gHistory",
+                                   "@mozilla.org/browser/history;1",
+                                   "mozIAsyncHistory");
+
+// add some visits and remove them, add a bookmark,
+// change its uri, then remove it, and
+// for each change check that moz_hosts has correctly been updated.
+
+function isHostInMozPlaces(aURI)
+{
+  let stmt = DBConn().createStatement(
+    `SELECT url
+       FROM moz_places
+       WHERE url_hash = hash(:host) AND url = :host`
+  );
+  let result = false;
+  stmt.params.host = aURI.spec;
+  while (stmt.executeStep()) {
+    if (stmt.row.url == aURI.spec) {
+      result = true;
+      break;
+    }
+  }
+  stmt.finalize();
+  return result;
+}
+
+function isHostInMozHosts(aURI, aTyped, aPrefix)
+{
+  let stmt = DBConn().createStatement(
+    `SELECT host, typed, prefix
+       FROM moz_hosts
+       WHERE host = fixup_url(:host)
+       AND frecency NOTNULL`
+  );
+  let result = false;
+  stmt.params.host = aURI.host;
+  if (stmt.executeStep()) {
+    result = aTyped == stmt.row.typed && aPrefix == stmt.row.prefix;
+  }
+  stmt.finalize();
+  return result;
+}
+
+var urls = [{uri: NetUtil.newURI("http://visit1.mozilla.org"),
+             expected: "visit1.mozilla.org",
+             typed: 0,
+             prefix: null
+            },
+            {uri: NetUtil.newURI("http://visit2.mozilla.org"),
+             expected: "visit2.mozilla.org",
+             typed: 0,
+             prefix: null
+            },
+            {uri: NetUtil.newURI("http://www.foo.mozilla.org"),
+             expected: "foo.mozilla.org",
+             typed: 1,
+             prefix: "www."
+            },
+           ];
+
+const NEW_URL = "http://different.mozilla.org/";
+
+add_task(function* test_moz_hosts_update()
+{
+  let places = [];
+  urls.forEach(function(url) {
+    let place = { uri: url.uri,
+                  title: "test for " + url.url,
+                  transition: url.typed ? TRANSITION_TYPED : undefined };
+    places.push(place);
+  });
+
+  yield PlacesTestUtils.addVisits(places);
+
+  do_check_true(isHostInMozHosts(urls[0].uri, urls[0].typed, urls[0].prefix));
+  do_check_true(isHostInMozHosts(urls[1].uri, urls[1].typed, urls[1].prefix));
+  do_check_true(isHostInMozHosts(urls[2].uri, urls[2].typed, urls[2].prefix));
+});
+
+add_task(function* test_remove_places()
+{
+  for (let idx in urls) {
+    PlacesUtils.history.removePage(urls[idx].uri);
+  }
+
+  yield PlacesTestUtils.clearHistory();
+
+  for (let idx in urls) {
+    do_check_false(isHostInMozHosts(urls[idx].uri, urls[idx].typed, urls[idx].prefix));
+  }
+});
+
+add_task(function* test_bookmark_changes()
+{
+  let testUri = NetUtil.newURI("http://test.mozilla.org");
+
+  let itemId = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                                                     testUri,
+                                                     PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                     "bookmark title");
+
+  do_check_true(isHostInMozPlaces(testUri));
+
+  // Change the hostname
+  PlacesUtils.bookmarks.changeBookmarkURI(itemId, NetUtil.newURI(NEW_URL));
+
+  yield PlacesTestUtils.clearHistory();
+
+  let newUri = NetUtil.newURI(NEW_URL);
+  do_check_true(isHostInMozPlaces(newUri));
+  do_check_true(isHostInMozHosts(newUri, false, null));
+  do_check_false(isHostInMozHosts(NetUtil.newURI("http://test.mozilla.org"), false, null));
+});
+
+add_task(function* test_bookmark_removal()
+{
+  let itemId = PlacesUtils.bookmarks.getIdForItemAt(PlacesUtils.unfiledBookmarksFolderId,
+                                                    PlacesUtils.bookmarks.DEFAULT_INDEX);
+  let newUri = NetUtil.newURI(NEW_URL);
+  PlacesUtils.bookmarks.removeItem(itemId);
+  yield PlacesTestUtils.clearHistory();
+
+  do_check_false(isHostInMozHosts(newUri, false, null));
+});
+
+add_task(function* test_moz_hosts_typed_update()
+{
+  const TEST_URI = NetUtil.newURI("http://typed.mozilla.com");
+  let places = [{ uri: TEST_URI
+                , title: "test for " + TEST_URI.spec
+                },
+                { uri: TEST_URI
+                , title: "test for " + TEST_URI.spec
+                , transition: TRANSITION_TYPED
+                }];
+
+  yield PlacesTestUtils.addVisits(places);
+
+  do_check_true(isHostInMozHosts(TEST_URI, true, null));
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_moz_hosts_www_remove()
+{
+  function* test_removal(aURIToRemove, aURIToKeep, aCallback) {
+    let places = [{ uri: aURIToRemove
+                  , title: "test for " + aURIToRemove.spec
+                  , transition: TRANSITION_TYPED
+                  },
+                  { uri: aURIToKeep
+                  , title: "test for " + aURIToKeep.spec
+                  , transition: TRANSITION_TYPED
+                  }];
+
+    yield PlacesTestUtils.addVisits(places);
+    print("removing " + aURIToRemove.spec + " keeping " + aURIToKeep);
+    dump_table("moz_hosts");
+    dump_table("moz_places");
+    PlacesUtils.history.removePage(aURIToRemove);
+    let prefix = /www/.test(aURIToKeep.spec) ? "www." : null;
+    dump_table("moz_hosts");
+    dump_table("moz_places");
+    do_check_true(isHostInMozHosts(aURIToKeep, true, prefix));
+  }
+
+  const TEST_URI = NetUtil.newURI("http://rem.mozilla.com");
+  const TEST_WWW_URI = NetUtil.newURI("http://www.rem.mozilla.com");
+  yield test_removal(TEST_URI, TEST_WWW_URI);
+  yield test_removal(TEST_WWW_URI, TEST_URI);
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_moz_hosts_ftp_matchall()
+{
+  const TEST_URI_1 = NetUtil.newURI("ftp://www.mozilla.com/");
+  const TEST_URI_2 = NetUtil.newURI("ftp://mozilla.com/");
+
+  yield PlacesTestUtils.addVisits([
+    { uri: TEST_URI_1, transition: TRANSITION_TYPED },
+    { uri: TEST_URI_2, transition: TRANSITION_TYPED }
+  ]);
+
+  do_check_true(isHostInMozHosts(TEST_URI_1, true, "ftp://"));
+});
+
+add_task(function* test_moz_hosts_ftp_not_matchall()
+{
+  const TEST_URI_1 = NetUtil.newURI("http://mozilla.com/");
+  const TEST_URI_2 = NetUtil.newURI("ftp://mozilla.com/");
+
+  yield PlacesTestUtils.addVisits([
+    { uri: TEST_URI_1, transition: TRANSITION_TYPED },
+    { uri: TEST_URI_2, transition: TRANSITION_TYPED }
+  ]);
+
+  do_check_true(isHostInMozHosts(TEST_URI_1, true, null));
+});
+
+add_task(function* test_moz_hosts_update_2()
+{
+  // Check that updating trigger takes into account prefixes for different
+  // rev_hosts.
+  const TEST_URI_1 = NetUtil.newURI("https://www.google.it/");
+  const TEST_URI_2 = NetUtil.newURI("https://google.it/");
+  let places = [{ uri: TEST_URI_1
+                , transition: TRANSITION_TYPED
+                },
+                { uri: TEST_URI_2
+                }];
+  yield PlacesTestUtils.addVisits(places);
+
+  do_check_true(isHostInMozHosts(TEST_URI_1, true, "https://www."));
+});
+
+function run_test()
+{
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_import_mobile_bookmarks.js b/toolkit/components/places/tests/unit/test_import_mobile_bookmarks.js
new file mode 100644
index 000000000..771a6ac17
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_import_mobile_bookmarks.js
@@ -0,0 +1,292 @@
+function* importFromFixture(fixture, replace) {
+  let cwd = yield OS.File.getCurrentDirectory();
+  let path = OS.Path.join(cwd, fixture);
+
+  do_print(`Importing from ${path}`);
+  yield BookmarkJSONUtils.importFromFile(path, replace);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+}
+
+function* treeEquals(guid, expected, message) {
+  let root = yield PlacesUtils.promiseBookmarksTree(guid);
+  let bookmarks = (function nodeToEntry(node) {
+    let entry = { guid: node.guid, index: node.index }
+    if (node.children) {
+      entry.children = node.children.map(nodeToEntry);
+    }
+    if (node.annos) {
+      entry.annos = node.annos;
+    }
+    return entry;
+  }(root));
+
+  do_print(`Checking if ${guid} tree matches ${JSON.stringify(expected)}`);
+  do_print(`Got bookmarks tree for ${guid}: ${JSON.stringify(bookmarks)}`);
+
+  deepEqual(bookmarks, expected, message);
+}
+
+add_task(function* test_restore_mobile_bookmarks_root() {
+  yield* importFromFixture("mobile_bookmarks_root_import.json",
+                           /* replace */ true);
+
+  yield* treeEquals(PlacesUtils.bookmarks.rootGuid, {
+    guid: PlacesUtils.bookmarks.rootGuid,
+    index: 0,
+    children: [{
+      guid: PlacesUtils.bookmarks.menuGuid,
+      index: 0,
+      children: [
+        { guid: "X6lUyOspVYwi", index: 0 },
+      ],
+    }, {
+      guid: PlacesUtils.bookmarks.toolbarGuid,
+      index: 1,
+    }, {
+      guid: PlacesUtils.bookmarks.unfiledGuid,
+      index: 3,
+    }, {
+      guid: PlacesUtils.bookmarks.mobileGuid,
+      index: 4,
+      annos: [{
+        name: "mobile/bookmarksRoot",
+        flags: 0,
+        expires: 4,
+        value: 1,
+      }],
+      children: [
+        { guid: "_o8e1_zxTJFg", index: 0 },
+        { guid: "QCtSqkVYUbXB", index: 1 },
+      ],
+    }],
+  }, "Should restore mobile bookmarks from root");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_import_mobile_bookmarks_root() {
+  yield* importFromFixture("mobile_bookmarks_root_import.json",
+                           /* replace */ false);
+  yield* importFromFixture("mobile_bookmarks_root_merge.json",
+                           /* replace */ false);
+
+  yield* treeEquals(PlacesUtils.bookmarks.rootGuid, {
+    guid: PlacesUtils.bookmarks.rootGuid,
+    index: 0,
+    children: [{
+      guid: PlacesUtils.bookmarks.menuGuid,
+      index: 0,
+      children: [
+        { guid: "Utodo9b0oVws", index: 0 },
+        { guid: "X6lUyOspVYwi", index: 1 },
+      ],
+    }, {
+      guid: PlacesUtils.bookmarks.toolbarGuid,
+      index: 1,
+    }, {
+      guid: PlacesUtils.bookmarks.unfiledGuid,
+      index: 3,
+    }, {
+      guid: PlacesUtils.bookmarks.mobileGuid,
+      index: 4,
+      annos: [{
+        name: "mobile/bookmarksRoot",
+        flags: 0,
+        expires: 4,
+        value: 1,
+      }],
+      children: [
+        { guid: "a17yW6-nTxEJ", index: 0 },
+        { guid: "xV10h9Wi3FBM", index: 1 },
+        { guid: "_o8e1_zxTJFg", index: 2 },
+        { guid: "QCtSqkVYUbXB", index: 3 },
+      ],
+    }],
+  }, "Should merge bookmarks root contents");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_restore_mobile_bookmarks_folder() {
+  yield* importFromFixture("mobile_bookmarks_folder_import.json",
+                           /* replace */ true);
+
+  yield* treeEquals(PlacesUtils.bookmarks.rootGuid, {
+    guid: PlacesUtils.bookmarks.rootGuid,
+    index: 0,
+    children: [{
+      guid: PlacesUtils.bookmarks.menuGuid,
+      index: 0,
+      children: [
+        { guid: "X6lUyOspVYwi", index: 0 },
+        { guid: "XF4yRP6bTuil", index: 1 },
+      ],
+    }, {
+      guid: PlacesUtils.bookmarks.toolbarGuid,
+      index: 1,
+      children: [{ guid: "buy7711R3ZgE", index: 0 }],
+    }, {
+      guid: PlacesUtils.bookmarks.unfiledGuid,
+      index: 3,
+      children: [{ guid: "KIa9iKZab2Z5", index: 0 }],
+    }, {
+      guid: PlacesUtils.bookmarks.mobileGuid,
+      index: 4,
+      annos: [{
+        name: "mobile/bookmarksRoot",
+        flags: 0,
+        expires: 4,
+        value: 1,
+      }],
+      children: [
+        { guid: "_o8e1_zxTJFg", index: 0 },
+        { guid: "QCtSqkVYUbXB", index: 1 },
+      ],
+    }],
+  }, "Should restore mobile bookmark folder contents into mobile root");
+
+  // We rewrite queries to point to the root ID instead of the name
+  // ("MOBILE_BOOKMARKS") so that we don't break them if the user downgrades
+  // to an earlier release channel. This can be removed along with the anno in
+  // bug 1306445.
+  let queryById = yield PlacesUtils.bookmarks.fetch("XF4yRP6bTuil");
+  equal(queryById.url.href, "place:folder=" + PlacesUtils.mobileFolderId,
+    "Should rewrite mobile query to point to root ID");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_import_mobile_bookmarks_folder() {
+  yield* importFromFixture("mobile_bookmarks_folder_import.json",
+                           /* replace */ false);
+  yield* importFromFixture("mobile_bookmarks_folder_merge.json",
+                           /* replace */ false);
+
+  yield* treeEquals(PlacesUtils.bookmarks.rootGuid, {
+    guid: PlacesUtils.bookmarks.rootGuid,
+    index: 0,
+    children: [{
+      guid: PlacesUtils.bookmarks.menuGuid,
+      index: 0,
+      children: [
+        { guid: "Utodo9b0oVws", index: 0 },
+        { guid: "X6lUyOspVYwi", index: 1 },
+        { guid: "XF4yRP6bTuil", index: 2 },
+      ],
+    }, {
+      guid: PlacesUtils.bookmarks.toolbarGuid,
+      index: 1,
+      children: [{ guid: "buy7711R3ZgE", index: 0 }],
+    }, {
+      guid: PlacesUtils.bookmarks.unfiledGuid,
+      index: 3,
+      children: [{ guid: "KIa9iKZab2Z5", index: 0 }],
+    }, {
+      guid: PlacesUtils.bookmarks.mobileGuid,
+      index: 4,
+      annos: [{
+        name: "mobile/bookmarksRoot",
+        flags: 0,
+        expires: 4,
+        value: 1,
+      }],
+      children: [
+        { guid: "a17yW6-nTxEJ", index: 0 },
+        { guid: "xV10h9Wi3FBM", index: 1 },
+        { guid: "_o8e1_zxTJFg", index: 2 },
+        { guid: "QCtSqkVYUbXB", index: 3 },
+      ],
+    }],
+  }, "Should merge bookmarks folder contents into mobile root");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_restore_multiple_bookmarks_folders() {
+  yield* importFromFixture("mobile_bookmarks_multiple_folders.json",
+                           /* replace */ true);
+
+  yield* treeEquals(PlacesUtils.bookmarks.rootGuid, {
+    guid: PlacesUtils.bookmarks.rootGuid,
+    index: 0,
+    children: [{
+      guid: PlacesUtils.bookmarks.menuGuid,
+      index: 0,
+      children: [
+        { guid: "buy7711R3ZgE", index: 0 },
+        { guid: "F_LBgd1fS_uQ", index: 1 },
+        { guid: "oIpmQXMWsXvY", index: 2 },
+      ],
+    }, {
+      guid: PlacesUtils.bookmarks.toolbarGuid,
+      index: 1,
+      children: [{ guid: "Utodo9b0oVws", index: 0 }],
+    }, {
+      guid: PlacesUtils.bookmarks.unfiledGuid,
+      index: 3,
+      children: [{ guid: "xV10h9Wi3FBM", index: 0 }],
+    }, {
+      guid: PlacesUtils.bookmarks.mobileGuid,
+      index: 4,
+      annos: [{
+        name: "mobile/bookmarksRoot",
+        flags: 0,
+        expires: 4,
+        value: 1,
+      }],
+      children: [
+        { guid: "sSZ86WT9WbN3", index: 0 },
+        { guid: "a17yW6-nTxEJ", index: 1 },
+      ],
+    }],
+  }, "Should restore multiple bookmarks folder contents into root");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_import_multiple_bookmarks_folders() {
+  yield* importFromFixture("mobile_bookmarks_root_import.json",
+                           /* replace */ false);
+  yield* importFromFixture("mobile_bookmarks_multiple_folders.json",
+                           /* replace */ false);
+
+  yield* treeEquals(PlacesUtils.bookmarks.rootGuid, {
+    guid: PlacesUtils.bookmarks.rootGuid,
+    index: 0,
+    children: [{
+      guid: PlacesUtils.bookmarks.menuGuid,
+      index: 0,
+      children: [
+        { guid: "buy7711R3ZgE", index: 0 },
+        { guid: "F_LBgd1fS_uQ", index: 1 },
+        { guid: "oIpmQXMWsXvY", index: 2 },
+        { guid: "X6lUyOspVYwi", index: 3 },
+      ],
+    }, {
+      guid: PlacesUtils.bookmarks.toolbarGuid,
+      index: 1,
+      children: [{ guid: "Utodo9b0oVws", index: 0 }],
+    }, {
+      guid: PlacesUtils.bookmarks.unfiledGuid,
+      index: 3,
+      children: [{ guid: "xV10h9Wi3FBM", index: 0 }],
+    }, {
+      guid: PlacesUtils.bookmarks.mobileGuid,
+      index: 4,
+      annos: [{
+        name: "mobile/bookmarksRoot",
+        flags: 0,
+        expires: 4,
+        value: 1,
+      }],
+      children: [
+        { guid: "sSZ86WT9WbN3", index: 0 },
+        { guid: "a17yW6-nTxEJ", index: 1 },
+        { guid: "_o8e1_zxTJFg", index: 2 },
+        { guid: "QCtSqkVYUbXB", index: 3 },
+      ],
+    }],
+  }, "Should merge multiple mobile folders into root");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
diff --git a/toolkit/components/places/tests/unit/test_isPageInDB.js b/toolkit/components/places/tests/unit/test_isPageInDB.js
new file mode 100644
index 000000000..249853fa9
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_isPageInDB.js
@@ -0,0 +1,10 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+
+add_task(function* test_execute() {
+  var good_uri = uri("http://mozilla.com");
+  var bad_uri = uri("http://google.com");
+  yield PlacesTestUtils.addVisits({uri: good_uri});
+  do_check_true(yield PlacesTestUtils.isPageInDB(good_uri));
+  do_check_false(yield PlacesTestUtils.isPageInDB(bad_uri));
+});
diff --git a/toolkit/components/places/tests/unit/test_isURIVisited.js b/toolkit/components/places/tests/unit/test_isURIVisited.js
new file mode 100644
index 000000000..93c010e83
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_isURIVisited.js
@@ -0,0 +1,84 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Tests functionality of the isURIVisited API.
+
+const SCHEMES = {
+  "http://": true,
+  "https://": true,
+  "ftp://": true,
+  "file:///": true,
+  "about:": false,
+// nsIIOService.newURI() can throw if e.g. the app knows about imap://
+// but the account is not set up and so the URL is invalid for it.
+//  "imap://": false,
+  "news://": false,
+  "mailbox:": false,
+  "moz-anno:favicon:http://": false,
+  "view-source:http://": false,
+  "chrome://browser/content/browser.xul?": false,
+  "resource://": false,
+  "data:,": false,
+  "wyciwyg:/0/http://": false,
+  "javascript:": false,
+};
+
+var gRunner;
+function run_test()
+{
+  do_test_pending();
+  gRunner = step();
+  gRunner.next();
+}
+
+function* step()
+{
+  let history = Cc["@mozilla.org/browser/history;1"]
+                  .getService(Ci.mozIAsyncHistory);
+
+  for (let scheme in SCHEMES) {
+    do_print("Testing scheme " + scheme);
+    for (let t in PlacesUtils.history.TRANSITIONS) {
+      do_print("With transition " + t);
+      let transition = PlacesUtils.history.TRANSITIONS[t];
+
+      let uri = NetUtil.newURI(scheme + "mozilla.org/");
+
+      history.isURIVisited(uri, function(aURI, aIsVisited) {
+        do_check_true(uri.equals(aURI));
+        do_check_false(aIsVisited);
+
+        let callback = {
+          handleError:  function () {},
+          handleResult: function () {},
+          handleCompletion: function () {
+            do_print("Added visit to " + uri.spec);
+
+            history.isURIVisited(uri, function (aURI2, aIsVisited2) {
+              do_check_true(uri.equals(aURI2));
+              let checker = SCHEMES[scheme] ? do_check_true : do_check_false;
+              checker(aIsVisited2);
+
+              PlacesTestUtils.clearHistory().then(function () {
+                history.isURIVisited(uri, function(aURI3, aIsVisited3) {
+                  do_check_true(uri.equals(aURI3));
+                  do_check_false(aIsVisited3);
+                  gRunner.next();
+                });
+              });
+            });
+          },
+        };
+
+        history.updatePlaces({ uri:    uri
+                             , visits: [ { transitionType: transition
+                                         , visitDate:      Date.now() * 1000
+                                         } ]
+                             }, callback);
+      });
+      yield undefined;
+    }
+  }
+
+  do_test_finished();
+}
diff --git a/toolkit/components/places/tests/unit/test_isvisited.js b/toolkit/components/places/tests/unit/test_isvisited.js
new file mode 100644
index 000000000..d7bcc2851
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_isvisited.js
@@ -0,0 +1,75 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  var referrer = uri("about:blank");
+
+  // add a http:// uri
+  var uri1 = uri("http://mozilla.com");
+  yield PlacesTestUtils.addVisits({uri: uri1, referrer: referrer});
+  do_check_guid_for_uri(uri1);
+  do_check_true(yield promiseIsURIVisited(uri1));
+
+  // add a https:// uri
+  var uri2 = uri("https://etrade.com");
+  yield PlacesTestUtils.addVisits({uri: uri2, referrer: referrer});
+  do_check_guid_for_uri(uri2);
+  do_check_true(yield promiseIsURIVisited(uri2));
+
+  // add a ftp:// uri
+  var uri3 = uri("ftp://ftp.mozilla.org");
+  yield PlacesTestUtils.addVisits({uri: uri3, referrer: referrer});
+  do_check_guid_for_uri(uri3);
+  do_check_true(yield promiseIsURIVisited(uri3));
+
+  // check if a nonexistent uri is visited
+  var uri4 = uri("http://foobarcheese.com");
+  do_check_false(yield promiseIsURIVisited(uri4));
+
+  // check that certain schemes never show up as visited
+  // even if we attempt to add them to history
+  // see CanAddURI() in nsNavHistory.cpp
+  const URLS = [
+    "about:config",
+    "imap://cyrus.andrew.cmu.edu/archive.imap",
+    "news://new.mozilla.org/mozilla.dev.apps.firefox",
+    "mailbox:Inbox",
+    "moz-anno:favicon:http://mozilla.org/made-up-favicon",
+    "view-source:http://mozilla.org",
+    "chrome://browser/content/browser.xul",
+    "resource://gre-resources/hiddenWindow.html",
+    "data:,Hello%2C%20World!",
+    "wyciwyg:/0/http://mozilla.org",
+    "javascript:alert('hello wolrd!');",
+    "http://localhost/" + "a".repeat(1984),
+  ];
+  for (let currentURL of URLS) {
+    try {
+      var cantAddUri = uri(currentURL);
+    }
+    catch (e) {
+      // nsIIOService.newURI() can throw if e.g. our app knows about imap://
+      // but the account is not set up and so the URL is invalid for us.
+      // Note this in the log but ignore as it's not the subject of this test.
+      do_print("Could not construct URI for '" + currentURL + "'; ignoring");
+    }
+    if (cantAddUri) {
+      PlacesTestUtils.addVisits({uri: cantAddUri, referrer: referrer}).then(() => {
+        do_throw("Should not have added history for invalid URI.");
+      }, error => {
+        do_check_true(error.message.includes("No items were added to history"));
+      });
+      do_check_false(yield promiseIsURIVisited(cantAddUri));
+    }
+  }
+});
+
diff --git a/toolkit/components/places/tests/unit/test_keywords.js b/toolkit/components/places/tests/unit/test_keywords.js
new file mode 100644
index 000000000..57b734c5d
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_keywords.js
@@ -0,0 +1,548 @@
+"use strict"
+
+function* check_keyword(aExpectExists, aHref, aKeyword, aPostData = null) {
+  // Check case-insensitivity.
+  aKeyword = aKeyword.toUpperCase();
+
+  let entry = yield PlacesUtils.keywords.fetch(aKeyword);
+
+  Assert.deepEqual(entry, yield PlacesUtils.keywords.fetch({ keyword: aKeyword }));
+
+  if (aExpectExists) {
+    Assert.ok(!!entry, "A keyword should exist");
+    Assert.equal(entry.url.href, aHref);
+    Assert.equal(entry.postData, aPostData);
+    Assert.deepEqual(entry, yield PlacesUtils.keywords.fetch({ keyword: aKeyword, url: aHref }));
+    let entries = [];
+    yield PlacesUtils.keywords.fetch({ url: aHref }, e => entries.push(e));
+    Assert.ok(entries.some(e => e.url.href == aHref && e.keyword == aKeyword.toLowerCase()));
+  } else {
+    Assert.ok(!entry || entry.url.href != aHref,
+              "The given keyword entry should not exist");
+    Assert.equal(null, yield PlacesUtils.keywords.fetch({ keyword: aKeyword, url: aHref }));
+  }
+}
+
+/**
+ * Polls the keywords cache waiting for the given keyword entry.
+ */
+function* promiseKeyword(keyword, expectedHref) {
+  let href = null;
+  do {
+    yield new Promise(resolve => do_timeout(100, resolve));
+    let entry = yield PlacesUtils.keywords.fetch(keyword);
+    if (entry)
+      href = entry.url.href;
+  } while (href != expectedHref);
+}
+
+function* check_no_orphans() {
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.executeCached(
+    `SELECT id FROM moz_keywords k
+     WHERE NOT EXISTS (SELECT 1 FROM moz_places WHERE id = k.place_id)
+    `);
+  Assert.equal(rows.length, 0);
+}
+
+function expectBookmarkNotifications() {
+  let notifications = [];
+  let observer = new Proxy(NavBookmarkObserver, {
+    get(target, name) {
+      if (name == "check") {
+        PlacesUtils.bookmarks.removeObserver(observer);
+        return expectedNotifications =>
+          Assert.deepEqual(notifications, expectedNotifications);
+      }
+
+      if (name.startsWith("onItemChanged")) {
+        return function(itemId, property) {
+          if (property != "keyword")
+            return;
+          let args = Array.from(arguments, arg => {
+            if (arg && arg instanceof Ci.nsIURI)
+              return new URL(arg.spec);
+            if (arg && typeof(arg) == "number" && arg >= Date.now() * 1000)
+              return new Date(parseInt(arg/1000));
+            return arg;
+          });
+          notifications.push({ name: name, arguments: args });
+        }
+      }
+
+      if (name in target)
+        return target[name];
+      return undefined;
+    }
+  });
+  PlacesUtils.bookmarks.addObserver(observer, false);
+  return observer;
+}
+
+add_task(function* test_invalid_input() {
+  Assert.throws(() => PlacesUtils.keywords.fetch(null),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.fetch(5),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.fetch(undefined),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({ keyword: null }),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({ keyword: {} }),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({ keyword: 5 }),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({}),
+                /At least keyword or url must be provided/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({ keyword: "test" }, "test"),
+                /onResult callback must be a valid function/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({ url: "test" }),
+                /is not a valid URL/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({ url: {} }),
+                /is not a valid URL/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({ url: null }),
+                /is not a valid URL/);
+  Assert.throws(() => PlacesUtils.keywords.fetch({ url: "" }),
+                /is not a valid URL/);
+
+  Assert.throws(() => PlacesUtils.keywords.insert(null),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.keywords.insert("test"),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.keywords.insert(undefined),
+                /Input should be a valid object/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ }),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: null }),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: 5 }),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: "" }),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: "test", postData: 5 }),
+                /Invalid POST data/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: "test", postData: {} }),
+                /Invalid POST data/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: "test" }),
+                /is not a valid URL/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: "test", url: 5 }),
+                /is not a valid URL/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: "test", url: "" }),
+                /is not a valid URL/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: "test", url: null }),
+                /is not a valid URL/);
+  Assert.throws(() => PlacesUtils.keywords.insert({ keyword: "test", url: "mozilla" }),
+                /is not a valid URL/);
+
+  Assert.throws(() => PlacesUtils.keywords.remove(null),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.remove(""),
+                /Invalid keyword/);
+  Assert.throws(() => PlacesUtils.keywords.remove(5),
+                /Invalid keyword/);
+});
+
+add_task(function* test_addKeyword() {
+  yield check_keyword(false, "http://example.com/", "keyword");
+  let fc = yield foreign_count("http://example.com/");
+  let observer = expectBookmarkNotifications();
+
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com/" });
+  observer.check([]);
+
+  yield check_keyword(true, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 1); // +1 keyword
+
+  // Now remove the keyword.
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.remove("keyword");
+  observer.check([]);
+
+  yield check_keyword(false, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc); // -1 keyword
+
+  // Check using URL.
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: new URL("http://example.com/") });
+  yield check_keyword(true, "http://example.com/", "keyword");
+  yield PlacesUtils.keywords.remove("keyword");
+  yield check_keyword(false, "http://example.com/", "keyword");
+
+  yield check_no_orphans();
+});
+
+add_task(function* test_addBookmarkAndKeyword() {
+  yield check_keyword(false, "http://example.com/", "keyword");
+  let fc = yield foreign_count("http://example.com/");
+  let bookmark = yield PlacesUtils.bookmarks.insert({ url: "http://example.com/",
+                                                      type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                      parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+
+  let observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com/" });
+
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark.guid)),
+                                 "keyword", false, "keyword",
+                                 bookmark.lastModified, bookmark.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark.parentGuid)),
+                                 bookmark.guid, bookmark.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+
+  yield check_keyword(true, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 2); // +1 bookmark +1 keyword
+
+  // Now remove the keyword.
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.remove("keyword");
+
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark.guid)),
+                                 "keyword", false, "",
+                                 bookmark.lastModified, bookmark.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark.parentGuid)),
+                                 bookmark.guid, bookmark.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+
+  yield check_keyword(false, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 1); // -1 keyword
+
+  // Add again the keyword, then remove the bookmark.
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com/" });
+
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.bookmarks.remove(bookmark.guid);
+  // the notification is synchronous but the removal process is async.
+  // Unfortunately there's nothing explicit we can wait for.
+  while ((yield foreign_count("http://example.com/")));
+  // We don't get any itemChanged notification since the bookmark has been
+  // removed already.
+  observer.check([]);
+
+  yield check_keyword(false, "http://example.com/", "keyword");
+
+  yield check_no_orphans();
+});
+
+add_task(function* test_addKeywordToURIHavingKeyword() {
+  yield check_keyword(false, "http://example.com/", "keyword");
+  let fc = yield foreign_count("http://example.com/");
+
+  let observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com/" });
+  observer.check([]);
+
+  yield check_keyword(true, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 1); // +1 keyword
+
+  yield PlacesUtils.keywords.insert({ keyword: "keyword2", url: "http://example.com/" });
+
+  yield check_keyword(true, "http://example.com/", "keyword");
+  yield check_keyword(true, "http://example.com/", "keyword2");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 2); // +1 keyword
+  let entries = [];
+  let entry = yield PlacesUtils.keywords.fetch({ url: "http://example.com/" }, e => entries.push(e));
+  Assert.equal(entries.length, 2);
+  Assert.deepEqual(entries[0], entry);
+
+  // Now remove the keywords.
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.remove("keyword");
+  yield PlacesUtils.keywords.remove("keyword2");
+  observer.check([]);
+
+  yield check_keyword(false, "http://example.com/", "keyword");
+  yield check_keyword(false, "http://example.com/", "keyword2");
+  Assert.equal((yield foreign_count("http://example.com/")), fc); // -1 keyword
+
+  yield check_no_orphans();
+});
+
+add_task(function* test_addBookmarkToURIHavingKeyword() {
+  yield check_keyword(false, "http://example.com/", "keyword");
+  let fc = yield foreign_count("http://example.com/");
+  let observer = expectBookmarkNotifications();
+
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com/" });
+  observer.check([]);
+
+  yield check_keyword(true, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 1); // +1 keyword
+
+  observer = expectBookmarkNotifications();
+  let bookmark = yield PlacesUtils.bookmarks.insert({ url: "http://example.com/",
+                                                      type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                      parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 2); // +1 bookmark
+  observer.check([]);
+
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.bookmarks.remove(bookmark.guid);
+  // the notification is synchronous but the removal process is async.
+  // Unfortunately there's nothing explicit we can wait for.
+  while ((yield foreign_count("http://example.com/")));
+  // We don't get any itemChanged notification since the bookmark has been
+  // removed already.
+  observer.check([]);
+
+  yield check_keyword(false, "http://example.com/", "keyword");
+
+  yield check_no_orphans();
+});
+
+add_task(function* test_sameKeywordDifferentURL() {
+  let fc1 = yield foreign_count("http://example1.com/");
+  let bookmark1 = yield PlacesUtils.bookmarks.insert({ url: "http://example1.com/",
+                                                       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                       parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let fc2 = yield foreign_count("http://example2.com/");
+  let bookmark2 = yield PlacesUtils.bookmarks.insert({ url: "http://example2.com/",
+                                                       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                       parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example1.com/" });
+
+  yield check_keyword(true, "http://example1.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example1.com/")), fc1 + 2); // +1 bookmark +1 keyword
+  yield check_keyword(false, "http://example2.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example2.com/")), fc2 + 1); // +1 bookmark
+
+  // Assign the same keyword to another url.
+  let observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example2.com/" });
+
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark1.guid)),
+                                 "keyword", false, "",
+                                 bookmark1.lastModified, bookmark1.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark1.parentGuid)),
+                                 bookmark1.guid, bookmark1.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                  { name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark2.guid)),
+                                 "keyword", false, "keyword",
+                                 bookmark2.lastModified, bookmark2.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark2.parentGuid)),
+                                 bookmark2.guid, bookmark2.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+
+  yield check_keyword(false, "http://example1.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example1.com/")), fc1 + 1); // -1 keyword
+  yield check_keyword(true, "http://example2.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example2.com/")), fc2 + 2); // +1 keyword
+
+  // Now remove the keyword.
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.remove("keyword");
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark2.guid)),
+                                 "keyword", false, "",
+                                 bookmark2.lastModified, bookmark2.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark2.parentGuid)),
+                                 bookmark2.guid, bookmark2.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+
+  yield check_keyword(false, "http://example1.com/", "keyword");
+  yield check_keyword(false, "http://example2.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example1.com/")), fc1 + 1);
+  Assert.equal((yield foreign_count("http://example2.com/")), fc2 + 1); // -1 keyword
+
+  yield PlacesUtils.bookmarks.remove(bookmark1);
+  yield PlacesUtils.bookmarks.remove(bookmark2);
+  Assert.equal((yield foreign_count("http://example1.com/")), fc1); // -1 bookmark
+  while ((yield foreign_count("http://example2.com/"))); // -1 keyword
+
+  yield check_no_orphans();
+});
+
+add_task(function* test_sameURIDifferentKeyword() {
+  let fc = yield foreign_count("http://example.com/");
+
+  let observer = expectBookmarkNotifications();
+  let bookmark = yield PlacesUtils.bookmarks.insert({ url: "http://example.com/",
+                                                      type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                      parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  yield PlacesUtils.keywords.insert({keyword: "keyword", url: "http://example.com/" });
+
+  yield check_keyword(true, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 2); // +1 bookmark +1 keyword
+
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark.guid)),
+                                 "keyword", false, "keyword",
+                                 bookmark.lastModified, bookmark.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark.parentGuid)),
+                                 bookmark.guid, bookmark.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.insert({ keyword: "keyword2", url: "http://example.com/" });
+  yield check_keyword(true, "http://example.com/", "keyword");
+  yield check_keyword(true, "http://example.com/", "keyword2");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 3); // +1 keyword
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark.guid)),
+                                 "keyword", false, "keyword2",
+                                 bookmark.lastModified, bookmark.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark.parentGuid)),
+                                 bookmark.guid, bookmark.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+
+  // Add a third keyword.
+  yield PlacesUtils.keywords.insert({ keyword: "keyword3", url: "http://example.com/" });
+  yield check_keyword(true, "http://example.com/", "keyword");
+  yield check_keyword(true, "http://example.com/", "keyword2");
+  yield check_keyword(true, "http://example.com/", "keyword3");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 4); // +1 keyword
+
+  // Remove one of the keywords.
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.remove("keyword");
+  yield check_keyword(false, "http://example.com/", "keyword");
+  yield check_keyword(true, "http://example.com/", "keyword2");
+  yield check_keyword(true, "http://example.com/", "keyword3");
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark.guid)),
+                                 "keyword", false, "",
+                                 bookmark.lastModified, bookmark.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark.parentGuid)),
+                                 bookmark.guid, bookmark.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 3); // -1 keyword
+
+  // Now remove the bookmark.
+  yield PlacesUtils.bookmarks.remove(bookmark);
+  while ((yield foreign_count("http://example.com/")));
+  yield check_keyword(false, "http://example.com/", "keyword");
+  yield check_keyword(false, "http://example.com/", "keyword2");
+  yield check_keyword(false, "http://example.com/", "keyword3");
+
+  check_no_orphans();
+});
+
+add_task(function* test_deleteKeywordMultipleBookmarks() {
+  let fc = yield foreign_count("http://example.com/");
+
+  let observer = expectBookmarkNotifications();
+  let bookmark1 = yield PlacesUtils.bookmarks.insert({ url: "http://example.com/",
+                                                       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                       parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  let bookmark2 = yield PlacesUtils.bookmarks.insert({ url: "http://example.com/",
+                                                       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                       parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com/" });
+
+  yield check_keyword(true, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 3); // +2 bookmark +1 keyword
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark2.guid)),
+                                 "keyword", false, "keyword",
+                                 bookmark2.lastModified, bookmark2.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark2.parentGuid)),
+                                 bookmark2.guid, bookmark2.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                  { name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark1.guid)),
+                                 "keyword", false, "keyword",
+                                 bookmark1.lastModified, bookmark1.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark1.parentGuid)),
+                                 bookmark1.guid, bookmark1.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+
+  observer = expectBookmarkNotifications();
+  yield PlacesUtils.keywords.remove("keyword");
+  yield check_keyword(false, "http://example.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example.com/")), fc + 2); // -1 keyword
+  observer.check([{ name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark2.guid)),
+                                 "keyword", false, "",
+                                 bookmark2.lastModified, bookmark2.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark2.parentGuid)),
+                                 bookmark2.guid, bookmark2.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] },
+                  { name: "onItemChanged",
+                    arguments: [ (yield PlacesUtils.promiseItemId(bookmark1.guid)),
+                                 "keyword", false, "",
+                                 bookmark1.lastModified, bookmark1.type,
+                                 (yield PlacesUtils.promiseItemId(bookmark1.parentGuid)),
+                                 bookmark1.guid, bookmark1.parentGuid, "",
+                                 Ci.nsINavBookmarksService.SOURCE_DEFAULT ] } ]);
+
+  // Now remove the bookmarks.
+  yield PlacesUtils.bookmarks.remove(bookmark1);
+  yield PlacesUtils.bookmarks.remove(bookmark2);
+  Assert.equal((yield foreign_count("http://example.com/")), fc); // -2 bookmarks
+
+  check_no_orphans();
+});
+
+add_task(function* test_multipleKeywordsSamePostData() {
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com/", postData: "postData1" });
+  yield check_keyword(true, "http://example.com/", "keyword", "postData1");
+  // Add another keyword with same postData, should fail.
+  yield Assert.rejects(PlacesUtils.keywords.insert({ keyword: "keyword2", url: "http://example.com/", postData: "postData1" }),
+                       /constraint failed/);
+  yield check_keyword(false, "http://example.com/", "keyword2", "postData1");
+
+  yield PlacesUtils.keywords.remove("keyword");
+
+  check_no_orphans();
+});
+
+add_task(function* test_oldPostDataAPI() {
+  let bookmark = yield PlacesUtils.bookmarks.insert({ url: "http://example.com/",
+                                                      type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                      parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com/" });
+  let itemId = yield PlacesUtils.promiseItemId(bookmark.guid);
+  yield PlacesUtils.setPostDataForBookmark(itemId, "postData");
+  yield check_keyword(true, "http://example.com/", "keyword", "postData");
+  Assert.equal(PlacesUtils.getPostDataForBookmark(itemId), "postData");
+
+  yield PlacesUtils.keywords.remove("keyword");
+  yield PlacesUtils.bookmarks.remove(bookmark);
+
+  check_no_orphans();
+});
+
+add_task(function* test_oldKeywordsAPI() {
+  let bookmark = yield PlacesUtils.bookmarks.insert({ url: "http://example.com/",
+                                                    type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                    parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  yield check_keyword(false, "http://example.com/", "keyword");
+  let itemId = yield PlacesUtils.promiseItemId(bookmark.guid);
+
+  PlacesUtils.bookmarks.setKeywordForBookmark(itemId, "keyword");
+  yield promiseKeyword("keyword", "http://example.com/");
+
+  // Remove the keyword.
+  PlacesUtils.bookmarks.setKeywordForBookmark(itemId, "");
+  yield promiseKeyword("keyword", null);
+
+  yield PlacesUtils.keywords.insert({ keyword: "keyword", url: "http://example.com" });
+  Assert.equal(PlacesUtils.bookmarks.getKeywordForBookmark(itemId), "keyword");
+  Assert.equal(PlacesUtils.bookmarks.getURIForKeyword("keyword").spec, "http://example.com/");
+  yield PlacesUtils.bookmarks.remove(bookmark);
+
+  check_no_orphans();
+});
+
+add_task(function* test_bookmarkURLChange() {
+  let fc1 = yield foreign_count("http://example1.com/");
+  let fc2 = yield foreign_count("http://example2.com/");
+  let bookmark = yield PlacesUtils.bookmarks.insert({ url: "http://example1.com/",
+                                                      type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+                                                      parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+  yield PlacesUtils.keywords.insert({ keyword: "keyword",
+                                      url: "http://example1.com/" });
+
+  yield check_keyword(true, "http://example1.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example1.com/")), fc1 + 2); // +1 bookmark +1 keyword
+
+  yield PlacesUtils.bookmarks.update({ guid: bookmark.guid,
+                                       url: "http://example2.com/"});
+  yield promiseKeyword("keyword", "http://example2.com/");
+
+  yield check_keyword(false, "http://example1.com/", "keyword");
+  yield check_keyword(true, "http://example2.com/", "keyword");
+  Assert.equal((yield foreign_count("http://example1.com/")), fc1); // -1 bookmark -1 keyword
+  Assert.equal((yield foreign_count("http://example2.com/")), fc2 + 2); // +1 bookmark +1 keyword
+});
diff --git a/toolkit/components/places/tests/unit/test_lastModified.js b/toolkit/components/places/tests/unit/test_lastModified.js
new file mode 100644
index 000000000..c75494932
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_lastModified.js
@@ -0,0 +1,34 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+ /**
+  * Test that inserting a new bookmark will set lastModified to the same
+  * values as dateAdded.
+  */
+// main
+function run_test() {
+  var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+           getService(Ci.nsINavBookmarksService);
+  var itemId = bs.insertBookmark(bs.bookmarksMenuFolder,
+                                 uri("http://www.mozilla.org/"),
+                                 bs.DEFAULT_INDEX,
+                                 "itemTitle");
+  var dateAdded = bs.getItemDateAdded(itemId);
+  do_check_eq(dateAdded, bs.getItemLastModified(itemId));
+
+  // Change lastModified, then change dateAdded.  LastModified should be set
+  // to the new dateAdded.
+  // This could randomly fail on virtual machines due to timing issues, so
+  // we manually increase the time value.  See bug 500640 for details.
+  bs.setItemLastModified(itemId, dateAdded + 1000);
+  do_check_true(bs.getItemLastModified(itemId) === dateAdded + 1000);
+  do_check_true(bs.getItemDateAdded(itemId) < bs.getItemLastModified(itemId));
+  bs.setItemDateAdded(itemId, dateAdded + 2000);
+  do_check_true(bs.getItemDateAdded(itemId) === dateAdded + 2000);
+  do_check_eq(bs.getItemDateAdded(itemId), bs.getItemLastModified(itemId));
+
+  bs.removeItem(itemId);
+}
diff --git a/toolkit/components/places/tests/unit/test_markpageas.js b/toolkit/components/places/tests/unit/test_markpageas.js
new file mode 100644
index 000000000..ba4f740c6
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_markpageas.js
@@ -0,0 +1,61 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var gVisits = [{url: "http://www.mozilla.com/",
+                transition: TRANSITION_TYPED},
+               {url: "http://www.google.com/",
+                transition: TRANSITION_BOOKMARK},
+               {url: "http://www.espn.com/",
+                transition: TRANSITION_LINK}];
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  let observer;
+  let completionPromise = new Promise(resolveCompletionPromise => {
+    observer = {
+      __proto__: NavHistoryObserver.prototype,
+      _visitCount: 0,
+      onVisit: function (aURI, aVisitID, aTime, aSessionID, aReferringID,
+                         aTransitionType, aAdded)
+      {
+        do_check_eq(aURI.spec, gVisits[this._visitCount].url);
+        do_check_eq(aTransitionType, gVisits[this._visitCount].transition);
+        this._visitCount++;
+
+        if (this._visitCount == gVisits.length) {
+          resolveCompletionPromise();
+        }
+      },
+    };
+  });
+
+  PlacesUtils.history.addObserver(observer, false);
+
+  for (var visit of gVisits) {
+    if (visit.transition == TRANSITION_TYPED)
+      PlacesUtils.history.markPageAsTyped(uri(visit.url));
+    else if (visit.transition == TRANSITION_BOOKMARK)
+      PlacesUtils.history.markPageAsFollowedBookmark(uri(visit.url))
+    else {
+     // because it is a top level visit with no referrer,
+     // it will result in TRANSITION_LINK
+    }
+    yield PlacesTestUtils.addVisits({
+      uri: uri(visit.url),
+      transition: visit.transition
+    });
+  }
+
+  yield completionPromise;
+
+  PlacesUtils.history.removeObserver(observer);
+});
+
diff --git a/toolkit/components/places/tests/unit/test_mozIAsyncLivemarks.js b/toolkit/components/places/tests/unit/test_mozIAsyncLivemarks.js
new file mode 100644
index 000000000..5136591ba
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_mozIAsyncLivemarks.js
@@ -0,0 +1,514 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Tests functionality of the mozIAsyncLivemarks interface.
+
+const FEED_URI = NetUtil.newURI("http://feed.rss/");
+const SITE_URI = NetUtil.newURI("http://site.org/");
+
+// This test must be the first one, since it's testing the cache.
+add_task(function* test_livemark_cache() {
+  // Add a livemark through other APIs.
+  let folder = yield PlacesUtils.bookmarks.insert({
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: "test",
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid
+  });
+  let id = yield PlacesUtils.promiseItemId(folder.guid);
+  PlacesUtils.annotations
+             .setItemAnnotation(id, PlacesUtils.LMANNO_FEEDURI,
+                                "http://example.com/feed",
+                                0, PlacesUtils.annotations.EXPIRE_NEVER);
+  PlacesUtils.annotations
+             .setItemAnnotation(id, PlacesUtils.LMANNO_SITEURI,
+                                "http://example.com/site",
+                                0, PlacesUtils.annotations.EXPIRE_NEVER);
+
+  let livemark = yield PlacesUtils.livemarks.getLivemark({ guid: folder.guid });
+  Assert.equal(folder.guid, livemark.guid);
+  Assert.equal(folder.dateAdded * 1000, livemark.dateAdded);
+  Assert.equal(folder.parentGuid, livemark.parentGuid);
+  Assert.equal(folder.index, livemark.index);
+  Assert.equal(folder.title, livemark.title);
+  Assert.equal(id, livemark.id);
+  Assert.equal(PlacesUtils.unfiledBookmarksFolderId, livemark.parentId);
+  Assert.equal("http://example.com/feed", livemark.feedURI.spec);
+  Assert.equal("http://example.com/site", livemark.siteURI.spec);
+
+  yield PlacesUtils.livemarks.removeLivemark(livemark);
+});
+
+add_task(function* test_addLivemark_noArguments_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark();
+    do_throw("Invoking addLivemark with no arguments should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_XPC_NOT_ENOUGH_ARGS);
+  }
+});
+
+add_task(function* test_addLivemark_emptyObject_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark({});
+    do_throw("Invoking addLivemark with empty object should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_badParentId_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark({ parentId: "test" });
+    do_throw("Invoking addLivemark with a bad parent id should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_invalidParentId_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark({ parentId: -2 });
+    do_throw("Invoking addLivemark with an invalid parent id should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_noIndex_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark({
+      parentId: PlacesUtils.unfiledBookmarksFolderId });
+    do_throw("Invoking addLivemark with no index should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_badIndex_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { parentId: PlacesUtils.unfiledBookmarksFolderId
+      , index: "test" });
+    do_throw("Invoking addLivemark with a bad index should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_invalidIndex_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { parentId: PlacesUtils.unfiledBookmarksFolderId
+      , index: -2
+      });
+    do_throw("Invoking addLivemark with an invalid index should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_noFeedURI_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { parentGuid: PlacesUtils.bookmarks.unfiledGuid });
+    do_throw("Invoking addLivemark with no feedURI should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_badFeedURI_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { parentGuid: PlacesUtils.bookmarks.unfiledGuid
+      , feedURI: "test" });
+    do_throw("Invoking addLivemark with a bad feedURI should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_badSiteURI_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { parentGuid: PlacesUtils.bookmarks.unfiledGuid
+      , feedURI: FEED_URI
+      , siteURI: "test" });
+    do_throw("Invoking addLivemark with a bad siteURI should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_badGuid_throws() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { parentGuid: PlacesUtils.bookmarks.unfileGuid
+      , feedURI: FEED_URI
+      , guid: "123456" });
+    do_throw("Invoking addLivemark with a bad guid should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_parentId_succeeds() {
+  let onItemAddedCalled = false;
+  PlacesUtils.bookmarks.addObserver({
+    __proto__: NavBookmarkObserver.prototype,
+    onItemAdded: function onItemAdded(aItemId, aParentId, aIndex, aItemType,
+                                      aURI, aTitle)
+    {
+      onItemAddedCalled = true;
+      PlacesUtils.bookmarks.removeObserver(this);
+      do_check_eq(aParentId, PlacesUtils.unfiledBookmarksFolderId);
+      do_check_eq(aIndex, 0);
+      do_check_eq(aItemType, Ci.nsINavBookmarksService.TYPE_FOLDER);
+      do_check_eq(aTitle, "test");
+    }
+  }, false);
+
+  yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentId: PlacesUtils.unfiledBookmarksFolderId
+    , feedURI: FEED_URI });
+  do_check_true(onItemAddedCalled);
+});
+
+
+add_task(function* test_addLivemark_noSiteURI_succeeds() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    });
+  do_check_true(livemark.id > 0);
+  do_check_valid_places_guid(livemark.guid);
+  do_check_eq(livemark.title, "test");
+  do_check_eq(livemark.parentId, PlacesUtils.unfiledBookmarksFolderId);
+  do_check_eq(livemark.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  do_check_true(livemark.feedURI.equals(FEED_URI));
+  do_check_eq(livemark.siteURI, null);
+  do_check_true(livemark.lastModified > 0);
+  do_check_true(is_time_ordered(livemark.dateAdded, livemark.lastModified));
+
+  let bookmark = yield PlacesUtils.bookmarks.fetch(livemark.guid);
+  do_check_eq(livemark.index, bookmark.index);
+  do_check_eq(livemark.dateAdded, bookmark.dateAdded * 1000);
+});
+
+add_task(function* test_addLivemark_succeeds() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    , siteURI: SITE_URI
+    });
+
+  do_check_true(livemark.id > 0);
+  do_check_valid_places_guid(livemark.guid);
+  do_check_eq(livemark.title, "test");
+  do_check_eq(livemark.parentId, PlacesUtils.unfiledBookmarksFolderId);
+  do_check_eq(livemark.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  do_check_true(livemark.feedURI.equals(FEED_URI));
+  do_check_true(livemark.siteURI.equals(SITE_URI));
+  do_check_true(PlacesUtils.annotations
+                           .itemHasAnnotation(livemark.id,
+                                              PlacesUtils.LMANNO_FEEDURI));
+  do_check_true(PlacesUtils.annotations
+                           .itemHasAnnotation(livemark.id,
+                                              PlacesUtils.LMANNO_SITEURI));
+});
+
+add_task(function* test_addLivemark_bogusid_succeeds() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { id: 100 // Should be ignored.
+    , title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    , siteURI: SITE_URI
+    });
+  do_check_true(livemark.id > 0);
+  do_check_neq(livemark.id, 100);
+});
+
+add_task(function* test_addLivemark_bogusParentId_fails() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { title: "test"
+      , parentId: 187
+      , feedURI: FEED_URI
+      });
+    do_throw("Adding a livemark with a bogus parent should fail");
+  } catch (ex) {}
+});
+
+add_task(function* test_addLivemark_bogusParentGuid_fails() {
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { title: "test"
+      , parentGuid: "123456789012"
+      , feedURI: FEED_URI
+      });
+    do_throw("Adding a livemark with a bogus parent should fail");
+  } catch (ex) {}
+})
+
+add_task(function* test_addLivemark_intoLivemark_fails() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    });
+
+  try {
+    yield PlacesUtils.livemarks.addLivemark(
+      { title: "test"
+      , parentGuid: livemark.guid
+      , feedURI: FEED_URI
+      });
+    do_throw("Adding a livemark into a livemark should fail");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_addLivemark_forceGuid_succeeds() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    , guid: "1234567890AB"
+    });
+    do_check_eq(livemark.guid, "1234567890AB");
+    do_check_guid_for_bookmark(livemark.id, "1234567890AB");
+});
+
+add_task(function* test_addLivemark_dateAdded_succeeds() {
+  let dateAdded = new Date("2013-03-01T01:10:00") * 1000;
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    , dateAdded
+    });
+  do_check_eq(livemark.dateAdded, dateAdded);
+});
+
+add_task(function* test_addLivemark_lastModified_succeeds() {
+  let now = Date.now() * 1000;
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    , lastModified: now
+    });
+  do_check_eq(livemark.dateAdded, now);
+  do_check_eq(livemark.lastModified, now);
+});
+
+add_task(function* test_removeLivemark_emptyObject_throws() {
+  try {
+    yield PlacesUtils.livemarks.removeLivemark({});
+    do_throw("Invoking removeLivemark with empty object should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_removeLivemark_noValidId_throws() {
+  try {
+    yield PlacesUtils.livemarks.removeLivemark({ id: -10, guid: "test"});
+    do_throw("Invoking removeLivemark with no valid id should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_removeLivemark_nonExistent_fails() {
+  try {
+    yield PlacesUtils.livemarks.removeLivemark({ id: 1337 });
+    do_throw("Removing a non-existent livemark should fail");
+  }
+  catch (ex) {
+  }
+});
+
+add_task(function* test_removeLivemark_guid_succeeds() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    , guid: "234567890ABC"
+  });
+
+  do_check_eq(livemark.guid, "234567890ABC");
+
+  yield PlacesUtils.livemarks.removeLivemark({
+    id: 789, guid: "234567890ABC"
+  });
+
+  do_check_eq((yield PlacesUtils.bookmarks.fetch("234567890ABC")), null);
+});
+
+add_task(function* test_removeLivemark_id_succeeds() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+  });
+
+  yield PlacesUtils.livemarks.removeLivemark({ id: livemark.id });
+
+  do_check_eq((yield PlacesUtils.bookmarks.fetch("234567890ABC")), null);
+});
+
+add_task(function* test_getLivemark_emptyObject_throws() {
+  try {
+    yield PlacesUtils.livemarks.getLivemark({});
+    do_throw("Invoking getLivemark with empty object should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_getLivemark_noValidId_throws() {
+  try {
+    yield PlacesUtils.livemarks.getLivemark({ id: -10, guid: "test"});
+    do_throw("Invoking getLivemark with no valid id should throw");
+  } catch (ex) {
+    do_check_eq(ex.result, Cr.NS_ERROR_INVALID_ARG);
+  }
+});
+
+add_task(function* test_getLivemark_nonExistentId_fails() {
+  try {
+    yield PlacesUtils.livemarks.getLivemark({ id: 1234 });
+    do_throw("getLivemark for a non existent id should fail");
+  } catch (ex) {}
+});
+
+add_task(function* test_getLivemark_nonExistentGUID_fails() {
+  try {
+    yield PlacesUtils.livemarks.getLivemark({ guid: "34567890ABCD" });
+    do_throw("getLivemark for a non-existent guid should fail");
+  } catch (ex) {}
+});
+
+add_task(function* test_getLivemark_guid_succeeds() {
+  yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    , guid: "34567890ABCD" });
+
+  // invalid id to check the guid wins.
+  let livemark =
+    yield PlacesUtils.livemarks.getLivemark({ id: 789, guid: "34567890ABCD" });
+
+  do_check_eq(livemark.title, "test");
+  do_check_eq(livemark.parentId, PlacesUtils.unfiledBookmarksFolderId);
+  do_check_eq(livemark.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  do_check_true(livemark.feedURI.equals(FEED_URI));
+  do_check_eq(livemark.siteURI, null);
+  do_check_eq(livemark.guid, "34567890ABCD");
+
+  let bookmark = yield PlacesUtils.bookmarks.fetch("34567890ABCD");
+  do_check_eq(livemark.index, bookmark.index);
+});
+
+add_task(function* test_getLivemark_id_succeeds() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    });
+
+  livemark = yield PlacesUtils.livemarks.getLivemark({ id: livemark.id });
+
+  do_check_eq(livemark.title, "test");
+  do_check_eq(livemark.parentId, PlacesUtils.unfiledBookmarksFolderId);
+  do_check_eq(livemark.parentGuid, PlacesUtils.bookmarks.unfiledGuid);
+  do_check_true(livemark.feedURI.equals(FEED_URI));
+  do_check_eq(livemark.siteURI, null);
+  do_check_guid_for_bookmark(livemark.id, livemark.guid);
+
+  let bookmark = yield PlacesUtils.bookmarks.fetch(livemark.guid);
+  do_check_eq(livemark.index, bookmark.index);
+});
+
+add_task(function* test_getLivemark_removeItem_contention() {
+  // do not yield.
+  PlacesUtils.livemarks.addLivemark({ title: "test"
+                                    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+                                    , feedURI: FEED_URI
+                                  }).catch(() => { /* swallow errors*/ });
+  yield PlacesUtils.bookmarks.eraseEverything();
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    });
+
+  livemark = yield PlacesUtils.livemarks.getLivemark({ guid: livemark.guid });
+
+  do_check_eq(livemark.title, "test");
+  do_check_eq(livemark.parentId, PlacesUtils.unfiledBookmarksFolderId);
+  do_check_true(livemark.feedURI.equals(FEED_URI));
+  do_check_eq(livemark.siteURI, null);
+  do_check_guid_for_bookmark(livemark.id, livemark.guid);
+});
+
+add_task(function* test_title_change() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI
+    });
+
+  yield PlacesUtils.bookmarks.update({ guid: livemark.guid,
+                                       title: "test2" });
+  // Poll for the title change.
+  while (true) {
+    let lm = yield PlacesUtils.livemarks.getLivemark({ guid: livemark.guid });
+    if (lm.title == "test2")
+      break;
+    yield new Promise(resolve => do_timeout(resolve, 100));
+  }
+});
+
+add_task(function* test_livemark_move() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI } );
+
+  yield PlacesUtils.bookmarks.update({ guid: livemark.guid,
+                                       parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+                                       index: PlacesUtils.bookmarks.DEFAULT_INDEX });
+  // Poll for the parent change.
+  while (true) {
+    let lm = yield PlacesUtils.livemarks.getLivemark({ guid: livemark.guid });
+    if (lm.parentGuid == PlacesUtils.bookmarks.toolbarGuid)
+      break;
+    yield new Promise(resolve => do_timeout(resolve, 100));
+  }
+});
+
+add_task(function* test_livemark_removed() {
+  let livemark = yield PlacesUtils.livemarks.addLivemark(
+    { title: "test"
+    , parentGuid: PlacesUtils.bookmarks.unfiledGuid
+    , feedURI: FEED_URI } );
+
+  yield PlacesUtils.bookmarks.remove(livemark.guid);
+  // Poll for the livemark removal.
+  while (true) {
+    try {
+      yield PlacesUtils.livemarks.getLivemark({ guid: livemark.guid });
+    } catch (ex) {
+      break;
+    }
+    yield new Promise(resolve => do_timeout(resolve, 100));
+  }
+});
diff --git a/toolkit/components/places/tests/unit/test_multi_queries.js b/toolkit/components/places/tests/unit/test_multi_queries.js
new file mode 100644
index 000000000..d485355a5
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_multi_queries.js
@@ -0,0 +1,53 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Adds a test URI visit to history.
+ *
+ * @param aURI
+ *        The URI to add a visit for.
+ * @param aReferrer
+ *        The referring URI for the given URI.  This can be null.
+ */
+function* add_visit(aURI, aDayOffset, aTransition) {
+  yield PlacesTestUtils.addVisits({
+    uri: aURI,
+    transition: aTransition,
+    visitDate: (Date.now() + aDayOffset*86400000) * 1000
+  });
+}
+
+function run_test()
+{
+  run_next_test();
+}
+
+add_task(function* test_execute()
+{
+  yield add_visit(uri("http://mirror1.mozilla.com/a"), -1, TRANSITION_LINK);
+  yield add_visit(uri("http://mirror2.mozilla.com/b"), -2, TRANSITION_LINK);
+  yield add_visit(uri("http://mirror3.mozilla.com/c"), -4, TRANSITION_FRAMED_LINK);
+  yield add_visit(uri("http://mirror1.google.com/b"), -1, TRANSITION_EMBED);
+  yield add_visit(uri("http://mirror2.google.com/a"), -2, TRANSITION_LINK);
+  yield add_visit(uri("http://mirror1.apache.org/b"), -3, TRANSITION_LINK);
+  yield add_visit(uri("http://mirror2.apache.org/a"), -4, TRANSITION_FRAMED_LINK);
+
+  let queries = [
+    PlacesUtils.history.getNewQuery(),
+    PlacesUtils.history.getNewQuery()
+  ];
+  queries[0].domain = "mozilla.com";
+  queries[1].domain = "google.com";
+
+  let root = PlacesUtils.history.executeQueries(
+    queries, queries.length, PlacesUtils.history.getNewQueryOptions()
+  ).root;
+  root.containerOpen = true;
+  let childCount = root.childCount;
+  root.containerOpen = false;
+
+  do_check_eq(childCount, 3);
+});
diff --git a/toolkit/components/places/tests/unit/test_multi_word_tags.js b/toolkit/components/places/tests/unit/test_multi_word_tags.js
new file mode 100644
index 000000000..6a0e5f130
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_multi_word_tags.js
@@ -0,0 +1,150 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get history service
+try {
+  var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].
+                getService(Ci.nsINavHistoryService);
+} catch (ex) {
+  do_throw("Could not get history service\n");
+}
+
+// Get bookmark service
+try {
+  var bmsvc = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+              getService(Ci.nsINavBookmarksService);
+}
+catch (ex) {
+  do_throw("Could not get the nav-bookmarks-service\n");
+}
+
+// Get tagging service
+try {
+  var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+                getService(Ci.nsITaggingService);
+} catch (ex) {
+  do_throw("Could not get tagging service\n");
+}
+
+// main
+function run_test() {
+  var uri1 = uri("http://site.tld/1");
+  var uri2 = uri("http://site.tld/2");
+  var uri3 = uri("http://site.tld/3");
+  var uri4 = uri("http://site.tld/4");
+  var uri5 = uri("http://site.tld/5");
+  var uri6 = uri("http://site.tld/6");
+
+  bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri1, bmsvc.DEFAULT_INDEX, null);
+  bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri2, bmsvc.DEFAULT_INDEX, null);
+  bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri3, bmsvc.DEFAULT_INDEX, null);
+  bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri4, bmsvc.DEFAULT_INDEX, null);
+  bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri5, bmsvc.DEFAULT_INDEX, null);
+  bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri6, bmsvc.DEFAULT_INDEX, null);
+
+  tagssvc.tagURI(uri1, ["foo"]);
+  tagssvc.tagURI(uri2, ["bar"]);
+  tagssvc.tagURI(uri3, ["cheese"]);
+  tagssvc.tagURI(uri4, ["foo bar"]);
+  tagssvc.tagURI(uri5, ["bar cheese"]);
+  tagssvc.tagURI(uri6, ["foo bar cheese"]);
+
+  // exclude livemark items, search for "item", should get one result
+  var options = histsvc.getNewQueryOptions();
+  options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+
+  var query = histsvc.getNewQuery();
+  query.searchTerms = "foo";
+  var result = histsvc.executeQuery(query, options);
+  var root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 3);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/1");
+  do_check_eq(root.getChild(1).uri, "http://site.tld/4");
+  do_check_eq(root.getChild(2).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "bar";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 4);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/2");
+  do_check_eq(root.getChild(1).uri, "http://site.tld/4");
+  do_check_eq(root.getChild(2).uri, "http://site.tld/5");
+  do_check_eq(root.getChild(3).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "cheese";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 3);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/3");
+  do_check_eq(root.getChild(1).uri, "http://site.tld/5");
+  do_check_eq(root.getChild(2).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "foo bar";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 2);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/4");
+  do_check_eq(root.getChild(1).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "bar foo";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 2);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/4");
+  do_check_eq(root.getChild(1).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "bar cheese";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 2);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/5");
+  do_check_eq(root.getChild(1).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "cheese bar";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 2);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/5");
+  do_check_eq(root.getChild(1).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "foo bar cheese";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 1);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "cheese foo bar";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 1);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/6");
+  root.containerOpen = false;
+
+  query.searchTerms = "cheese bar foo";
+  result = histsvc.executeQuery(query, options);
+  root = result.root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 1);
+  do_check_eq(root.getChild(0).uri, "http://site.tld/6");
+  root.containerOpen = false;
+}
diff --git a/toolkit/components/places/tests/unit/test_nsINavHistoryViewer.js b/toolkit/components/places/tests/unit/test_nsINavHistoryViewer.js
new file mode 100644
index 000000000..037ab7d08
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_nsINavHistoryViewer.js
@@ -0,0 +1,256 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Get history service
+var histsvc = PlacesUtils.history;
+var bhist = PlacesUtils.bhistory;
+var bmsvc = PlacesUtils.bookmarks;
+
+var resultObserver = {
+  insertedNode: null,
+  nodeInserted: function(parent, node, newIndex) {
+    this.insertedNode = node;
+  },
+  removedNode: null,
+  nodeRemoved: function(parent, node, oldIndex) {
+    this.removedNode = node;
+  },
+
+  nodeAnnotationChanged: function() {},
+
+  newTitle: "",
+  nodeChangedByTitle: null,
+  nodeTitleChanged: function(node, newTitle) {
+    this.nodeChangedByTitle = node;
+    this.newTitle = newTitle;
+  },
+
+  newAccessCount: 0,
+  newTime: 0,
+  nodeChangedByHistoryDetails: null,
+  nodeHistoryDetailsChanged: function(node,
+                                         updatedVisitDate,
+                                         updatedVisitCount) {
+    this.nodeChangedByHistoryDetails = node
+    this.newTime = updatedVisitDate;
+    this.newAccessCount = updatedVisitCount;
+  },
+
+  movedNode: null,
+  nodeMoved: function(node, oldParent, oldIndex, newParent, newIndex) {
+    this.movedNode = node;
+  },
+  openedContainer: null,
+  closedContainer: null,
+  containerStateChanged: function (aNode, aOldState, aNewState) {
+    if (aNewState == Ci.nsINavHistoryContainerResultNode.STATE_OPENED) {
+      this.openedContainer = aNode;
+    }
+    else if (aNewState == Ci.nsINavHistoryContainerResultNode.STATE_CLOSED) {
+      this.closedContainer = aNode;
+    }
+  },
+  invalidatedContainer: null,
+  invalidateContainer: function(node) {
+    this.invalidatedContainer = node;
+  },
+  sortingMode: null,
+  sortingChanged: function(sortingMode) {
+    this.sortingMode = sortingMode;
+  },
+  inBatchMode: false,
+  batching: function(aToggleMode) {
+    do_check_neq(this.inBatchMode, aToggleMode);
+    this.inBatchMode = aToggleMode;
+  },
+  result: null,
+  reset: function() {
+    this.insertedNode = null;
+    this.removedNode = null;
+    this.nodeChangedByTitle = null;
+    this.nodeChangedByHistoryDetails = null;
+    this.replacedNode = null;
+    this.movedNode = null;
+    this.openedContainer = null;
+    this.closedContainer = null;
+    this.invalidatedContainer = null;
+    this.sortingMode = null;
+  }
+};
+
+var testURI = uri("http://mozilla.com");
+
+function run_test() {
+  run_next_test();
+}
+
+add_test(function check_history_query() {
+  var options = histsvc.getNewQueryOptions();
+  options.sortingMode = options.SORT_BY_DATE_DESCENDING;
+  options.resultType = options.RESULTS_AS_VISIT;
+  var query = histsvc.getNewQuery();
+  var result = histsvc.executeQuery(query, options);
+  result.addObserver(resultObserver, false);
+  var root = result.root;
+  root.containerOpen = true;
+
+  do_check_neq(resultObserver.openedContainer, null);
+
+  // nsINavHistoryResultObserver.nodeInserted
+  // add a visit
+  PlacesTestUtils.addVisits(testURI).then(function() {
+    do_check_eq(testURI.spec, resultObserver.insertedNode.uri);
+
+    // nsINavHistoryResultObserver.nodeHistoryDetailsChanged
+    // adding a visit causes nodeHistoryDetailsChanged for the folder
+    do_check_eq(root.uri, resultObserver.nodeChangedByHistoryDetails.uri);
+
+    // nsINavHistoryResultObserver.itemTitleChanged for a leaf node
+    PlacesTestUtils.addVisits({ uri: testURI, title: "baz" }).then(function () {
+      do_check_eq(resultObserver.nodeChangedByTitle.title, "baz");
+
+      // nsINavHistoryResultObserver.nodeRemoved
+      var removedURI = uri("http://google.com");
+      PlacesTestUtils.addVisits(removedURI).then(function() {
+        bhist.removePage(removedURI);
+        do_check_eq(removedURI.spec, resultObserver.removedNode.uri);
+
+        // nsINavHistoryResultObserver.invalidateContainer
+        bhist.removePagesFromHost("mozilla.com", false);
+        do_check_eq(root.uri, resultObserver.invalidatedContainer.uri);
+
+        // nsINavHistoryResultObserver.sortingChanged
+        resultObserver.invalidatedContainer = null;
+        result.sortingMode = options.SORT_BY_TITLE_ASCENDING;
+        do_check_eq(resultObserver.sortingMode, options.SORT_BY_TITLE_ASCENDING);
+        do_check_eq(resultObserver.invalidatedContainer, result.root);
+
+        // nsINavHistoryResultObserver.invalidateContainer
+        PlacesTestUtils.clearHistoryEnabled().then(() => {
+          do_check_eq(root.uri, resultObserver.invalidatedContainer.uri);
+
+          // nsINavHistoryResultObserver.batching
+          do_check_false(resultObserver.inBatchMode);
+          histsvc.runInBatchMode({
+            runBatched: function (aUserData) {
+              do_check_true(resultObserver.inBatchMode);
+            }
+          }, null);
+          do_check_false(resultObserver.inBatchMode);
+          bmsvc.runInBatchMode({
+            runBatched: function (aUserData) {
+              do_check_true(resultObserver.inBatchMode);
+            }
+          }, null);
+          do_check_false(resultObserver.inBatchMode);
+
+          root.containerOpen = false;
+          do_check_eq(resultObserver.closedContainer, resultObserver.openedContainer);
+          result.removeObserver(resultObserver);
+          resultObserver.reset();
+          PlacesTestUtils.promiseAsyncUpdates().then(run_next_test);
+        });
+      });
+    });
+  });
+});
+
+add_test(function check_bookmarks_query() {
+  var options = histsvc.getNewQueryOptions();
+  var query = histsvc.getNewQuery();
+  query.setFolders([bmsvc.bookmarksMenuFolder], 1);
+  var result = histsvc.executeQuery(query, options);
+  result.addObserver(resultObserver, false);
+  var root = result.root;
+  root.containerOpen = true;
+
+  do_check_neq(resultObserver.openedContainer, null);
+
+  // nsINavHistoryResultObserver.nodeInserted
+  // add a bookmark
+  var testBookmark = bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, testURI, bmsvc.DEFAULT_INDEX, "foo");
+  do_check_eq("foo", resultObserver.insertedNode.title);
+  do_check_eq(testURI.spec, resultObserver.insertedNode.uri);
+
+  // nsINavHistoryResultObserver.nodeHistoryDetailsChanged
+  // adding a visit causes nodeHistoryDetailsChanged for the folder
+  do_check_eq(root.uri, resultObserver.nodeChangedByHistoryDetails.uri);
+
+  // nsINavHistoryResultObserver.nodeTitleChanged for a leaf node
+  bmsvc.setItemTitle(testBookmark, "baz");
+  do_check_eq(resultObserver.nodeChangedByTitle.title, "baz");
+  do_check_eq(resultObserver.newTitle, "baz");
+
+  var testBookmark2 = bmsvc.insertBookmark(bmsvc.bookmarksMenuFolder, uri("http://google.com"), bmsvc.DEFAULT_INDEX, "foo");
+  bmsvc.moveItem(testBookmark2, bmsvc.bookmarksMenuFolder, 0);
+  do_check_eq(resultObserver.movedNode.itemId, testBookmark2);
+
+  // nsINavHistoryResultObserver.nodeRemoved
+  bmsvc.removeItem(testBookmark2);
+  do_check_eq(testBookmark2, resultObserver.removedNode.itemId);
+
+  // XXX nsINavHistoryResultObserver.invalidateContainer
+
+  // nsINavHistoryResultObserver.sortingChanged
+  resultObserver.invalidatedContainer = null;
+  result.sortingMode = options.SORT_BY_TITLE_ASCENDING;
+  do_check_eq(resultObserver.sortingMode, options.SORT_BY_TITLE_ASCENDING);
+  do_check_eq(resultObserver.invalidatedContainer, result.root);
+
+  // nsINavHistoryResultObserver.batching
+  do_check_false(resultObserver.inBatchMode);
+  histsvc.runInBatchMode({
+    runBatched: function (aUserData) {
+      do_check_true(resultObserver.inBatchMode);
+    }
+  }, null);
+  do_check_false(resultObserver.inBatchMode);
+  bmsvc.runInBatchMode({
+    runBatched: function (aUserData) {
+      do_check_true(resultObserver.inBatchMode);
+    }
+  }, null);
+  do_check_false(resultObserver.inBatchMode);
+
+  root.containerOpen = false;
+  do_check_eq(resultObserver.closedContainer, resultObserver.openedContainer);
+  result.removeObserver(resultObserver);
+  resultObserver.reset();
+  PlacesTestUtils.promiseAsyncUpdates().then(run_next_test);
+});
+
+add_test(function check_mixed_query() {
+  var options = histsvc.getNewQueryOptions();
+  var query = histsvc.getNewQuery();
+  query.onlyBookmarked = true;
+  var result = histsvc.executeQuery(query, options);
+  result.addObserver(resultObserver, false);
+  var root = result.root;
+  root.containerOpen = true;
+
+  do_check_neq(resultObserver.openedContainer, null);
+
+  // nsINavHistoryResultObserver.batching
+  do_check_false(resultObserver.inBatchMode);
+  histsvc.runInBatchMode({
+    runBatched: function (aUserData) {
+      do_check_true(resultObserver.inBatchMode);
+    }
+  }, null);
+  do_check_false(resultObserver.inBatchMode);
+  bmsvc.runInBatchMode({
+    runBatched: function (aUserData) {
+      do_check_true(resultObserver.inBatchMode);
+    }
+  }, null);
+  do_check_false(resultObserver.inBatchMode);
+
+  root.containerOpen = false;
+  do_check_eq(resultObserver.closedContainer, resultObserver.openedContainer);
+  result.removeObserver(resultObserver);
+  resultObserver.reset();
+  PlacesTestUtils.promiseAsyncUpdates().then(run_next_test);
+});
diff --git a/toolkit/components/places/tests/unit/test_null_interfaces.js b/toolkit/components/places/tests/unit/test_null_interfaces.js
new file mode 100644
index 000000000..524837ca3
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_null_interfaces.js
@@ -0,0 +1,98 @@
+/* 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/. */
+
+/**
+ * Test bug 489872 to make sure passing nulls to nsNavHistory doesn't crash.
+ */
+
+// Make an array of services to test, each specifying a class id, interface
+// and an array of function names that don't throw when passed nulls
+var testServices = [
+  ["browser/nav-history-service;1",
+    ["nsINavHistoryService"],
+    ["queryStringToQueries", "removePagesByTimeframe", "removePagesFromHost", "getObservers"]
+  ],
+  ["browser/nav-bookmarks-service;1",
+    ["nsINavBookmarksService", "nsINavHistoryObserver", "nsIAnnotationObserver"],
+    ["createFolder", "getObservers", "onFrecencyChanged", "onTitleChanged",
+     "onPageAnnotationSet", "onPageAnnotationRemoved", "onDeleteURI"]
+  ],
+  ["browser/livemark-service;2", ["mozIAsyncLivemarks"], ["reloadLivemarks"]],
+  ["browser/annotation-service;1", ["nsIAnnotationService"], []],
+  ["browser/favicon-service;1", ["nsIFaviconService"], []],
+  ["browser/tagging-service;1", ["nsITaggingService"], []],
+];
+do_print(testServices.join("\n"));
+
+function run_test()
+{
+  for (let [cid, ifaces, nothrow] of testServices) {
+    do_print(`Running test with ${cid} ${ifaces.join(", ")} ${nothrow}`);
+    let s = Cc["@mozilla.org/" + cid].getService(Ci.nsISupports);
+    for (let iface of ifaces) {
+      s.QueryInterface(Ci[iface]);
+    }
+
+    let okName = function(name) {
+      do_print(`Checking if function is okay to test: ${name}`);
+      let func = s[name];
+
+      let mesg = "";
+      if (typeof func != "function")
+        mesg = "Not a function!";
+      else if (func.length == 0)
+        mesg = "No args needed!";
+      else if (name == "QueryInterface")
+        mesg = "Ignore QI!";
+
+      if (mesg) {
+        do_print(`${mesg} Skipping: ${name}`);
+        return false;
+      }
+
+      return true;
+    }
+
+    do_print(`Generating an array of functions to test service: ${s}`);
+    for (let n of Object.keys(s).filter(i => okName(i)).sort()) {
+      do_print(`\nTesting ${ifaces.join(", ")} function with null args: ${n}`);
+
+      let func = s[n];
+      let num = func.length;
+      do_print(`Generating array of nulls for #args: ${num}`);
+      let args = Array(num).fill(null);
+
+      let tryAgain = true;
+      while (tryAgain == true) {
+        try {
+          do_print(`Calling with args: ${JSON.stringify(args)}`);
+          func.apply(s, args);
+
+          do_print(`The function did not throw! Is it one of the nothrow? ${nothrow}`);
+          Assert.notEqual(nothrow.indexOf(n), -1);
+
+          do_print("Must have been an expected nothrow, so no need to try again");
+          tryAgain = false;
+        }
+        catch (ex) {
+          if (ex.result == Cr.NS_ERROR_ILLEGAL_VALUE) {
+            do_print(`Caught an expected exception: ${ex.name}`);
+            do_print("Moving on to the next test..");
+            tryAgain = false;
+          } else if (ex.result == Cr.NS_ERROR_XPC_NEED_OUT_OBJECT) {
+            let pos = Number(ex.message.match(/object arg (\d+)/)[1]);
+            do_print(`Function call expects an out object at ${pos}`);
+            args[pos] = {};
+          } else if (ex.result == Cr.NS_ERROR_NOT_IMPLEMENTED) {
+            do_print(`Method not implemented exception: ${ex.name}`);
+            do_print("Moving on to the next test..");
+            tryAgain = false;
+          } else {
+            throw ex;
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/toolkit/components/places/tests/unit/test_onItemChanged_tags.js b/toolkit/components/places/tests/unit/test_onItemChanged_tags.js
new file mode 100644
index 000000000..7a0eb354d
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_onItemChanged_tags.js
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// This test checks that changing a tag for a bookmark with multiple tags
+// notifies OnItemChanged("tags") only once, and not once per tag.
+
+function run_test() {
+  do_test_pending();
+
+  let tags = ["a", "b", "c"];
+  let uri = NetUtil.newURI("http://1.moz.org/");
+
+  let id = PlacesUtils.bookmarks.insertBookmark(
+    PlacesUtils.unfiledBookmarksFolderId, uri,
+    PlacesUtils.bookmarks.DEFAULT_INDEX, "Bookmark 1"
+  );
+  PlacesUtils.tagging.tagURI(uri, tags);
+
+  let bookmarksObserver = {
+    QueryInterface: XPCOMUtils.generateQI([
+      Ci.nsINavBookmarkObserver
+    ]),
+
+    _changedCount: 0,
+    onItemChanged: function (aItemId, aProperty, aIsAnnotationProperty, aValue,
+                             aLastModified, aItemType) {
+      if (aProperty == "tags") {
+        do_check_eq(aItemId, id);
+        this._changedCount++;
+      }
+    },
+
+    onItemRemoved: function (aItemId, aParentId, aIndex, aItemType) {
+      if (aItemId == id) {
+        PlacesUtils.bookmarks.removeObserver(this);
+        do_check_eq(this._changedCount, 2);
+        do_test_finished();
+      }
+    },
+
+    onItemAdded: function () {},
+    onBeginUpdateBatch: function () {},
+    onEndUpdateBatch: function () {},
+    onItemVisited: function () {},
+    onItemMoved: function () {},
+  };
+  PlacesUtils.bookmarks.addObserver(bookmarksObserver, false);
+
+  PlacesUtils.tagging.tagURI(uri, ["d"]);
+  PlacesUtils.tagging.tagURI(uri, ["e"]);
+  PlacesUtils.bookmarks.removeItem(id);
+}
diff --git a/toolkit/components/places/tests/unit/test_pageGuid_bookmarkGuid.js b/toolkit/components/places/tests/unit/test_pageGuid_bookmarkGuid.js
new file mode 100644
index 000000000..f6131b211
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_pageGuid_bookmarkGuid.js
@@ -0,0 +1,179 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const bmsvc = PlacesUtils.bookmarks;
+const histsvc = PlacesUtils.history;
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_addBookmarksAndCheckGuids() {
+  let folder = bmsvc.createFolder(bmsvc.placesRoot, "test folder", bmsvc.DEFAULT_INDEX);
+  bmsvc.insertBookmark(folder, uri("http://test1.com/"),
+                       bmsvc.DEFAULT_INDEX, "1 title");
+  bmsvc.insertBookmark(folder, uri("http://test2.com/"),
+                       bmsvc.DEFAULT_INDEX, "2 title");
+  bmsvc.insertBookmark(folder, uri("http://test3.com/"),
+                       bmsvc.DEFAULT_INDEX, "3 title");
+  bmsvc.insertSeparator(folder, bmsvc.DEFAULT_INDEX);
+  bmsvc.createFolder(folder, "test folder 2", bmsvc.DEFAULT_INDEX);
+
+  let root = PlacesUtils.getFolderContents(folder).root;
+  do_check_eq(root.childCount, 5);
+
+  // check bookmark guids
+  let bookmarkGuidZero = root.getChild(0).bookmarkGuid;
+  do_check_eq(bookmarkGuidZero.length, 12);
+  // bookmarks have bookmark guids
+  do_check_eq(root.getChild(1).bookmarkGuid.length, 12);
+  do_check_eq(root.getChild(2).bookmarkGuid.length, 12);
+  // separator has bookmark guid
+  do_check_eq(root.getChild(3).bookmarkGuid.length, 12);
+  // folder has bookmark guid
+  do_check_eq(root.getChild(4).bookmarkGuid.length, 12);
+  // all bookmark guids are different.
+  do_check_neq(bookmarkGuidZero, root.getChild(1).bookmarkGuid);
+  do_check_neq(root.getChild(1).bookmarkGuid, root.getChild(2).bookmarkGuid);
+  do_check_neq(root.getChild(2).bookmarkGuid, root.getChild(3).bookmarkGuid);
+  do_check_neq(root.getChild(3).bookmarkGuid, root.getChild(4).bookmarkGuid);
+
+  // check page guids
+  let pageGuidZero = root.getChild(0).pageGuid;
+  do_check_eq(pageGuidZero.length, 12);
+  // bookmarks have page guids
+  do_check_eq(root.getChild(1).pageGuid.length, 12);
+  do_check_eq(root.getChild(2).pageGuid.length, 12);
+  // folder and separator don't have page guids
+  do_check_eq(root.getChild(3).pageGuid, "");
+  do_check_eq(root.getChild(4).pageGuid, "");
+
+  do_check_neq(pageGuidZero, root.getChild(1).pageGuid);
+  do_check_neq(root.getChild(1).pageGuid, root.getChild(2).pageGuid);
+
+  root.containerOpen = false;
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_updateBookmarksAndCheckGuids() {
+  let folder = bmsvc.createFolder(bmsvc.placesRoot, "test folder", bmsvc.DEFAULT_INDEX);
+  let b1 = bmsvc.insertBookmark(folder, uri("http://test1.com/"),
+                                bmsvc.DEFAULT_INDEX, "1 title");
+  let f1 = bmsvc.createFolder(folder, "test folder 2", bmsvc.DEFAULT_INDEX);
+
+  let root = PlacesUtils.getFolderContents(folder).root;
+  do_check_eq(root.childCount, 2);
+
+  // ensure the bookmark and page guids remain the same after modifing other property.
+  let bookmarkGuidZero = root.getChild(0).bookmarkGuid;
+  let pageGuidZero = root.getChild(0).pageGuid;
+  bmsvc.setItemTitle(b1, "1 title mod");
+  do_check_eq(root.getChild(0).title, "1 title mod");
+  do_check_eq(root.getChild(0).bookmarkGuid, bookmarkGuidZero);
+  do_check_eq(root.getChild(0).pageGuid, pageGuidZero);
+
+  let bookmarkGuidOne = root.getChild(1).bookmarkGuid;
+  let pageGuidOne = root.getChild(1).pageGuid;
+  bmsvc.setItemTitle(f1, "test foolder 234");
+  do_check_eq(root.getChild(1).title, "test foolder 234");
+  do_check_eq(root.getChild(1).bookmarkGuid, bookmarkGuidOne);
+  do_check_eq(root.getChild(1).pageGuid, pageGuidOne);
+
+  root.containerOpen = false;
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_addVisitAndCheckGuid() {
+  // add a visit and test page guid and non-existing bookmark guids.
+  let sourceURI = uri("http://test4.com/");
+  yield PlacesTestUtils.addVisits({ uri: sourceURI });
+  do_check_eq(bmsvc.getBookmarkedURIFor(sourceURI), null);
+
+  let options = histsvc.getNewQueryOptions();
+  let query = histsvc.getNewQuery();
+  query.uri = sourceURI;
+  let root = histsvc.executeQuery(query, options).root;
+  root.containerOpen = true;
+  do_check_eq(root.childCount, 1);
+
+  do_check_valid_places_guid(root.getChild(0).pageGuid);
+  do_check_eq(root.getChild(0).bookmarkGuid, "");
+  root.containerOpen = false;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_addItemsWithInvalidGUIDsFails() {
+  const INVALID_GUID = "XYZ";
+  try {
+    bmsvc.createFolder(bmsvc.placesRoot, "XYZ folder",
+                       bmsvc.DEFAULT_INDEX, INVALID_GUID);
+    do_throw("Adding a folder with an invalid guid should fail");
+  }
+  catch (ex) { }
+
+  let folder = bmsvc.createFolder(bmsvc.placesRoot, "test folder",
+                                  bmsvc.DEFAULT_INDEX);
+  try {
+    bmsvc.insertBookmark(folder, uri("http://test.tld"), bmsvc.DEFAULT_INDEX,
+                         "title", INVALID_GUID);
+    do_throw("Adding a bookmark with an invalid guid should fail");
+  }
+  catch (ex) { }
+
+  try {
+    bmsvc.insertSeparator(folder, bmsvc.DEFAULT_INDEX, INVALID_GUID);
+    do_throw("Adding a separator with an invalid guid should fail");
+  }
+  catch (ex) { }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_addItemsWithGUIDs() {
+  const FOLDER_GUID     = "FOLDER--GUID";
+  const BOOKMARK_GUID   = "BM------GUID";
+  const SEPARATOR_GUID  = "SEP-----GUID";
+
+  let folder = bmsvc.createFolder(bmsvc.placesRoot, "test folder",
+                                  bmsvc.DEFAULT_INDEX, FOLDER_GUID);
+  bmsvc.insertBookmark(folder, uri("http://test1.com/"), bmsvc.DEFAULT_INDEX,
+                       "1 title", BOOKMARK_GUID);
+  bmsvc.insertSeparator(folder, bmsvc.DEFAULT_INDEX, SEPARATOR_GUID);
+
+  let root = PlacesUtils.getFolderContents(folder).root;
+  do_check_eq(root.childCount, 2);
+  do_check_eq(root.bookmarkGuid, FOLDER_GUID);
+  do_check_eq(root.getChild(0).bookmarkGuid, BOOKMARK_GUID);
+  do_check_eq(root.getChild(1).bookmarkGuid, SEPARATOR_GUID);
+
+  root.containerOpen = false;
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_emptyGUIDIgnored() {
+  let folder = bmsvc.createFolder(bmsvc.placesRoot, "test folder",
+                                  bmsvc.DEFAULT_INDEX, "");
+  do_check_valid_places_guid(PlacesUtils.getFolderContents(folder)
+                                        .root.bookmarkGuid);
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_usingSameGUIDFails() {
+  const GUID = "XYZXYZXYZXYZ";
+  bmsvc.createFolder(bmsvc.placesRoot, "test folder",
+                     bmsvc.DEFAULT_INDEX, GUID);
+  try {
+    bmsvc.createFolder(bmsvc.placesRoot, "test folder 2",
+                       bmsvc.DEFAULT_INDEX, GUID);
+    do_throw("Using the same guid twice should fail");
+  }
+  catch (ex) { }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
diff --git a/toolkit/components/places/tests/unit/test_placeURIs.js b/toolkit/components/places/tests/unit/test_placeURIs.js
new file mode 100644
index 000000000..0f585ca51
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_placeURIs.js
@@ -0,0 +1,42 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+
+// Get history service
+try {
+  var histsvc = Cc["@mozilla.org/browser/nav-history-service;1"].getService(Ci.nsINavHistoryService);
+} catch (ex) {
+  do_throw("Could not get history service\n");
+}
+
+// main
+function run_test() {
+  // XXX Full testing coverage for QueriesToQueryString and
+  // QueryStringToQueries
+
+  var bs = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+           getService(Ci.nsINavBookmarksService);
+  const NHQO = Ci.nsINavHistoryQueryOptions;
+  // Bug 376798
+  var query = histsvc.getNewQuery();
+  query.setFolders([bs.placesRoot], 1);
+  do_check_eq(histsvc.queriesToQueryString([query], 1, histsvc.getNewQueryOptions()),
+              "place:folder=PLACES_ROOT");
+
+  // Bug 378828
+  var options = histsvc.getNewQueryOptions();
+  options.sortingAnnotation = "test anno";
+  options.sortingMode = NHQO.SORT_BY_ANNOTATION_DESCENDING;
+  var placeURI =
+    "place:folder=PLACES_ROOT&sort=" + NHQO.SORT_BY_ANNOTATION_DESCENDING +
+    "&sortingAnnotation=test%20anno";
+  do_check_eq(histsvc.queriesToQueryString([query], 1, options),
+              placeURI);
+  options = {};
+  histsvc.queryStringToQueries(placeURI, { }, {}, options);
+  do_check_eq(options.value.sortingAnnotation, "test anno");
+  do_check_eq(options.value.sortingMode, NHQO.SORT_BY_ANNOTATION_DESCENDING);
+}
diff --git a/toolkit/components/places/tests/unit/test_placesTxn.js b/toolkit/components/places/tests/unit/test_placesTxn.js
new file mode 100644
index 000000000..3cc9809bb
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_placesTxn.js
@@ -0,0 +1,937 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var bmsvc = PlacesUtils.bookmarks;
+var tagssvc = PlacesUtils.tagging;
+var annosvc = PlacesUtils.annotations;
+var txnManager = PlacesUtils.transactionManager;
+const DESCRIPTION_ANNO = "bookmarkProperties/description";
+
+function* promiseKeyword(keyword, href, postData) {
+  while (true) {
+    let entry = yield PlacesUtils.keywords.fetch(keyword);
+    if (href == null && !entry)
+      break;
+    if (entry && entry.url.href == href && entry.postData == postData) {
+      break;
+    }
+
+    yield new Promise(resolve => do_timeout(100, resolve));
+  }
+}
+
+// create and add bookmarks observer
+var observer = {
+
+  onBeginUpdateBatch: function() {
+    this._beginUpdateBatch = true;
+  },
+  _beginUpdateBatch: false,
+
+  onEndUpdateBatch: function() {
+    this._endUpdateBatch = true;
+  },
+  _endUpdateBatch: false,
+
+  onItemAdded: function(id, folder, index, itemType, uri) {
+    this._itemAddedId = id;
+    this._itemAddedParent = folder;
+    this._itemAddedIndex = index;
+    this._itemAddedType = itemType;
+  },
+  _itemAddedId: null,
+  _itemAddedParent: null,
+  _itemAddedIndex: null,
+  _itemAddedType: null,
+
+  onItemRemoved: function(id, folder, index, itemType) {
+    this._itemRemovedId = id;
+    this._itemRemovedFolder = folder;
+    this._itemRemovedIndex = index;
+  },
+  _itemRemovedId: null,
+  _itemRemovedFolder: null,
+  _itemRemovedIndex: null,
+
+  onItemChanged: function(id, property, isAnnotationProperty, newValue,
+                          lastModified, itemType) {
+    // The transaction manager is being rewritten in bug 891303, so just
+    // skip checking this for now.
+    if (property == "tags")
+      return;
+    this._itemChangedId = id;
+    this._itemChangedProperty = property;
+    this._itemChanged_isAnnotationProperty = isAnnotationProperty;
+    this._itemChangedValue = newValue;
+  },
+  _itemChangedId: null,
+  _itemChangedProperty: null,
+  _itemChanged_isAnnotationProperty: null,
+  _itemChangedValue: null,
+
+  onItemVisited: function(id, visitID, time) {
+    this._itemVisitedId = id;
+    this._itemVisitedVistId = visitID;
+    this._itemVisitedTime = time;
+  },
+  _itemVisitedId: null,
+  _itemVisitedVistId: null,
+  _itemVisitedTime: null,
+
+  onItemMoved: function(id, oldParent, oldIndex, newParent, newIndex,
+                        itemType) {
+    this._itemMovedId = id;
+    this._itemMovedOldParent = oldParent;
+    this._itemMovedOldIndex = oldIndex;
+    this._itemMovedNewParent = newParent;
+    this._itemMovedNewIndex = newIndex;
+  },
+  _itemMovedId: null,
+  _itemMovedOldParent: null,
+  _itemMovedOldIndex: null,
+  _itemMovedNewParent: null,
+  _itemMovedNewIndex: null,
+
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsINavBookmarkObserver) ||
+        iid.equals(Ci.nsISupports)) {
+      return this;
+    }
+    throw Cr.NS_ERROR_NO_INTERFACE;
+  }
+};
+
+// index at which items should begin
+var bmStartIndex = 0;
+
+// get bookmarks root id
+var root = PlacesUtils.bookmarksMenuFolderId;
+
+add_task(function* init() {
+  bmsvc.addObserver(observer, false);
+  do_register_cleanup(function () {
+    bmsvc.removeObserver(observer);
+  });
+});
+
+add_task(function* test_create_folder_with_description() {
+  const TEST_FOLDERNAME = "Test creating a folder with a description";
+  const TEST_DESCRIPTION = "this is my test description";
+
+  let annos = [{ name: DESCRIPTION_ANNO,
+                 type: annosvc.TYPE_STRING,
+                 flags: 0,
+                 value: TEST_DESCRIPTION,
+                 expires: annosvc.EXPIRE_NEVER }];
+  let txn = new PlacesCreateFolderTransaction(TEST_FOLDERNAME, root, bmStartIndex, annos);
+  txnManager.doTransaction(txn);
+
+  // This checks that calling undoTransaction on an "empty batch" doesn't
+  // undo the previous transaction (getItemTitle will fail)
+  txnManager.beginBatch(null);
+  txnManager.endBatch(false);
+  txnManager.undoTransaction();
+
+  let folderId = observer._itemAddedId;
+  do_check_eq(bmsvc.getItemTitle(folderId), TEST_FOLDERNAME);
+  do_check_eq(observer._itemAddedIndex, bmStartIndex);
+  do_check_eq(observer._itemAddedParent, root);
+  do_check_eq(observer._itemAddedId, folderId);
+  do_check_eq(TEST_DESCRIPTION, annosvc.getItemAnnotation(folderId, DESCRIPTION_ANNO));
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemRemovedId, folderId);
+  do_check_eq(observer._itemRemovedFolder, root);
+  do_check_eq(observer._itemRemovedIndex, bmStartIndex);
+
+  txn.redoTransaction();
+  do_check_eq(observer._itemAddedIndex, bmStartIndex);
+  do_check_eq(observer._itemAddedParent, root);
+  do_check_eq(observer._itemAddedId, folderId);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemRemovedId, folderId);
+  do_check_eq(observer._itemRemovedFolder, root);
+  do_check_eq(observer._itemRemovedIndex, bmStartIndex);
+});
+
+add_task(function* test_create_item() {
+  let testURI = NetUtil.newURI("http://test_create_item.com");
+
+  let txn = new PlacesCreateBookmarkTransaction(testURI, root, bmStartIndex,
+                                                "Test creating an item");
+
+  txnManager.doTransaction(txn);
+  let id = bmsvc.getBookmarkIdsForURI(testURI)[0];
+  do_check_eq(observer._itemAddedId, id);
+  do_check_eq(observer._itemAddedIndex, bmStartIndex);
+  do_check_true(bmsvc.isBookmarked(testURI));
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemRemovedId, id);
+  do_check_eq(observer._itemRemovedIndex, bmStartIndex);
+  do_check_false(bmsvc.isBookmarked(testURI));
+
+  txn.redoTransaction();
+  do_check_true(bmsvc.isBookmarked(testURI));
+  let newId = bmsvc.getBookmarkIdsForURI(testURI)[0];
+  do_check_eq(observer._itemAddedIndex, bmStartIndex);
+  do_check_eq(observer._itemAddedParent, root);
+  do_check_eq(observer._itemAddedId, newId);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemRemovedId, newId);
+  do_check_eq(observer._itemRemovedFolder, root);
+  do_check_eq(observer._itemRemovedIndex, bmStartIndex);
+});
+
+add_task(function* test_create_item_to_folder() {
+  const TEST_FOLDERNAME = "Test creating item to a folder";
+  let testURI = NetUtil.newURI("http://test_create_item_to_folder.com");
+  let folderId = bmsvc.createFolder(root, TEST_FOLDERNAME, bmsvc.DEFAULT_INDEX);
+
+  let txn = new PlacesCreateBookmarkTransaction(testURI, folderId, bmStartIndex,
+                                                "Test creating item");
+  txnManager.doTransaction(txn);
+  let bkmId = bmsvc.getBookmarkIdsForURI(testURI)[0];
+  do_check_eq(observer._itemAddedId, bkmId);
+  do_check_eq(observer._itemAddedIndex, bmStartIndex);
+  do_check_true(bmsvc.isBookmarked(testURI));
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemRemovedId, bkmId);
+  do_check_eq(observer._itemRemovedIndex, bmStartIndex);
+
+  txn.redoTransaction();
+  let newBkmId = bmsvc.getBookmarkIdsForURI(testURI)[0];
+  do_check_eq(observer._itemAddedIndex, bmStartIndex);
+  do_check_eq(observer._itemAddedParent, folderId);
+  do_check_eq(observer._itemAddedId, newBkmId);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemRemovedId, newBkmId);
+  do_check_eq(observer._itemRemovedFolder, folderId);
+  do_check_eq(observer._itemRemovedIndex, bmStartIndex);
+});
+
+add_task(function* test_move_items_to_folder() {
+  let testFolderId = bmsvc.createFolder(root, "Test move items", bmsvc.DEFAULT_INDEX);
+  let testURI = NetUtil.newURI("http://test_move_items.com");
+  let testBkmId = bmsvc.insertBookmark(testFolderId, testURI, bmsvc.DEFAULT_INDEX, "1: Test move items");
+  bmsvc.insertBookmark(testFolderId, testURI, bmsvc.DEFAULT_INDEX, "2: Test move items");
+
+  // Moving items between the same folder
+  let sameTxn = new PlacesMoveItemTransaction(testBkmId, testFolderId, bmsvc.DEFAULT_INDEX);
+
+  sameTxn.doTransaction();
+  do_check_eq(observer._itemMovedId, testBkmId);
+  do_check_eq(observer._itemMovedOldParent, testFolderId);
+  do_check_eq(observer._itemMovedOldIndex, 0);
+  do_check_eq(observer._itemMovedNewParent, testFolderId);
+  do_check_eq(observer._itemMovedNewIndex, 1);
+
+  sameTxn.undoTransaction();
+  do_check_eq(observer._itemMovedId, testBkmId);
+  do_check_eq(observer._itemMovedOldParent, testFolderId);
+  do_check_eq(observer._itemMovedOldIndex, 1);
+  do_check_eq(observer._itemMovedNewParent, testFolderId);
+  do_check_eq(observer._itemMovedNewIndex, 0);
+
+  sameTxn.redoTransaction();
+  do_check_eq(observer._itemMovedId, testBkmId);
+  do_check_eq(observer._itemMovedOldParent, testFolderId);
+  do_check_eq(observer._itemMovedOldIndex, 0);
+  do_check_eq(observer._itemMovedNewParent, testFolderId);
+  do_check_eq(observer._itemMovedNewIndex, 1);
+
+  sameTxn.undoTransaction();
+  do_check_eq(observer._itemMovedId, testBkmId);
+  do_check_eq(observer._itemMovedOldParent, testFolderId);
+  do_check_eq(observer._itemMovedOldIndex, 1);
+  do_check_eq(observer._itemMovedNewParent, testFolderId);
+  do_check_eq(observer._itemMovedNewIndex, 0);
+
+  // Moving items between different folders
+  let folderId = bmsvc.createFolder(testFolderId,
+                                    "Test move items between different folders",
+                                    bmsvc.DEFAULT_INDEX);
+  let diffTxn = new PlacesMoveItemTransaction(testBkmId, folderId, bmsvc.DEFAULT_INDEX);
+
+  diffTxn.doTransaction();
+  do_check_eq(observer._itemMovedId, testBkmId);
+  do_check_eq(observer._itemMovedOldParent, testFolderId);
+  do_check_eq(observer._itemMovedOldIndex, 0);
+  do_check_eq(observer._itemMovedNewParent, folderId);
+  do_check_eq(observer._itemMovedNewIndex, 0);
+
+  sameTxn.undoTransaction();
+  do_check_eq(observer._itemMovedId, testBkmId);
+  do_check_eq(observer._itemMovedOldParent, folderId);
+  do_check_eq(observer._itemMovedOldIndex, 0);
+  do_check_eq(observer._itemMovedNewParent, testFolderId);
+  do_check_eq(observer._itemMovedNewIndex, 0);
+
+  diffTxn.redoTransaction();
+  do_check_eq(observer._itemMovedId, testBkmId);
+  do_check_eq(observer._itemMovedOldParent, testFolderId);
+  do_check_eq(observer._itemMovedOldIndex, 0);
+  do_check_eq(observer._itemMovedNewParent, folderId);
+  do_check_eq(observer._itemMovedNewIndex, 0);
+
+  sameTxn.undoTransaction();
+  do_check_eq(observer._itemMovedId, testBkmId);
+  do_check_eq(observer._itemMovedOldParent, folderId);
+  do_check_eq(observer._itemMovedOldIndex, 0);
+  do_check_eq(observer._itemMovedNewParent, testFolderId);
+  do_check_eq(observer._itemMovedNewIndex, 0);
+});
+
+add_task(function* test_remove_folder() {
+  let testFolder = bmsvc.createFolder(root, "Test Removing a Folder", bmsvc.DEFAULT_INDEX);
+  let folderId = bmsvc.createFolder(testFolder, "Removed Folder", bmsvc.DEFAULT_INDEX);
+
+  let txn = new PlacesRemoveItemTransaction(folderId);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemRemovedId, folderId);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemAddedId, folderId);
+  do_check_eq(observer._itemAddedParent, testFolder);
+  do_check_eq(observer._itemAddedIndex, 0);
+
+  txn.redoTransaction();
+  do_check_eq(observer._itemRemovedId, folderId);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemAddedId, folderId);
+  do_check_eq(observer._itemAddedParent, testFolder);
+  do_check_eq(observer._itemAddedIndex, 0);
+});
+
+add_task(function* test_remove_item_with_tag() {
+  // Notice in this case the tag persists since other bookmarks have same uri.
+  let testFolder = bmsvc.createFolder(root, "Test removing an item with a tag",
+                                      bmsvc.DEFAULT_INDEX);
+
+  const TAG_NAME = "tag-test_remove_item_with_tag";
+  let testURI = NetUtil.newURI("http://test_remove_item_with_tag.com");
+  let testBkmId = bmsvc.insertBookmark(testFolder, testURI, bmsvc.DEFAULT_INDEX, "test-item1");
+
+  // create bookmark for not removing tag.
+  bmsvc.insertBookmark(testFolder, testURI, bmsvc.DEFAULT_INDEX, "test-item2");
+
+  // set tag
+  tagssvc.tagURI(testURI, [TAG_NAME]);
+
+  let txn = new PlacesRemoveItemTransaction(testBkmId);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemRemovedId, testBkmId);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+  do_check_eq(tagssvc.getTagsForURI(testURI), TAG_NAME);
+
+  txn.undoTransaction();
+  let newbkmk2Id = observer._itemAddedId;
+  do_check_eq(observer._itemAddedParent, testFolder);
+  do_check_eq(observer._itemAddedIndex, 0);
+  do_check_eq(tagssvc.getTagsForURI(testURI)[0], TAG_NAME);
+
+  txn.redoTransaction();
+  do_check_eq(observer._itemRemovedId, newbkmk2Id);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+  do_check_eq(tagssvc.getTagsForURI(testURI)[0], TAG_NAME);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemAddedParent, testFolder);
+  do_check_eq(observer._itemAddedIndex, 0);
+  do_check_eq(tagssvc.getTagsForURI(testURI)[0], TAG_NAME);
+});
+
+add_task(function* test_remove_item_with_keyword() {
+  // Notice in this case the tag persists since other bookmarks have same uri.
+  let testFolder = bmsvc.createFolder(root, "Test removing an item with a keyword",
+                                      bmsvc.DEFAULT_INDEX);
+
+  const KEYWORD = "test: test removing an item with a keyword";
+  let testURI = NetUtil.newURI("http://test_remove_item_with_keyword.com");
+  let testBkmId = bmsvc.insertBookmark(testFolder, testURI, bmsvc.DEFAULT_INDEX, "test-item1");
+
+  // set keyword
+  yield PlacesUtils.keywords.insert({ url: testURI.spec, keyword: KEYWORD});
+
+  let txn = new PlacesRemoveItemTransaction(testBkmId);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemRemovedId, testBkmId);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+  yield promiseKeyword(KEYWORD, null);
+
+  txn.undoTransaction();
+  let newbkmk2Id = observer._itemAddedId;
+  do_check_eq(observer._itemAddedParent, testFolder);
+  do_check_eq(observer._itemAddedIndex, 0);
+  yield promiseKeyword(KEYWORD, testURI.spec);
+
+  txn.redoTransaction();
+  do_check_eq(observer._itemRemovedId, newbkmk2Id);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+  yield promiseKeyword(KEYWORD, null);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemAddedParent, testFolder);
+  do_check_eq(observer._itemAddedIndex, 0);
+});
+
+add_task(function* test_creating_separator() {
+  let testFolder = bmsvc.createFolder(root, "Test creating a separator", bmsvc.DEFAULT_INDEX);
+
+  let txn = new PlacesCreateSeparatorTransaction(testFolder, 0);
+  txn.doTransaction();
+
+  let sepId = observer._itemAddedId;
+  do_check_eq(observer._itemAddedIndex, 0);
+  do_check_eq(observer._itemAddedParent, testFolder);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemRemovedId, sepId);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+
+  txn.redoTransaction();
+  let newSepId = observer._itemAddedId;
+  do_check_eq(observer._itemAddedIndex, 0);
+  do_check_eq(observer._itemAddedParent, testFolder);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemRemovedId, newSepId);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+});
+
+add_task(function* test_removing_separator() {
+  let testFolder = bmsvc.createFolder(root, "Test removing a separator", bmsvc.DEFAULT_INDEX);
+
+  let sepId = bmsvc.insertSeparator(testFolder, 0);
+  let txn = new PlacesRemoveItemTransaction(sepId);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemRemovedId, sepId);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemAddedId, sepId); // New separator created
+  do_check_eq(observer._itemAddedParent, testFolder);
+  do_check_eq(observer._itemAddedIndex, 0);
+
+  txn.redoTransaction();
+  do_check_eq(observer._itemRemovedId, sepId);
+  do_check_eq(observer._itemRemovedFolder, testFolder);
+  do_check_eq(observer._itemRemovedIndex, 0);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemAddedId, sepId); // New separator created
+  do_check_eq(observer._itemAddedParent, testFolder);
+  do_check_eq(observer._itemAddedIndex, 0);
+});
+
+add_task(function* test_editing_item_title() {
+  const TITLE = "Test editing item title";
+  const MOD_TITLE = "Mod: Test editing item title";
+  let testURI = NetUtil.newURI("http://www.test_editing_item_title.com");
+  let testBkmId = bmsvc.insertBookmark(root, testURI, bmsvc.DEFAULT_INDEX, TITLE);
+
+  let txn = new PlacesEditItemTitleTransaction(testBkmId, MOD_TITLE);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "title");
+  do_check_eq(observer._itemChangedValue, MOD_TITLE);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "title");
+  do_check_eq(observer._itemChangedValue, TITLE);
+
+  txn.redoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "title");
+  do_check_eq(observer._itemChangedValue, MOD_TITLE);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "title");
+  do_check_eq(observer._itemChangedValue, TITLE);
+});
+
+add_task(function* test_editing_item_uri() {
+  const OLD_TEST_URI = NetUtil.newURI("http://old.test_editing_item_uri.com/");
+  const NEW_TEST_URI = NetUtil.newURI("http://new.test_editing_item_uri.com/");
+  let testBkmId = bmsvc.insertBookmark(root, OLD_TEST_URI, bmsvc.DEFAULT_INDEX,
+                                       "Test editing item title");
+  tagssvc.tagURI(OLD_TEST_URI, ["tag"]);
+
+  let txn = new PlacesEditBookmarkURITransaction(testBkmId, NEW_TEST_URI);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "uri");
+  do_check_eq(observer._itemChangedValue, NEW_TEST_URI.spec);
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(NEW_TEST_URI)), JSON.stringify(["tag"]));
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(OLD_TEST_URI)), JSON.stringify([]));
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "uri");
+  do_check_eq(observer._itemChangedValue, OLD_TEST_URI.spec);
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(OLD_TEST_URI)), JSON.stringify(["tag"]));
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(NEW_TEST_URI)), JSON.stringify([]));
+
+  txn.redoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "uri");
+  do_check_eq(observer._itemChangedValue, NEW_TEST_URI.spec);
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(NEW_TEST_URI)), JSON.stringify(["tag"]));
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(OLD_TEST_URI)), JSON.stringify([]));
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "uri");
+  do_check_eq(observer._itemChangedValue, OLD_TEST_URI.spec);
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(OLD_TEST_URI)), JSON.stringify(["tag"]));
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(NEW_TEST_URI)), JSON.stringify([]));
+});
+
+add_task(function* test_edit_description_transaction() {
+  let testURI = NetUtil.newURI("http://test_edit_description_transaction.com");
+  let testBkmId = bmsvc.insertBookmark(root, testURI, bmsvc.DEFAULT_INDEX, "Test edit description transaction");
+
+  let anno = {
+    name: DESCRIPTION_ANNO,
+    type: Ci.nsIAnnotationService.TYPE_STRING,
+    flags: 0,
+    value: "Test edit Description",
+    expires: Ci.nsIAnnotationService.EXPIRE_NEVER,
+  };
+  let txn = new PlacesSetItemAnnotationTransaction(testBkmId, anno);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, DESCRIPTION_ANNO);
+});
+
+add_task(function* test_edit_keyword() {
+  const KEYWORD = "keyword-test_edit_keyword";
+
+  let testURI = NetUtil.newURI("http://test_edit_keyword.com");
+  let testBkmId = bmsvc.insertBookmark(root, testURI, bmsvc.DEFAULT_INDEX, "Test edit keyword");
+
+  let txn = new PlacesEditBookmarkKeywordTransaction(testBkmId, KEYWORD, "postData");
+
+  txn.doTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "keyword");
+  do_check_eq(observer._itemChangedValue, KEYWORD);
+  do_check_eq(PlacesUtils.getPostDataForBookmark(testBkmId), "postData");
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "keyword");
+  do_check_eq(observer._itemChangedValue, "");
+  do_check_eq(PlacesUtils.getPostDataForBookmark(testBkmId), null);
+});
+
+add_task(function* test_edit_specific_keyword() {
+  const KEYWORD = "keyword-test_edit_keyword2";
+
+  let testURI = NetUtil.newURI("http://test_edit_keyword2.com");
+  let testBkmId = bmsvc.insertBookmark(root, testURI, bmsvc.DEFAULT_INDEX, "Test edit keyword");
+  // Add multiple keyword to this uri.
+  yield PlacesUtils.keywords.insert({ keyword: "kw1", url: testURI.spec, postData: "postData1" });
+  yield PlacesUtils.keywords.insert({keyword: "kw2", url: testURI.spec, postData: "postData2" });
+
+  // Try to change only kw2.
+  let txn = new PlacesEditBookmarkKeywordTransaction(testBkmId, KEYWORD, "postData2", "kw2");
+
+  txn.doTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "keyword");
+  do_check_eq(observer._itemChangedValue, KEYWORD);
+  let entry = yield PlacesUtils.keywords.fetch("kw1");
+  Assert.equal(entry.url.href, testURI.spec);
+  Assert.equal(entry.postData, "postData1");
+  yield promiseKeyword(KEYWORD, testURI.spec, "postData2");
+  yield promiseKeyword("kw2", null);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "keyword");
+  do_check_eq(observer._itemChangedValue, "kw2");
+  do_check_eq(PlacesUtils.getPostDataForBookmark(testBkmId), "postData1");
+  entry = yield PlacesUtils.keywords.fetch("kw1");
+  Assert.equal(entry.url.href, testURI.spec);
+  Assert.equal(entry.postData, "postData1");
+  yield promiseKeyword("kw2", testURI.spec, "postData2");
+  yield promiseKeyword("keyword", null);
+});
+
+add_task(function* test_LoadInSidebar_transaction() {
+  let testURI = NetUtil.newURI("http://test_LoadInSidebar_transaction.com");
+  let testBkmId = bmsvc.insertBookmark(root, testURI, bmsvc.DEFAULT_INDEX, "Test LoadInSidebar transaction");
+
+  const LOAD_IN_SIDEBAR_ANNO = "bookmarkProperties/loadInSidebar";
+  let anno = { name: LOAD_IN_SIDEBAR_ANNO,
+               type: Ci.nsIAnnotationService.TYPE_INT32,
+               flags: 0,
+               value: true,
+               expires: Ci.nsIAnnotationService.EXPIRE_NEVER };
+  let txn = new PlacesSetItemAnnotationTransaction(testBkmId, anno);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, LOAD_IN_SIDEBAR_ANNO);
+  do_check_eq(observer._itemChanged_isAnnotationProperty, true);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, LOAD_IN_SIDEBAR_ANNO);
+  do_check_eq(observer._itemChanged_isAnnotationProperty, true);
+});
+
+add_task(function* test_generic_item_annotation() {
+  let testURI = NetUtil.newURI("http://test_generic_item_annotation.com");
+  let testBkmId = bmsvc.insertBookmark(root, testURI, bmsvc.DEFAULT_INDEX, "Test generic item annotation");
+
+  let itemAnnoObj = { name: "testAnno/testInt",
+                      type: Ci.nsIAnnotationService.TYPE_INT32,
+                      flags: 0,
+                      value: 123,
+                      expires: Ci.nsIAnnotationService.EXPIRE_NEVER };
+  let txn = new PlacesSetItemAnnotationTransaction(testBkmId, itemAnnoObj);
+
+  txn.doTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "testAnno/testInt");
+  do_check_eq(observer._itemChanged_isAnnotationProperty, true);
+
+  txn.undoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "testAnno/testInt");
+  do_check_eq(observer._itemChanged_isAnnotationProperty, true);
+
+  txn.redoTransaction();
+  do_check_eq(observer._itemChangedId, testBkmId);
+  do_check_eq(observer._itemChangedProperty, "testAnno/testInt");
+  do_check_eq(observer._itemChanged_isAnnotationProperty, true);
+});
+
+add_task(function* test_editing_item_date_added() {
+  let testURI = NetUtil.newURI("http://test_editing_item_date_added.com");
+  let testBkmId = bmsvc.insertBookmark(root, testURI, bmsvc.DEFAULT_INDEX,
+                                       "Test editing item date added");
+
+  let oldAdded = bmsvc.getItemDateAdded(testBkmId);
+  let newAdded = Date.now() * 1000 + 1000;
+  let txn = new PlacesEditItemDateAddedTransaction(testBkmId, newAdded);
+
+  txn.doTransaction();
+  do_check_eq(newAdded, bmsvc.getItemDateAdded(testBkmId));
+
+  txn.undoTransaction();
+  do_check_eq(oldAdded, bmsvc.getItemDateAdded(testBkmId));
+});
+
+add_task(function* test_edit_item_last_modified() {
+  let testURI = NetUtil.newURI("http://test_edit_item_last_modified.com");
+  let testBkmId = bmsvc.insertBookmark(root, testURI, bmsvc.DEFAULT_INDEX,
+                                       "Test editing item last modified");
+
+  let oldModified = bmsvc.getItemLastModified(testBkmId);
+  let newModified = Date.now() * 1000 + 1000;
+  let txn = new PlacesEditItemLastModifiedTransaction(testBkmId, newModified);
+
+  txn.doTransaction();
+  do_check_eq(newModified, bmsvc.getItemLastModified(testBkmId));
+
+  txn.undoTransaction();
+  do_check_eq(oldModified, bmsvc.getItemLastModified(testBkmId));
+});
+
+add_task(function* test_generic_page_annotation() {
+  const TEST_ANNO = "testAnno/testInt";
+  let testURI = NetUtil.newURI("http://www.mozilla.org/");
+  PlacesTestUtils.addVisits(testURI).then(function () {
+    let pageAnnoObj = { name: TEST_ANNO,
+                        type: Ci.nsIAnnotationService.TYPE_INT32,
+                        flags: 0,
+                        value: 123,
+                        expires: Ci.nsIAnnotationService.EXPIRE_NEVER };
+    let txn = new PlacesSetPageAnnotationTransaction(testURI, pageAnnoObj);
+
+    txn.doTransaction();
+    do_check_true(annosvc.pageHasAnnotation(testURI, TEST_ANNO));
+
+    txn.undoTransaction();
+    do_check_false(annosvc.pageHasAnnotation(testURI, TEST_ANNO));
+
+    txn.redoTransaction();
+    do_check_true(annosvc.pageHasAnnotation(testURI, TEST_ANNO));
+  });
+});
+
+add_task(function* test_sort_folder_by_name() {
+  let testFolder = bmsvc.createFolder(root, "Test PlacesSortFolderByNameTransaction",
+                                      bmsvc.DEFAULT_INDEX);
+  let testURI = NetUtil.newURI("http://test_sort_folder_by_name.com");
+
+  bmsvc.insertBookmark(testFolder, testURI, bmsvc.DEFAULT_INDEX, "bookmark3");
+  bmsvc.insertBookmark(testFolder, testURI, bmsvc.DEFAULT_INDEX, "bookmark2");
+  bmsvc.insertBookmark(testFolder, testURI, bmsvc.DEFAULT_INDEX, "bookmark1");
+
+  let bkmIds = bmsvc.getBookmarkIdsForURI(testURI);
+  bkmIds.sort();
+
+  let b1 = bkmIds[0];
+  let b2 = bkmIds[1];
+  let b3 = bkmIds[2];
+
+  do_check_eq(0, bmsvc.getItemIndex(b1));
+  do_check_eq(1, bmsvc.getItemIndex(b2));
+  do_check_eq(2, bmsvc.getItemIndex(b3));
+
+  let txn = new PlacesSortFolderByNameTransaction(testFolder);
+
+  txn.doTransaction();
+  do_check_eq(2, bmsvc.getItemIndex(b1));
+  do_check_eq(1, bmsvc.getItemIndex(b2));
+  do_check_eq(0, bmsvc.getItemIndex(b3));
+
+  txn.undoTransaction();
+  do_check_eq(0, bmsvc.getItemIndex(b1));
+  do_check_eq(1, bmsvc.getItemIndex(b2));
+  do_check_eq(2, bmsvc.getItemIndex(b3));
+
+  txn.redoTransaction();
+  do_check_eq(2, bmsvc.getItemIndex(b1));
+  do_check_eq(1, bmsvc.getItemIndex(b2));
+  do_check_eq(0, bmsvc.getItemIndex(b3));
+
+  txn.undoTransaction();
+  do_check_eq(0, bmsvc.getItemIndex(b1));
+  do_check_eq(1, bmsvc.getItemIndex(b2));
+  do_check_eq(2, bmsvc.getItemIndex(b3));
+});
+
+add_task(function* test_tagURI_untagURI() {
+  const TAG_1 = "tag-test_tagURI_untagURI-bar";
+  const TAG_2 = "tag-test_tagURI_untagURI-foo";
+  let tagURI = NetUtil.newURI("http://test_tagURI_untagURI.com");
+
+  // Test tagURI
+  let tagTxn = new PlacesTagURITransaction(tagURI, [TAG_1, TAG_2]);
+
+  tagTxn.doTransaction();
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(tagURI)), JSON.stringify([TAG_1, TAG_2]));
+
+  tagTxn.undoTransaction();
+  do_check_eq(tagssvc.getTagsForURI(tagURI).length, 0);
+
+  tagTxn.redoTransaction();
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(tagURI)), JSON.stringify([TAG_1, TAG_2]));
+
+  // Test untagURI
+  let untagTxn = new PlacesUntagURITransaction(tagURI, [TAG_1]);
+
+  untagTxn.doTransaction();
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(tagURI)), JSON.stringify([TAG_2]));
+
+  untagTxn.undoTransaction();
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(tagURI)), JSON.stringify([TAG_1, TAG_2]));
+
+  untagTxn.redoTransaction();
+  do_check_eq(JSON.stringify(tagssvc.getTagsForURI(tagURI)), JSON.stringify([TAG_2]));
+});
+
+add_task(function* test_aggregate_removeItem_Txn() {
+  let testFolder = bmsvc.createFolder(root, "Test aggregate removeItem transaction", bmsvc.DEFAULT_INDEX);
+
+  const TEST_URL = "http://test_aggregate_removeitem_txn.com/";
+  const FOLDERNAME = "Folder";
+  let testURI = NetUtil.newURI(TEST_URL);
+
+  let bkmk1Id = bmsvc.insertBookmark(testFolder, testURI, 0, "Mozilla");
+  let bkmk2Id = bmsvc.insertSeparator(testFolder, 1);
+  let bkmk3Id = bmsvc.createFolder(testFolder, FOLDERNAME, 2);
+
+  let bkmk3_1Id = bmsvc.insertBookmark(bkmk3Id, testURI, 0, "Mozilla");
+  let bkmk3_2Id = bmsvc.insertSeparator(bkmk3Id, 1);
+  let bkmk3_3Id = bmsvc.createFolder(bkmk3Id, FOLDERNAME, 2);
+
+  let childTxn1 = new PlacesRemoveItemTransaction(bkmk1Id);
+  let childTxn2 = new PlacesRemoveItemTransaction(bkmk2Id);
+  let childTxn3 = new PlacesRemoveItemTransaction(bkmk3Id);
+  let transactions = [childTxn1, childTxn2, childTxn3];
+  let txn = new PlacesAggregatedTransaction("RemoveItems", transactions);
+
+  txn.doTransaction();
+  do_check_eq(bmsvc.getItemIndex(bkmk1Id), -1);
+  do_check_eq(bmsvc.getItemIndex(bkmk2Id), -1);
+  do_check_eq(bmsvc.getItemIndex(bkmk3Id), -1);
+  do_check_eq(bmsvc.getItemIndex(bkmk3_1Id), -1);
+  do_check_eq(bmsvc.getItemIndex(bkmk3_2Id), -1);
+  do_check_eq(bmsvc.getItemIndex(bkmk3_3Id), -1);
+  // Check last removed item id.
+  do_check_eq(observer._itemRemovedId, bkmk3Id);
+
+  txn.undoTransaction();
+  let newBkmk1Id = bmsvc.getIdForItemAt(testFolder, 0);
+  let newBkmk2Id = bmsvc.getIdForItemAt(testFolder, 1);
+  let newBkmk3Id = bmsvc.getIdForItemAt(testFolder, 2);
+  let newBkmk3_1Id = bmsvc.getIdForItemAt(newBkmk3Id, 0);
+  let newBkmk3_2Id = bmsvc.getIdForItemAt(newBkmk3Id, 1);
+  let newBkmk3_3Id = bmsvc.getIdForItemAt(newBkmk3Id, 2);
+  do_check_eq(bmsvc.getItemType(newBkmk1Id), bmsvc.TYPE_BOOKMARK);
+  do_check_eq(bmsvc.getBookmarkURI(newBkmk1Id).spec, TEST_URL);
+  do_check_eq(bmsvc.getItemType(newBkmk2Id), bmsvc.TYPE_SEPARATOR);
+  do_check_eq(bmsvc.getItemType(newBkmk3Id), bmsvc.TYPE_FOLDER);
+  do_check_eq(bmsvc.getItemTitle(newBkmk3Id), FOLDERNAME);
+  do_check_eq(bmsvc.getFolderIdForItem(newBkmk3_1Id), newBkmk3Id);
+  do_check_eq(bmsvc.getItemType(newBkmk3_1Id), bmsvc.TYPE_BOOKMARK);
+  do_check_eq(bmsvc.getBookmarkURI(newBkmk3_1Id).spec, TEST_URL);
+  do_check_eq(bmsvc.getFolderIdForItem(newBkmk3_2Id), newBkmk3Id);
+  do_check_eq(bmsvc.getItemType(newBkmk3_2Id), bmsvc.TYPE_SEPARATOR);
+  do_check_eq(bmsvc.getFolderIdForItem(newBkmk3_3Id), newBkmk3Id);
+  do_check_eq(bmsvc.getItemType(newBkmk3_3Id), bmsvc.TYPE_FOLDER);
+  do_check_eq(bmsvc.getItemTitle(newBkmk3_3Id), FOLDERNAME);
+  // Check last added back item id.
+  // Notice items are restored in reverse order.
+  do_check_eq(observer._itemAddedId, newBkmk1Id);
+
+  txn.redoTransaction();
+  do_check_eq(bmsvc.getItemIndex(newBkmk1Id), -1);
+  do_check_eq(bmsvc.getItemIndex(newBkmk2Id), -1);
+  do_check_eq(bmsvc.getItemIndex(newBkmk3Id), -1);
+  do_check_eq(bmsvc.getItemIndex(newBkmk3_1Id), -1);
+  do_check_eq(bmsvc.getItemIndex(newBkmk3_2Id), -1);
+  do_check_eq(bmsvc.getItemIndex(newBkmk3_3Id), -1);
+  // Check last removed item id.
+  do_check_eq(observer._itemRemovedId, newBkmk3Id);
+
+  txn.undoTransaction();
+  newBkmk1Id = bmsvc.getIdForItemAt(testFolder, 0);
+  newBkmk2Id = bmsvc.getIdForItemAt(testFolder, 1);
+  newBkmk3Id = bmsvc.getIdForItemAt(testFolder, 2);
+  newBkmk3_1Id = bmsvc.getIdForItemAt(newBkmk3Id, 0);
+  newBkmk3_2Id = bmsvc.getIdForItemAt(newBkmk3Id, 1);
+  newBkmk3_3Id = bmsvc.getIdForItemAt(newBkmk3Id, 2);
+  do_check_eq(bmsvc.getItemType(newBkmk1Id), bmsvc.TYPE_BOOKMARK);
+  do_check_eq(bmsvc.getBookmarkURI(newBkmk1Id).spec, TEST_URL);
+  do_check_eq(bmsvc.getItemType(newBkmk2Id), bmsvc.TYPE_SEPARATOR);
+  do_check_eq(bmsvc.getItemType(newBkmk3Id), bmsvc.TYPE_FOLDER);
+  do_check_eq(bmsvc.getItemTitle(newBkmk3Id), FOLDERNAME);
+  do_check_eq(bmsvc.getFolderIdForItem(newBkmk3_1Id), newBkmk3Id);
+  do_check_eq(bmsvc.getItemType(newBkmk3_1Id), bmsvc.TYPE_BOOKMARK);
+  do_check_eq(bmsvc.getBookmarkURI(newBkmk3_1Id).spec, TEST_URL);
+  do_check_eq(bmsvc.getFolderIdForItem(newBkmk3_2Id), newBkmk3Id);
+  do_check_eq(bmsvc.getItemType(newBkmk3_2Id), bmsvc.TYPE_SEPARATOR);
+  do_check_eq(bmsvc.getFolderIdForItem(newBkmk3_3Id), newBkmk3Id);
+  do_check_eq(bmsvc.getItemType(newBkmk3_3Id), bmsvc.TYPE_FOLDER);
+  do_check_eq(bmsvc.getItemTitle(newBkmk3_3Id), FOLDERNAME);
+  // Check last added back item id.
+  // Notice items are restored in reverse order.
+  do_check_eq(observer._itemAddedId, newBkmk1Id);
+});
+
+add_task(function* test_create_item_with_childTxn() {
+  let testFolder = bmsvc.createFolder(root, "Test creating an item with childTxns", bmsvc.DEFAULT_INDEX);
+
+  const BOOKMARK_TITLE = "parent item";
+  let testURI = NetUtil.newURI("http://test_create_item_with_childTxn.com");
+  let childTxns = [];
+  let newDateAdded = Date.now() * 1000 - 20000;
+  let editDateAdddedTxn = new PlacesEditItemDateAddedTransaction(null, newDateAdded);
+  childTxns.push(editDateAdddedTxn);
+
+  let itemChildAnnoObj = { name: "testAnno/testInt",
+                           type: Ci.nsIAnnotationService.TYPE_INT32,
+                           flags: 0,
+                           value: 123,
+                           expires: Ci.nsIAnnotationService.EXPIRE_NEVER };
+  let annoTxn = new PlacesSetItemAnnotationTransaction(null, itemChildAnnoObj);
+  childTxns.push(annoTxn);
+
+  let itemWChildTxn = new PlacesCreateBookmarkTransaction(testURI, testFolder, bmStartIndex,
+                                                          BOOKMARK_TITLE, null, null,
+                                                          childTxns);
+  try {
+    txnManager.doTransaction(itemWChildTxn);
+    let itemId = bmsvc.getBookmarkIdsForURI(testURI)[0];
+    do_check_eq(observer._itemAddedId, itemId);
+    do_check_eq(newDateAdded, bmsvc.getItemDateAdded(itemId));
+    do_check_eq(observer._itemChangedProperty, "testAnno/testInt");
+    do_check_eq(observer._itemChanged_isAnnotationProperty, true);
+    do_check_true(annosvc.itemHasAnnotation(itemId, itemChildAnnoObj.name))
+    do_check_eq(annosvc.getItemAnnotation(itemId, itemChildAnnoObj.name), itemChildAnnoObj.value);
+
+    itemWChildTxn.undoTransaction();
+    do_check_eq(observer._itemRemovedId, itemId);
+
+    itemWChildTxn.redoTransaction();
+    do_check_true(bmsvc.isBookmarked(testURI));
+    let newId = bmsvc.getBookmarkIdsForURI(testURI)[0];
+    do_check_eq(newDateAdded, bmsvc.getItemDateAdded(newId));
+    do_check_eq(observer._itemAddedId, newId);
+    do_check_eq(observer._itemChangedProperty, "testAnno/testInt");
+    do_check_eq(observer._itemChanged_isAnnotationProperty, true);
+    do_check_true(annosvc.itemHasAnnotation(newId, itemChildAnnoObj.name))
+    do_check_eq(annosvc.getItemAnnotation(newId, itemChildAnnoObj.name), itemChildAnnoObj.value);
+
+    itemWChildTxn.undoTransaction();
+    do_check_eq(observer._itemRemovedId, newId);
+  }
+  catch (ex) {
+    do_throw("Setting a child transaction in a createItem transaction did throw: " + ex);
+  }
+});
+
+add_task(function* test_create_folder_with_child_itemTxn() {
+  let childURI = NetUtil.newURI("http://test_create_folder_with_child_itemTxn.com");
+  let childItemTxn = new PlacesCreateBookmarkTransaction(childURI, root,
+                                                         bmStartIndex, "childItem");
+  let txn = new PlacesCreateFolderTransaction("Test creating a folder with child itemTxns",
+                                              root, bmStartIndex, null, [childItemTxn]);
+  try {
+    txnManager.doTransaction(txn);
+    let childItemId = bmsvc.getBookmarkIdsForURI(childURI)[0];
+    do_check_eq(observer._itemAddedId, childItemId);
+    do_check_eq(observer._itemAddedIndex, 0);
+    do_check_true(bmsvc.isBookmarked(childURI));
+
+    txn.undoTransaction();
+    do_check_false(bmsvc.isBookmarked(childURI));
+
+    txn.redoTransaction();
+    let newchildItemId = bmsvc.getBookmarkIdsForURI(childURI)[0];
+    do_check_eq(observer._itemAddedIndex, 0);
+    do_check_eq(observer._itemAddedId, newchildItemId);
+    do_check_true(bmsvc.isBookmarked(childURI));
+
+    txn.undoTransaction();
+    do_check_false(bmsvc.isBookmarked(childURI));
+  }
+  catch (ex) {
+    do_throw("Setting a child item transaction in a createFolder transaction did throw: " + ex);
+  }
+});
diff --git a/toolkit/components/places/tests/unit/test_preventive_maintenance.js b/toolkit/components/places/tests/unit/test_preventive_maintenance.js
new file mode 100644
index 000000000..a533c8295
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_preventive_maintenance.js
@@ -0,0 +1,1356 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+ /**
+  * Test preventive maintenance
+  * For every maintenance query create an uncoherent db and check that we take
+  * correct fix steps, without polluting valid data.
+  */
+
+// Include PlacesDBUtils module
+Components.utils.import("resource://gre/modules/PlacesDBUtils.jsm");
+
+const FINISHED_MAINTENANCE_NOTIFICATION_TOPIC = "places-maintenance-finished";
+
+// Get services and database connection
+var hs = PlacesUtils.history;
+var bs = PlacesUtils.bookmarks;
+var ts = PlacesUtils.tagging;
+var as = PlacesUtils.annotations;
+var fs = PlacesUtils.favicons;
+
+var mDBConn = hs.QueryInterface(Ci.nsPIPlacesDatabase).DBConnection;
+
+// ------------------------------------------------------------------------------
+// Helpers
+
+var defaultBookmarksMaxId = 0;
+function cleanDatabase() {
+  mDBConn.executeSimpleSQL("DELETE FROM moz_places");
+  mDBConn.executeSimpleSQL("DELETE FROM moz_historyvisits");
+  mDBConn.executeSimpleSQL("DELETE FROM moz_anno_attributes");
+  mDBConn.executeSimpleSQL("DELETE FROM moz_annos");
+  mDBConn.executeSimpleSQL("DELETE FROM moz_items_annos");
+  mDBConn.executeSimpleSQL("DELETE FROM moz_inputhistory");
+  mDBConn.executeSimpleSQL("DELETE FROM moz_keywords");
+  mDBConn.executeSimpleSQL("DELETE FROM moz_favicons");
+  mDBConn.executeSimpleSQL("DELETE FROM moz_bookmarks WHERE id > " + defaultBookmarksMaxId);
+}
+
+function addPlace(aUrl, aFavicon) {
+  let stmt = mDBConn.createStatement(
+    "INSERT INTO moz_places (url, url_hash, favicon_id) VALUES (:url, hash(:url), :favicon)");
+  stmt.params["url"] = aUrl || "http://www.mozilla.org";
+  stmt.params["favicon"] = aFavicon || null;
+  stmt.execute();
+  stmt.finalize();
+  return mDBConn.lastInsertRowID;
+}
+
+function addBookmark(aPlaceId, aType, aParent, aKeywordId, aFolderType, aTitle) {
+  let stmt = mDBConn.createStatement(
+    `INSERT INTO moz_bookmarks (fk, type, parent, keyword_id, folder_type,
+                                title, guid)
+     VALUES (:place_id, :type, :parent, :keyword_id, :folder_type, :title,
+             GENERATE_GUID())`);
+  stmt.params["place_id"] = aPlaceId || null;
+  stmt.params["type"] = aType || bs.TYPE_BOOKMARK;
+  stmt.params["parent"] = aParent || bs.unfiledBookmarksFolder;
+  stmt.params["keyword_id"] = aKeywordId || null;
+  stmt.params["folder_type"] = aFolderType || null;
+  stmt.params["title"] = typeof(aTitle) == "string" ? aTitle : null;
+  stmt.execute();
+  stmt.finalize();
+  return mDBConn.lastInsertRowID;
+}
+
+// ------------------------------------------------------------------------------
+// Tests
+
+var tests = [];
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "A.1",
+  desc: "Remove obsolete annotations from moz_annos",
+
+  _obsoleteWeaveAttribute: "weave/test",
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid.
+    this._placeId = addPlace();
+    // Add an obsolete attribute.
+    let stmt = mDBConn.createStatement(
+      "INSERT INTO moz_anno_attributes (name) VALUES (:anno)"
+    );
+    stmt.params['anno'] = this._obsoleteWeaveAttribute;
+    stmt.execute();
+    stmt.finalize();
+    stmt = mDBConn.createStatement(
+      `INSERT INTO moz_annos (place_id, anno_attribute_id)
+       VALUES (:place_id,
+         (SELECT id FROM moz_anno_attributes WHERE name = :anno)
+       )`
+    );
+    stmt.params['place_id'] = this._placeId;
+    stmt.params['anno'] = this._obsoleteWeaveAttribute;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that the obsolete annotation has been removed.
+    let stmt = mDBConn.createStatement(
+      "SELECT id FROM moz_anno_attributes WHERE name = :anno"
+    );
+    stmt.params['anno'] = this._obsoleteWeaveAttribute;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+tests.push({
+  name: "A.2",
+  desc: "Remove obsolete annotations from moz_items_annos",
+
+  _obsoleteSyncAttribute: "sync/children",
+  _obsoleteGuidAttribute: "placesInternal/GUID",
+  _obsoleteWeaveAttribute: "weave/test",
+  _placeId: null,
+  _bookmarkId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid.
+    this._placeId = addPlace();
+    // Add a bookmark.
+    this._bookmarkId = addBookmark(this._placeId);
+    // Add an obsolete attribute.
+    let stmt = mDBConn.createStatement(
+      `INSERT INTO moz_anno_attributes (name)
+       VALUES (:anno1), (:anno2), (:anno3)`
+    );
+    stmt.params['anno1'] = this._obsoleteSyncAttribute;
+    stmt.params['anno2'] = this._obsoleteGuidAttribute;
+    stmt.params['anno3'] = this._obsoleteWeaveAttribute;
+    stmt.execute();
+    stmt.finalize();
+    stmt = mDBConn.createStatement(
+      `INSERT INTO moz_items_annos (item_id, anno_attribute_id)
+       SELECT :item_id, id
+       FROM moz_anno_attributes
+       WHERE name IN (:anno1, :anno2, :anno3)`
+    );
+    stmt.params['item_id'] = this._bookmarkId;
+    stmt.params['anno1'] = this._obsoleteSyncAttribute;
+    stmt.params['anno2'] = this._obsoleteGuidAttribute;
+    stmt.params['anno3'] = this._obsoleteWeaveAttribute;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that the obsolete annotations have been removed.
+    let stmt = mDBConn.createStatement(
+      `SELECT id FROM moz_anno_attributes
+       WHERE name IN (:anno1, :anno2, :anno3)`
+    );
+    stmt.params['anno1'] = this._obsoleteSyncAttribute;
+    stmt.params['anno2'] = this._obsoleteGuidAttribute;
+    stmt.params['anno3'] = this._obsoleteWeaveAttribute;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+tests.push({
+  name: "A.3",
+  desc: "Remove unused attributes",
+
+  _usedPageAttribute: "usedPage",
+  _usedItemAttribute: "usedItem",
+  _unusedAttribute: "unused",
+  _placeId: null,
+  _bookmarkId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // add a bookmark
+    this._bookmarkId = addBookmark(this._placeId);
+    // Add a used attribute and an unused one.
+    let stmt = mDBConn.createStatement("INSERT INTO moz_anno_attributes (name) VALUES (:anno)");
+    stmt.params['anno'] = this._usedPageAttribute;
+    stmt.execute();
+    stmt.reset();
+    stmt.params['anno'] = this._usedItemAttribute;
+    stmt.execute();
+    stmt.reset();
+    stmt.params['anno'] = this._unusedAttribute;
+    stmt.execute();
+    stmt.finalize();
+
+    stmt = mDBConn.createStatement("INSERT INTO moz_annos (place_id, anno_attribute_id) VALUES(:place_id, (SELECT id FROM moz_anno_attributes WHERE name = :anno))");
+    stmt.params['place_id'] = this._placeId;
+    stmt.params['anno'] = this._usedPageAttribute;
+    stmt.execute();
+    stmt.finalize();
+    stmt = mDBConn.createStatement("INSERT INTO moz_items_annos (item_id, anno_attribute_id) VALUES(:item_id, (SELECT id FROM moz_anno_attributes WHERE name = :anno))");
+    stmt.params['item_id'] = this._bookmarkId;
+    stmt.params['anno'] = this._usedItemAttribute;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that used attributes are still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_anno_attributes WHERE name = :anno");
+    stmt.params['anno'] = this._usedPageAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params['anno'] = this._usedItemAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    // Check that unused attribute has been removed
+    stmt.params['anno'] = this._unusedAttribute;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "B.1",
+  desc: "Remove annotations with an invalid attribute",
+
+  _usedPageAttribute: "usedPage",
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Add a used attribute.
+    let stmt = mDBConn.createStatement("INSERT INTO moz_anno_attributes (name) VALUES (:anno)");
+    stmt.params['anno'] = this._usedPageAttribute;
+    stmt.execute();
+    stmt.finalize();
+    stmt = mDBConn.createStatement("INSERT INTO moz_annos (place_id, anno_attribute_id) VALUES(:place_id, (SELECT id FROM moz_anno_attributes WHERE name = :anno))");
+    stmt.params['place_id'] = this._placeId;
+    stmt.params['anno'] = this._usedPageAttribute;
+    stmt.execute();
+    stmt.finalize();
+    // Add an annotation with a nonexistent attribute
+    stmt = mDBConn.createStatement("INSERT INTO moz_annos (place_id, anno_attribute_id) VALUES(:place_id, 1337)");
+    stmt.params['place_id'] = this._placeId;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that used attribute is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_anno_attributes WHERE name = :anno");
+    stmt.params['anno'] = this._usedPageAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // check that annotation with valid attribute is still there
+    stmt = mDBConn.createStatement("SELECT id FROM moz_annos WHERE anno_attribute_id = (SELECT id FROM moz_anno_attributes WHERE name = :anno)");
+    stmt.params['anno'] = this._usedPageAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // Check that annotation with bogus attribute has been removed
+    stmt = mDBConn.createStatement("SELECT id FROM moz_annos WHERE anno_attribute_id = 1337");
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "B.2",
+  desc: "Remove orphan page annotations",
+
+  _usedPageAttribute: "usedPage",
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Add a used attribute.
+    let stmt = mDBConn.createStatement("INSERT INTO moz_anno_attributes (name) VALUES (:anno)");
+    stmt.params['anno'] = this._usedPageAttribute;
+    stmt.execute();
+    stmt.finalize();
+    stmt = mDBConn.createStatement("INSERT INTO moz_annos (place_id, anno_attribute_id) VALUES(:place_id, (SELECT id FROM moz_anno_attributes WHERE name = :anno))");
+    stmt.params['place_id'] = this._placeId;
+    stmt.params['anno'] = this._usedPageAttribute;
+    stmt.execute();
+    stmt.reset();
+    // Add an annotation to a nonexistent page
+    stmt.params['place_id'] = 1337;
+    stmt.params['anno'] = this._usedPageAttribute;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that used attribute is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_anno_attributes WHERE name = :anno");
+    stmt.params['anno'] = this._usedPageAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // check that annotation with valid attribute is still there
+    stmt = mDBConn.createStatement("SELECT id FROM moz_annos WHERE anno_attribute_id = (SELECT id FROM moz_anno_attributes WHERE name = :anno)");
+    stmt.params['anno'] = this._usedPageAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // Check that an annotation to a nonexistent page has been removed
+    stmt = mDBConn.createStatement("SELECT id FROM moz_annos WHERE place_id = 1337");
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+tests.push({
+  name: "C.1",
+  desc: "fix missing Places root",
+
+  setup: function() {
+    // Sanity check: ensure that roots are intact.
+    do_check_eq(bs.getFolderIdForItem(bs.placesRoot), 0);
+    do_check_eq(bs.getFolderIdForItem(bs.bookmarksMenuFolder), bs.placesRoot);
+    do_check_eq(bs.getFolderIdForItem(bs.tagsFolder), bs.placesRoot);
+    do_check_eq(bs.getFolderIdForItem(bs.unfiledBookmarksFolder), bs.placesRoot);
+    do_check_eq(bs.getFolderIdForItem(bs.toolbarFolder), bs.placesRoot);
+
+    // Remove the root.
+    mDBConn.executeSimpleSQL("DELETE FROM moz_bookmarks WHERE parent = 0");
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_bookmarks WHERE parent = 0");
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Ensure the roots have been correctly restored.
+    do_check_eq(bs.getFolderIdForItem(bs.placesRoot), 0);
+    do_check_eq(bs.getFolderIdForItem(bs.bookmarksMenuFolder), bs.placesRoot);
+    do_check_eq(bs.getFolderIdForItem(bs.tagsFolder), bs.placesRoot);
+    do_check_eq(bs.getFolderIdForItem(bs.unfiledBookmarksFolder), bs.placesRoot);
+    do_check_eq(bs.getFolderIdForItem(bs.toolbarFolder), bs.placesRoot);
+  }
+});
+
+// ------------------------------------------------------------------------------
+tests.push({
+  name: "C.2",
+  desc: "Fix roots titles",
+
+  setup: function() {
+    // Sanity check: ensure that roots titles are correct. We can use our check.
+    this.check();
+    // Change some roots' titles.
+    bs.setItemTitle(bs.placesRoot, "bad title");
+    do_check_eq(bs.getItemTitle(bs.placesRoot), "bad title");
+    bs.setItemTitle(bs.unfiledBookmarksFolder, "bad title");
+    do_check_eq(bs.getItemTitle(bs.unfiledBookmarksFolder), "bad title");
+  },
+
+  check: function() {
+    // Ensure all roots titles are correct.
+    do_check_eq(bs.getItemTitle(bs.placesRoot), "");
+    do_check_eq(bs.getItemTitle(bs.bookmarksMenuFolder),
+                PlacesUtils.getString("BookmarksMenuFolderTitle"));
+    do_check_eq(bs.getItemTitle(bs.tagsFolder),
+                PlacesUtils.getString("TagsFolderTitle"));
+    do_check_eq(bs.getItemTitle(bs.unfiledBookmarksFolder),
+                PlacesUtils.getString("OtherBookmarksFolderTitle"));
+    do_check_eq(bs.getItemTitle(bs.toolbarFolder),
+                PlacesUtils.getString("BookmarksToolbarFolderTitle"));
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.1",
+  desc: "Remove items without a valid place",
+
+  _validItemId: null,
+  _invalidItemId: null,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this.placeId = addPlace();
+    // Insert a valid bookmark
+    this._validItemId = addBookmark(this.placeId);
+    // Insert a bookmark with an invalid place
+    this._invalidItemId = addBookmark(1337);
+  },
+
+  check: function() {
+    // Check that valid bookmark is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_bookmarks WHERE id = :item_id");
+    stmt.params["item_id"] = this._validItemId;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    // Check that invalid bookmark has been removed
+    stmt.params["item_id"] = this._invalidItemId;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.2",
+  desc: "Remove items that are not uri bookmarks from tag containers",
+
+  _tagId: null,
+  _bookmarkId: null,
+  _separatorId: null,
+  _folderId: null,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Create a tag
+    this._tagId = addBookmark(null, bs.TYPE_FOLDER, bs.tagsFolder);
+    // Insert a bookmark in the tag
+    this._bookmarkId = addBookmark(this._placeId, bs.TYPE_BOOKMARK, this._tagId);
+    // Insert a separator in the tag
+    this._separatorId = addBookmark(null, bs.TYPE_SEPARATOR, this._tagId);
+    // Insert a folder in the tag
+    this._folderId = addBookmark(null, bs.TYPE_FOLDER, this._tagId);
+  },
+
+  check: function() {
+    // Check that valid bookmark is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_bookmarks WHERE type = :type AND parent = :parent");
+    stmt.params["type"] = bs.TYPE_BOOKMARK;
+    stmt.params["parent"] = this._tagId;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    // Check that separator is no more there
+    stmt.params["type"] = bs.TYPE_SEPARATOR;
+    stmt.params["parent"] = this._tagId;
+    do_check_false(stmt.executeStep());
+    stmt.reset();
+    // Check that folder is no more there
+    stmt.params["type"] = bs.TYPE_FOLDER;
+    stmt.params["parent"] = this._tagId;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.3",
+  desc: "Remove empty tags",
+
+  _tagId: null,
+  _bookmarkId: null,
+  _emptyTagId: null,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Create a tag
+    this._tagId = addBookmark(null, bs.TYPE_FOLDER, bs.tagsFolder);
+    // Insert a bookmark in the tag
+    this._bookmarkId = addBookmark(this._placeId, bs.TYPE_BOOKMARK, this._tagId);
+    // Create another tag (empty)
+    this._emptyTagId = addBookmark(null, bs.TYPE_FOLDER, bs.tagsFolder);
+  },
+
+  check: function() {
+    // Check that valid bookmark is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_bookmarks WHERE id = :id AND type = :type AND parent = :parent");
+    stmt.params["id"] = this._bookmarkId;
+    stmt.params["type"] = bs.TYPE_BOOKMARK;
+    stmt.params["parent"] = this._tagId;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params["id"] = this._tagId;
+    stmt.params["type"] = bs.TYPE_FOLDER;
+    stmt.params["parent"] = bs.tagsFolder;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params["id"] = this._emptyTagId;
+    stmt.params["type"] = bs.TYPE_FOLDER;
+    stmt.params["parent"] = bs.tagsFolder;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.4",
+  desc: "Move orphan items to unsorted folder",
+
+  _orphanBookmarkId: null,
+  _orphanSeparatorId: null,
+  _orphanFolderId: null,
+  _bookmarkId: null,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Insert an orphan bookmark
+    this._orphanBookmarkId = addBookmark(this._placeId, bs.TYPE_BOOKMARK, 8888);
+    // Insert an orphan separator
+    this._orphanSeparatorId = addBookmark(null, bs.TYPE_SEPARATOR, 8888);
+    // Insert a orphan folder
+    this._orphanFolderId = addBookmark(null, bs.TYPE_FOLDER, 8888);
+    // Create a child of the last created folder
+    this._bookmarkId = addBookmark(this._placeId, bs.TYPE_BOOKMARK, this._orphanFolderId);
+  },
+
+  check: function() {
+    // Check that bookmarks are now children of a real folder (unsorted)
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_bookmarks WHERE id = :item_id AND parent = :parent");
+    stmt.params["item_id"] = this._orphanBookmarkId;
+    stmt.params["parent"] = bs.unfiledBookmarksFolder;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params["item_id"] = this._orphanSeparatorId;
+    stmt.params["parent"] = bs.unfiledBookmarksFolder;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params["item_id"] = this._orphanFolderId;
+    stmt.params["parent"] = bs.unfiledBookmarksFolder;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params["item_id"] = this._bookmarkId;
+    stmt.params["parent"] = this._orphanFolderId;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.6",
+  desc: "Fix wrong item types | bookmarks",
+
+  _separatorId: null,
+  _folderId: null,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Add a separator with a fk
+    this._separatorId = addBookmark(this._placeId, bs.TYPE_SEPARATOR);
+    // Add a folder with a fk
+    this._folderId = addBookmark(this._placeId, bs.TYPE_FOLDER);
+  },
+
+  check: function() {
+    // Check that items with an fk have been converted to bookmarks
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_bookmarks WHERE id = :item_id AND type = :type");
+    stmt.params["item_id"] = this._separatorId;
+    stmt.params["type"] = bs.TYPE_BOOKMARK;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params["item_id"] = this._folderId;
+    stmt.params["type"] = bs.TYPE_BOOKMARK;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.7",
+  desc: "Fix wrong item types | bookmarks",
+
+  _validBookmarkId: null,
+  _invalidBookmarkId: null,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Add a bookmark with a valid place id
+    this._validBookmarkId = addBookmark(this._placeId, bs.TYPE_BOOKMARK);
+    // Add a bookmark with a null place id
+    this._invalidBookmarkId = addBookmark(null, bs.TYPE_BOOKMARK);
+  },
+
+  check: function() {
+    // Check valid bookmark
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_bookmarks WHERE id = :item_id AND type = :type");
+    stmt.params["item_id"] = this._validBookmarkId;
+    stmt.params["type"] = bs.TYPE_BOOKMARK;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    // Check invalid bookmark has been converted to a folder
+    stmt.params["item_id"] = this._invalidBookmarkId;
+    stmt.params["type"] = bs.TYPE_FOLDER;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.9",
+  desc: "Fix wrong parents",
+
+  _bookmarkId: null,
+  _separatorId: null,
+  _bookmarkId1: null,
+  _bookmarkId2: null,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Insert a bookmark
+    this._bookmarkId = addBookmark(this._placeId, bs.TYPE_BOOKMARK);
+    // Insert a separator
+    this._separatorId = addBookmark(null, bs.TYPE_SEPARATOR);
+    // Create 3 children of these items
+    this._bookmarkId1 = addBookmark(this._placeId, bs.TYPE_BOOKMARK, this._bookmarkId);
+    this._bookmarkId2 = addBookmark(this._placeId, bs.TYPE_BOOKMARK, this._separatorId);
+  },
+
+  check: function() {
+    // Check that bookmarks are now children of a real folder (unsorted)
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_bookmarks WHERE id = :item_id AND parent = :parent");
+    stmt.params["item_id"] = this._bookmarkId1;
+    stmt.params["parent"] = bs.unfiledBookmarksFolder;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params["item_id"] = this._bookmarkId2;
+    stmt.params["parent"] = bs.unfiledBookmarksFolder;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.10",
+  desc: "Recalculate positions",
+
+  _unfiledBookmarks: [],
+  _toolbarBookmarks: [],
+
+  setup: function() {
+    const NUM_BOOKMARKS = 20;
+    bs.runInBatchMode({
+      runBatched: function (aUserData) {
+        // Add bookmarks to two folders to better perturbate the table.
+        for (let i = 0; i < NUM_BOOKMARKS; i++) {
+          bs.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
+                            NetUtil.newURI("http://example.com/"),
+                            bs.DEFAULT_INDEX, "testbookmark");
+        }
+        for (let i = 0; i < NUM_BOOKMARKS; i++) {
+          bs.insertBookmark(PlacesUtils.toolbarFolderId,
+                            NetUtil.newURI("http://example.com/"),
+                            bs.DEFAULT_INDEX, "testbookmark");
+        }
+      }
+    }, null);
+
+    function randomize_positions(aParent, aResultArray) {
+      let stmt = mDBConn.createStatement(
+        `UPDATE moz_bookmarks SET position = :rand
+         WHERE id IN (
+           SELECT id FROM moz_bookmarks WHERE parent = :parent
+           ORDER BY RANDOM() LIMIT 1
+         )`
+      );
+      for (let i = 0; i < (NUM_BOOKMARKS / 2); i++) {
+        stmt.params["parent"] = aParent;
+        stmt.params["rand"] = Math.round(Math.random() * (NUM_BOOKMARKS - 1));
+        stmt.execute();
+        stmt.reset();
+      }
+      stmt.finalize();
+
+      // Build the expected ordered list of bookmarks.
+      stmt = mDBConn.createStatement(
+        `SELECT id, position
+         FROM moz_bookmarks WHERE parent = :parent
+         ORDER BY position ASC, ROWID ASC`
+      );
+      stmt.params["parent"] = aParent;
+      while (stmt.executeStep()) {
+        aResultArray.push(stmt.row.id);
+        print(stmt.row.id + "\t" + stmt.row.position + "\t" +
+              (aResultArray.length - 1));
+      }
+      stmt.finalize();
+    }
+
+    // Set random positions for the added bookmarks.
+    randomize_positions(PlacesUtils.unfiledBookmarksFolderId,
+                        this._unfiledBookmarks);
+    randomize_positions(PlacesUtils.toolbarFolderId, this._toolbarBookmarks);
+  },
+
+  check: function() {
+    function check_order(aParent, aResultArray) {
+      // Build the expected ordered list of bookmarks.
+      let stmt = mDBConn.createStatement(
+        `SELECT id, position FROM moz_bookmarks WHERE parent = :parent
+         ORDER BY position ASC`
+      );
+      stmt.params["parent"] = aParent;
+      let pass = true;
+      while (stmt.executeStep()) {
+        print(stmt.row.id + "\t" + stmt.row.position);
+        if (aResultArray.indexOf(stmt.row.id) != stmt.row.position) {
+          pass = false;
+        }
+      }
+      stmt.finalize();
+      if (!pass) {
+        dump_table("moz_bookmarks");
+        do_throw("Unexpected unfiled bookmarks order.");
+      }
+    }
+
+    check_order(PlacesUtils.unfiledBookmarksFolderId, this._unfiledBookmarks);
+    check_order(PlacesUtils.toolbarFolderId, this._toolbarBookmarks);
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "D.12",
+  desc: "Fix empty-named tags",
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    let placeId = addPlace();
+    // Create a empty-named tag.
+    this._untitledTagId = addBookmark(null, bs.TYPE_FOLDER, bs.tagsFolder, null, null, "");
+    // Insert a bookmark in the tag, otherwise it will be removed.
+    addBookmark(placeId, bs.TYPE_BOOKMARK, this._untitledTagId);
+    // Create a empty-named folder.
+    this._untitledFolderId = addBookmark(null, bs.TYPE_FOLDER, bs.toolbarFolder, null, null, "");
+    // Create a titled tag.
+    this._titledTagId = addBookmark(null, bs.TYPE_FOLDER, bs.tagsFolder, null, null, "titledTag");
+    // Insert a bookmark in the tag, otherwise it will be removed.
+    addBookmark(placeId, bs.TYPE_BOOKMARK, this._titledTagId);
+    // Create a titled folder.
+    this._titledFolderId = addBookmark(null, bs.TYPE_FOLDER, bs.toolbarFolder, null, null, "titledFolder");
+  },
+
+  check: function() {
+    // Check that valid bookmark is still there
+    let stmt = mDBConn.createStatement(
+      "SELECT title FROM moz_bookmarks WHERE id = :id"
+    );
+    stmt.params["id"] = this._untitledTagId;
+    do_check_true(stmt.executeStep());
+    do_check_eq(stmt.row.title, "(notitle)");
+    stmt.reset();
+    stmt.params["id"] = this._untitledFolderId;
+    do_check_true(stmt.executeStep());
+    do_check_eq(stmt.row.title, "");
+    stmt.reset();
+    stmt.params["id"] = this._titledTagId;
+    do_check_true(stmt.executeStep());
+    do_check_eq(stmt.row.title, "titledTag");
+    stmt.reset();
+    stmt.params["id"] = this._titledFolderId;
+    do_check_true(stmt.executeStep());
+    do_check_eq(stmt.row.title, "titledFolder");
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "E.1",
+  desc: "Remove orphan icons",
+
+  _placeId: null,
+
+  setup: function() {
+    // Insert favicon entries
+    let stmt = mDBConn.createStatement("INSERT INTO moz_favicons (id, url) VALUES(:favicon_id, :url)");
+    stmt.params["favicon_id"] = 1;
+    stmt.params["url"] = "http://www1.mozilla.org/favicon.ico";
+    stmt.execute();
+    stmt.reset();
+    stmt.params["favicon_id"] = 2;
+    stmt.params["url"] = "http://www2.mozilla.org/favicon.ico";
+    stmt.execute();
+    stmt.finalize();
+    // Insert a place using the existing favicon entry
+    this._placeId = addPlace("http://www.mozilla.org", 1);
+  },
+
+  check: function() {
+    // Check that used icon is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_favicons WHERE id = :favicon_id");
+    stmt.params["favicon_id"] = 1;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    // Check that unused icon has been removed
+    stmt.params["favicon_id"] = 2;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "F.1",
+  desc: "Remove orphan visits",
+
+  _placeId: null,
+  _invalidPlaceId: 1337,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Add a valid visit and an invalid one
+    stmt = mDBConn.createStatement("INSERT INTO moz_historyvisits(place_id) VALUES (:place_id)");
+    stmt.params["place_id"] = this._placeId;
+    stmt.execute();
+    stmt.reset();
+    stmt.params["place_id"] = this._invalidPlaceId;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that valid visit is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_historyvisits WHERE place_id = :place_id");
+    stmt.params["place_id"] = this._placeId;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    // Check that invalid visit has been removed
+    stmt.params["place_id"] = this._invalidPlaceId;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "G.1",
+  desc: "Remove orphan input history",
+
+  _placeId: null,
+  _invalidPlaceId: 1337,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Add input history entries
+    let stmt = mDBConn.createStatement("INSERT INTO moz_inputhistory (place_id, input) VALUES (:place_id, :input)");
+    stmt.params["place_id"] = this._placeId;
+    stmt.params["input"] = "moz";
+    stmt.execute();
+    stmt.reset();
+    stmt.params["place_id"] = this._invalidPlaceId;
+    stmt.params["input"] = "moz";
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that inputhistory on valid place is still there
+    let stmt = mDBConn.createStatement("SELECT place_id FROM moz_inputhistory WHERE place_id = :place_id");
+    stmt.params["place_id"] = this._placeId;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    // Check that inputhistory on invalid place has gone
+    stmt.params["place_id"] = this._invalidPlaceId;
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "H.1",
+  desc: "Remove item annos with an invalid attribute",
+
+  _usedItemAttribute: "usedItem",
+  _bookmarkId: null,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Insert a bookmark
+    this._bookmarkId = addBookmark(this._placeId);
+    // Add a used attribute.
+    let stmt = mDBConn.createStatement("INSERT INTO moz_anno_attributes (name) VALUES (:anno)");
+    stmt.params['anno'] = this._usedItemAttribute;
+    stmt.execute();
+    stmt.finalize();
+    stmt = mDBConn.createStatement("INSERT INTO moz_items_annos (item_id, anno_attribute_id) VALUES(:item_id, (SELECT id FROM moz_anno_attributes WHERE name = :anno))");
+    stmt.params['item_id'] = this._bookmarkId;
+    stmt.params['anno'] = this._usedItemAttribute;
+    stmt.execute();
+    stmt.finalize();
+    // Add an annotation with a nonexistent attribute
+    stmt = mDBConn.createStatement("INSERT INTO moz_items_annos (item_id, anno_attribute_id) VALUES(:item_id, 1337)");
+    stmt.params['item_id'] = this._bookmarkId;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that used attribute is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_anno_attributes WHERE name = :anno");
+    stmt.params['anno'] = this._usedItemAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // check that annotation with valid attribute is still there
+    stmt = mDBConn.createStatement("SELECT id FROM moz_items_annos WHERE anno_attribute_id = (SELECT id FROM moz_anno_attributes WHERE name = :anno)");
+    stmt.params['anno'] = this._usedItemAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // Check that annotation with bogus attribute has been removed
+    stmt = mDBConn.createStatement("SELECT id FROM moz_items_annos WHERE anno_attribute_id = 1337");
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "H.2",
+  desc: "Remove orphan item annotations",
+
+  _usedItemAttribute: "usedItem",
+  _bookmarkId: null,
+  _invalidBookmarkId: 8888,
+  _placeId: null,
+
+  setup: function() {
+    // Add a place to ensure place_id = 1 is valid
+    this._placeId = addPlace();
+    // Insert a bookmark
+    this._bookmarkId = addBookmark(this._placeId);
+    // Add a used attribute.
+    stmt = mDBConn.createStatement("INSERT INTO moz_anno_attributes (name) VALUES (:anno)");
+    stmt.params['anno'] = this._usedItemAttribute;
+    stmt.execute();
+    stmt.finalize();
+    stmt = mDBConn.createStatement("INSERT INTO moz_items_annos (item_id, anno_attribute_id) VALUES (:item_id, (SELECT id FROM moz_anno_attributes WHERE name = :anno))");
+    stmt.params["item_id"] = this._bookmarkId;
+    stmt.params["anno"] = this._usedItemAttribute;
+    stmt.execute();
+    stmt.reset();
+    // Add an annotation to a nonexistent item
+    stmt.params["item_id"] = this._invalidBookmarkId;
+    stmt.params["anno"] = this._usedItemAttribute;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that used attribute is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_anno_attributes WHERE name = :anno");
+    stmt.params['anno'] = this._usedItemAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // check that annotation with valid attribute is still there
+    stmt = mDBConn.createStatement("SELECT id FROM moz_items_annos WHERE anno_attribute_id = (SELECT id FROM moz_anno_attributes WHERE name = :anno)");
+    stmt.params['anno'] = this._usedItemAttribute;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // Check that an annotation to a nonexistent page has been removed
+    stmt = mDBConn.createStatement("SELECT id FROM moz_items_annos WHERE item_id = 8888");
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "I.1",
+  desc: "Remove unused keywords",
+
+  _bookmarkId: null,
+  _placeId: null,
+
+  setup: function() {
+    // Insert 2 keywords
+    let stmt = mDBConn.createStatement("INSERT INTO moz_keywords (id, keyword, place_id) VALUES(:id, :keyword, :place_id)");
+    stmt.params["id"] = 1;
+    stmt.params["keyword"] = "unused";
+    stmt.params["place_id"] = 100;
+    stmt.execute();
+    stmt.finalize();
+  },
+
+  check: function() {
+    // Check that "used" keyword is still there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_keywords WHERE keyword = :keyword");
+    // Check that "unused" keyword has gone
+    stmt.params["keyword"] = "unused";
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "L.1",
+  desc: "Fix wrong favicon ids",
+
+  _validIconPlaceId: null,
+  _invalidIconPlaceId: null,
+
+  setup: function() {
+    // Insert a favicon entry
+    let stmt = mDBConn.createStatement("INSERT INTO moz_favicons (id, url) VALUES(1, :url)");
+    stmt.params["url"] = "http://www.mozilla.org/favicon.ico";
+    stmt.execute();
+    stmt.finalize();
+    // Insert a place using the existing favicon entry
+    this._validIconPlaceId = addPlace("http://www1.mozilla.org", 1);
+
+    // Insert a place using a nonexistent favicon entry
+    this._invalidIconPlaceId = addPlace("http://www2.mozilla.org", 1337);
+  },
+
+  check: function() {
+    // Check that bogus favicon is not there
+    let stmt = mDBConn.createStatement("SELECT id FROM moz_places WHERE favicon_id = :favicon_id");
+    stmt.params["favicon_id"] = 1337;
+    do_check_false(stmt.executeStep());
+    stmt.reset();
+    // Check that valid favicon is still there
+    stmt.params["favicon_id"] = 1;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+    // Check that place entries are there
+    stmt = mDBConn.createStatement("SELECT id FROM moz_places WHERE id = :place_id");
+    stmt.params["place_id"] = this._validIconPlaceId;
+    do_check_true(stmt.executeStep());
+    stmt.reset();
+    stmt.params["place_id"] = this._invalidIconPlaceId;
+    do_check_true(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "L.2",
+  desc: "Recalculate visit_count and last_visit_date",
+
+  setup: function* () {
+    function setVisitCount(aURL, aValue) {
+      let stmt = mDBConn.createStatement(
+        `UPDATE moz_places SET visit_count = :count WHERE url_hash = hash(:url)
+                                                      AND url = :url`
+      );
+      stmt.params.count = aValue;
+      stmt.params.url = aURL;
+      stmt.execute();
+      stmt.finalize();
+    }
+    function setLastVisitDate(aURL, aValue) {
+      let stmt = mDBConn.createStatement(
+        `UPDATE moz_places SET last_visit_date = :date WHERE url_hash = hash(:url)
+                                                         AND url = :url`
+      );
+      stmt.params.date = aValue;
+      stmt.params.url = aURL;
+      stmt.execute();
+      stmt.finalize();
+    }
+
+    let now = Date.now() * 1000;
+    // Add a page with 1 visit.
+    let url = "http://1.moz.org/";
+    yield PlacesTestUtils.addVisits({ uri: uri(url), visitDate: now++ });
+    // Add a page with 1 visit and set wrong visit_count.
+    url = "http://2.moz.org/";
+    yield PlacesTestUtils.addVisits({ uri: uri(url), visitDate: now++ });
+    setVisitCount(url, 10);
+    // Add a page with 1 visit and set wrong last_visit_date.
+    url = "http://3.moz.org/";
+    yield PlacesTestUtils.addVisits({ uri: uri(url), visitDate: now++ });
+    setLastVisitDate(url, now++);
+    // Add a page with 1 visit and set wrong stats.
+    url = "http://4.moz.org/";
+    yield PlacesTestUtils.addVisits({ uri: uri(url), visitDate: now++ });
+    setVisitCount(url, 10);
+    setLastVisitDate(url, now++);
+
+    // Add a page without visits.
+    url = "http://5.moz.org/";
+    addPlace(url);
+    // Add a page without visits and set wrong visit_count.
+    url = "http://6.moz.org/";
+    addPlace(url);
+    setVisitCount(url, 10);
+    // Add a page without visits and set wrong last_visit_date.
+    url = "http://7.moz.org/";
+    addPlace(url);
+    setLastVisitDate(url, now++);
+    // Add a page without visits and set wrong stats.
+    url = "http://8.moz.org/";
+    addPlace(url);
+    setVisitCount(url, 10);
+    setLastVisitDate(url, now++);
+  },
+
+  check: function() {
+    let stmt = mDBConn.createStatement(
+      `SELECT h.id FROM moz_places h
+       JOIN moz_historyvisits v ON v.place_id = h.id AND visit_type NOT IN (0,4,7,8,9)
+       GROUP BY h.id HAVING h.visit_count <> count(*)
+       UNION ALL
+       SELECT h.id FROM moz_places h
+       JOIN moz_historyvisits v ON v.place_id = h.id
+       GROUP BY h.id HAVING h.last_visit_date <> MAX(v.visit_date)`
+    );
+    do_check_false(stmt.executeStep());
+    stmt.finalize();
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "L.3",
+  desc: "recalculate hidden for redirects.",
+
+  *setup() {
+    yield PlacesTestUtils.addVisits([
+      { uri: NetUtil.newURI("http://l3.moz.org/"),
+        transition: TRANSITION_TYPED },
+      { uri: NetUtil.newURI("http://l3.moz.org/redirecting/"),
+        transition: TRANSITION_TYPED },
+      { uri: NetUtil.newURI("http://l3.moz.org/redirecting2/"),
+        transition: TRANSITION_REDIRECT_TEMPORARY,
+        referrer: NetUtil.newURI("http://l3.moz.org/redirecting/") },
+      { uri: NetUtil.newURI("http://l3.moz.org/target/"),
+        transition: TRANSITION_REDIRECT_PERMANENT,
+        referrer: NetUtil.newURI("http://l3.moz.org/redirecting2/") },
+    ]);
+  },
+
+  check: function () {
+    return new Promise(resolve => {
+      let stmt = mDBConn.createAsyncStatement(
+        "SELECT h.url FROM moz_places h WHERE h.hidden = 1"
+      );
+      stmt.executeAsync({
+        _count: 0,
+        handleResult: function(aResultSet) {
+          for (let row; (row = aResultSet.getNextRow());) {
+            let url = row.getResultByIndex(0);
+            do_check_true(/redirecting/.test(url));
+            this._count++;
+          }
+        },
+        handleError: function(aError) {
+        },
+        handleCompletion: function(aReason) {
+          dump_table("moz_places");
+          dump_table("moz_historyvisits");
+          do_check_eq(aReason, Ci.mozIStorageStatementCallback.REASON_FINISHED);
+          do_check_eq(this._count, 2);
+          resolve();
+        }
+      });
+      stmt.finalize();
+    });
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "L.4",
+  desc: "recalculate foreign_count.",
+
+  *setup() {
+    this._pageGuid = (yield PlacesUtils.history.insert({ url: "http://l4.moz.org/",
+                                                         visits: [{ date: new Date() }] })).guid;
+    yield PlacesUtils.bookmarks.insert({ url: "http://l4.moz.org/",
+                                         parentGuid: PlacesUtils.bookmarks.unfiledGuid});
+    yield PlacesUtils.keywords.insert({ url: "http://l4.moz.org/", keyword: "kw" });
+    Assert.equal((yield this._getForeignCount()), 2);
+  },
+
+  *_getForeignCount() {
+    let db = yield PlacesUtils.promiseDBConnection();
+    let rows = yield db.execute(`SELECT foreign_count FROM moz_places
+                                 WHERE guid = :guid`, { guid: this._pageGuid });
+    return rows[0].getResultByName("foreign_count");
+  },
+
+  *check() {
+    Assert.equal((yield this._getForeignCount()), 2);
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "L.5",
+  desc: "recalculate hashes when missing.",
+
+  *setup() {
+    this._pageGuid = (yield PlacesUtils.history.insert({ url: "http://l5.moz.org/",
+                                                         visits: [{ date: new Date() }] })).guid;
+    Assert.ok((yield this._getHash()) > 0);
+    yield PlacesUtils.withConnectionWrapper("change url hash", Task.async(function* (db) {
+      yield db.execute(`UPDATE moz_places SET url_hash = 0`);
+    }));
+    Assert.equal((yield this._getHash()), 0);
+  },
+
+  *_getHash() {
+    let db = yield PlacesUtils.promiseDBConnection();
+    let rows = yield db.execute(`SELECT url_hash FROM moz_places
+                                 WHERE guid = :guid`, { guid: this._pageGuid });
+    return rows[0].getResultByName("url_hash");
+  },
+
+  *check() {
+    Assert.ok((yield this._getHash()) > 0);
+  }
+});
+
+// ------------------------------------------------------------------------------
+
+tests.push({
+  name: "Z",
+  desc: "Sanity: Preventive maintenance does not touch valid items",
+
+  _uri1: uri("http://www1.mozilla.org"),
+  _uri2: uri("http://www2.mozilla.org"),
+  _folderId: null,
+  _bookmarkId: null,
+  _separatorId: null,
+
+  setup: function* () {
+    // use valid api calls to create a bunch of items
+    yield PlacesTestUtils.addVisits([
+      { uri: this._uri1 },
+      { uri: this._uri2 },
+    ]);
+
+    this._folderId = bs.createFolder(bs.toolbarFolder, "testfolder",
+                                     bs.DEFAULT_INDEX);
+    do_check_true(this._folderId > 0);
+    this._bookmarkId = bs.insertBookmark(this._folderId, this._uri1,
+                                         bs.DEFAULT_INDEX, "testbookmark");
+    do_check_true(this._bookmarkId > 0);
+    this._separatorId = bs.insertSeparator(bs.unfiledBookmarksFolder,
+                                           bs.DEFAULT_INDEX);
+    do_check_true(this._separatorId > 0);
+    ts.tagURI(this._uri1, ["testtag"]);
+    fs.setAndFetchFaviconForPage(this._uri2, SMALLPNG_DATA_URI, false,
+                                 PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+                                 null,
+                                 Services.scriptSecurityManager.getSystemPrincipal());
+    yield PlacesUtils.keywords.insert({ url: this._uri1.spec, keyword: "testkeyword" });
+    as.setPageAnnotation(this._uri2, "anno", "anno", 0, as.EXPIRE_NEVER);
+    as.setItemAnnotation(this._bookmarkId, "anno", "anno", 0, as.EXPIRE_NEVER);
+  },
+
+  check: Task.async(function* () {
+    // Check that all items are correct
+    let isVisited = yield promiseIsURIVisited(this._uri1);
+    do_check_true(isVisited);
+    isVisited = yield promiseIsURIVisited(this._uri2);
+    do_check_true(isVisited);
+
+    do_check_eq(bs.getBookmarkURI(this._bookmarkId).spec, this._uri1.spec);
+    do_check_eq(bs.getItemIndex(this._folderId), 0);
+    do_check_eq(bs.getItemType(this._folderId), bs.TYPE_FOLDER);
+    do_check_eq(bs.getItemType(this._separatorId), bs.TYPE_SEPARATOR);
+
+    do_check_eq(ts.getTagsForURI(this._uri1).length, 1);
+    do_check_eq((yield PlacesUtils.keywords.fetch({ url: this._uri1.spec })).keyword, "testkeyword");
+    do_check_eq(as.getPageAnnotation(this._uri2, "anno"), "anno");
+    do_check_eq(as.getItemAnnotation(this._bookmarkId, "anno"), "anno");
+
+    yield new Promise(resolve => {
+      fs.getFaviconURLForPage(this._uri2, aFaviconURI => {
+        do_check_true(aFaviconURI.equals(SMALLPNG_DATA_URI));
+        resolve();
+      });
+    });
+  })
+});
+
+// ------------------------------------------------------------------------------
+
+add_task(function* test_preventive_maintenance()
+{
+  // Get current bookmarks max ID for cleanup
+  let stmt = mDBConn.createStatement("SELECT MAX(id) FROM moz_bookmarks");
+  stmt.executeStep();
+  defaultBookmarksMaxId = stmt.getInt32(0);
+  stmt.finalize();
+  do_check_true(defaultBookmarksMaxId > 0);
+
+  for (let test of tests) {
+    dump("\nExecuting test: " + test.name + "\n" + "*** " + test.desc + "\n");
+    yield test.setup();
+
+    let promiseMaintenanceFinished =
+        promiseTopicObserved(FINISHED_MAINTENANCE_NOTIFICATION_TOPIC);
+    Services.prefs.clearUserPref("places.database.lastMaintenance");
+    let callbackInvoked = false;
+    PlacesDBUtils.maintenanceOnIdle(() => callbackInvoked = true);
+    yield promiseMaintenanceFinished;
+    do_check_true(callbackInvoked);
+
+    // Check the lastMaintenance time has been saved.
+    do_check_neq(Services.prefs.getIntPref("places.database.lastMaintenance"), null);
+
+    yield test.check();
+
+    cleanDatabase();
+  }
+
+  // Sanity check: all roots should be intact
+  do_check_eq(bs.getFolderIdForItem(bs.placesRoot), 0);
+  do_check_eq(bs.getFolderIdForItem(bs.bookmarksMenuFolder), bs.placesRoot);
+  do_check_eq(bs.getFolderIdForItem(bs.tagsFolder), bs.placesRoot);
+  do_check_eq(bs.getFolderIdForItem(bs.unfiledBookmarksFolder), bs.placesRoot);
+  do_check_eq(bs.getFolderIdForItem(bs.toolbarFolder), bs.placesRoot);
+});
diff --git a/toolkit/components/places/tests/unit/test_preventive_maintenance_checkAndFixDatabase.js b/toolkit/components/places/tests/unit/test_preventive_maintenance_checkAndFixDatabase.js
new file mode 100644
index 000000000..a8acb4be0
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_preventive_maintenance_checkAndFixDatabase.js
@@ -0,0 +1,50 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+ /**
+  * Test preventive maintenance checkAndFixDatabase.
+  */
+
+// Include PlacesDBUtils module.
+Components.utils.import("resource://gre/modules/PlacesDBUtils.jsm");
+
+function run_test() {
+  do_test_pending();
+  PlacesDBUtils.checkAndFixDatabase(function(aLog) {
+    let sections = [];
+    let positives = [];
+    let negatives = [];
+    let infos = [];
+
+    aLog.forEach(function (aMsg) {
+      print (aMsg);
+      switch (aMsg.substr(0, 1)) {
+        case "+":
+          positives.push(aMsg);
+          break;
+        case "-":
+          negatives.push(aMsg);
+          break;
+        case ">":
+          sections.push(aMsg);
+          break;
+        default:
+          infos.push(aMsg);
+      }
+    });
+
+    print("Check that we have run all sections.");
+    do_check_eq(sections.length, 5);
+    print("Check that we have no negatives.");
+    do_check_false(!!negatives.length);
+    print("Check that we have positives.");
+    do_check_true(!!positives.length);
+    print("Check that we have info.");
+    do_check_true(!!infos.length);
+
+    do_test_finished();
+  });
+}
diff --git a/toolkit/components/places/tests/unit/test_preventive_maintenance_runTasks.js b/toolkit/components/places/tests/unit/test_preventive_maintenance_runTasks.js
new file mode 100644
index 000000000..ebe308f03
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_preventive_maintenance_runTasks.js
@@ -0,0 +1,46 @@
+/* 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/. */
+
+ /**
+  * Test preventive maintenance runTasks.
+  */
+
+// Include PlacesDBUtils module.
+Components.utils.import("resource://gre/modules/PlacesDBUtils.jsm");
+
+function run_test() {
+  do_test_pending();
+  PlacesDBUtils.runTasks([PlacesDBUtils.reindex], function(aLog) {
+    let sections = [];
+    let positives = [];
+    let negatives = [];
+    let infos = [];
+
+    aLog.forEach(function (aMsg) {
+      print (aMsg);
+      switch (aMsg.substr(0, 1)) {
+        case "+":
+          positives.push(aMsg);
+          break;
+        case "-":
+          negatives.push(aMsg);
+          break;
+        case ">":
+          sections.push(aMsg);
+          break;
+        default:
+          infos.push(aMsg);
+      }
+    });
+
+    print("Check that we have run all sections.");
+    do_check_eq(sections.length, 1);
+    print("Check that we have no negatives.");
+    do_check_false(!!negatives.length);
+    print("Check that we have positives.");
+    do_check_true(!!positives.length);
+
+    do_test_finished();
+  });
+}
diff --git a/toolkit/components/places/tests/unit/test_promiseBookmarksTree.js b/toolkit/components/places/tests/unit/test_promiseBookmarksTree.js
new file mode 100644
index 000000000..0719a0cd4
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_promiseBookmarksTree.js
@@ -0,0 +1,256 @@
+/* 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/. */
+
+function* check_has_child(aParentGuid, aChildGuid) {
+  let parentTree = yield PlacesUtils.promiseBookmarksTree(aParentGuid);
+  do_check_true("children" in parentTree);
+  do_check_true(parentTree.children.find( e => e.guid == aChildGuid ) != null);
+}
+
+function* compareToNode(aItem, aNode, aIsRootItem, aExcludedGuids = []) {
+  // itemId==-1 indicates a non-bookmark node, which is unexpected.
+  do_check_neq(aNode.itemId, -1);
+
+  function check_unset(...aProps) {
+    aProps.forEach( p => { do_check_false(p in aItem); } );
+  }
+  function strict_eq_check(v1, v2) {
+    dump("v1: " + v1 + " v2: " + v2 + "\n");
+    do_check_eq(typeof v1, typeof v2);
+    do_check_eq(v1, v2);
+  }
+  function compare_prop(aItemProp, aNodeProp = aItemProp, aOptional = false) {
+    if (aOptional && aNode[aNodeProp] === null)
+      check_unset(aItemProp);
+    else
+      strict_eq_check(aItem[aItemProp], aNode[aNodeProp]);
+  }
+  function compare_prop_to_value(aItemProp, aValue, aOptional = true) {
+    if (aOptional && aValue === null)
+      check_unset(aItemProp);
+    else
+      strict_eq_check(aItem[aItemProp], aValue);
+  }
+
+  // Bug 1013053 - bookmarkIndex is unavailable for the query's root
+  if (aNode.bookmarkIndex == -1) {
+    compare_prop_to_value("index",
+                          PlacesUtils.bookmarks.getItemIndex(aNode.itemId),
+                          false);
+  }
+  else {
+    compare_prop("index", "bookmarkIndex");
+  }
+
+  compare_prop("dateAdded");
+  compare_prop("lastModified");
+
+  if (aIsRootItem && aNode.itemId != PlacesUtils.placesRootId) {
+    do_check_true("parentGuid" in aItem);
+    yield check_has_child(aItem.parentGuid, aItem.guid)
+  }
+  else {
+    check_unset("parentGuid");
+  }
+
+  let expectedAnnos = PlacesUtils.getAnnotationsForItem(aItem.id);
+  if (expectedAnnos.length > 0) {
+    let annosToString = annos => {
+      return annos.map(a => a.name + ":" + a.value).sort().join(",");
+    };
+    do_check_true(Array.isArray(aItem.annos))
+    do_check_eq(annosToString(aItem.annos), annosToString(expectedAnnos));
+  }
+  else {
+    check_unset("annos");
+  }
+  const BOOKMARK_ONLY_PROPS = ["uri", "iconuri", "tags", "charset", "keyword"];
+  const FOLDER_ONLY_PROPS = ["children", "root"];
+
+  let nodesCount = 1;
+
+  switch (aNode.type) {
+    case Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER:
+      do_check_eq(aItem.type, PlacesUtils.TYPE_X_MOZ_PLACE_CONTAINER);
+      compare_prop("title", "title", true);
+      check_unset(...BOOKMARK_ONLY_PROPS);
+
+      let expectedChildrenNodes = [];
+
+      PlacesUtils.asContainer(aNode);
+      if (!aNode.containerOpen)
+        aNode.containerOpen = true;
+
+      for (let i = 0; i < aNode.childCount; i++) {
+        let childNode = aNode.getChild(i);
+        if (childNode.itemId == PlacesUtils.tagsFolderId ||
+            aExcludedGuids.includes(childNode.bookmarkGuid)) {
+          continue;
+        }
+        expectedChildrenNodes.push(childNode);
+      }
+
+      if (expectedChildrenNodes.length > 0) {
+        do_check_true(Array.isArray(aItem.children));
+        do_check_eq(aItem.children.length, expectedChildrenNodes.length);
+        for (let i = 0; i < aItem.children.length; i++) {
+          nodesCount +=
+            yield compareToNode(aItem.children[i], expectedChildrenNodes[i],
+                                false, aExcludedGuids);
+        }
+      }
+      else {
+        check_unset("children");
+      }
+
+      switch (aItem.id) {
+      case PlacesUtils.placesRootId:
+        compare_prop_to_value("root", "placesRoot");
+        break;
+      case PlacesUtils.bookmarksMenuFolderId:
+        compare_prop_to_value("root", "bookmarksMenuFolder");
+        break;
+      case PlacesUtils.toolbarFolderId:
+        compare_prop_to_value("root", "toolbarFolder");
+        break;
+      case PlacesUtils.unfiledBookmarksFolderId:
+        compare_prop_to_value("root", "unfiledBookmarksFolder");
+        break;
+      case PlacesUtils.mobileFolderId:
+        compare_prop_to_value("root", "mobileFolder");
+        break;
+      default:
+        check_unset("root");
+      }
+      break;
+    case Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR:
+      do_check_eq(aItem.type, PlacesUtils.TYPE_X_MOZ_PLACE_SEPARATOR);
+      check_unset(...BOOKMARK_ONLY_PROPS, ...FOLDER_ONLY_PROPS);
+      break;
+    default:
+      do_check_eq(aItem.type, PlacesUtils.TYPE_X_MOZ_PLACE);
+      compare_prop("uri");
+      // node.tags's format is "a, b" whilst promiseBoookmarksTree is "a,b"
+      if (aNode.tags === null)
+        check_unset("tags");
+      else
+        compare_prop_to_value("tags", aNode.tags.replace(/, /g, ","), false);
+
+      if (aNode.icon) {
+        let nodeIconData = aNode.icon.replace("moz-anno:favicon:", "");
+        compare_prop_to_value("iconuri", nodeIconData);
+      }
+      else {
+        check_unset(aItem.iconuri);
+      }
+
+      check_unset(...FOLDER_ONLY_PROPS);
+
+      let itemURI = uri(aNode.uri);
+      compare_prop_to_value("charset",
+                            yield PlacesUtils.getCharsetForURI(itemURI));
+
+      let entry = yield PlacesUtils.keywords.fetch({ url: aNode.uri });
+      compare_prop_to_value("keyword", entry ? entry.keyword : null);
+
+      if ("title" in aItem)
+        compare_prop("title");
+      else
+        do_check_null(aNode.title);
+  }
+
+  if (aIsRootItem)
+    do_check_eq(aItem.itemsCount, nodesCount);
+
+  return nodesCount;
+}
+
+var itemsCount = 0;
+function* new_bookmark(aInfo) {
+  ++itemsCount;
+  if (!("url" in aInfo))
+    aInfo.url = uri("http://test.item." + itemsCount);
+
+  if (!("title" in aInfo))
+    aInfo.title = "Test Item (bookmark) " + itemsCount;
+
+  yield PlacesTransactions.NewBookmark(aInfo).transact();
+}
+
+function* new_folder(aInfo) {
+  if (!("title" in aInfo))
+    aInfo.title = "Test Item (folder) " + itemsCount;
+  return yield PlacesTransactions.NewFolder(aInfo).transact();
+}
+
+// Walks a result nodes tree and test promiseBookmarksTree for each node.
+// DO NOT COPY THIS LOGIC:  It is done here to accomplish a more comprehensive
+// test of the API (the entire hierarchy data is available in the very test).
+function* test_promiseBookmarksTreeForEachNode(aNode, aOptions, aExcludedGuids) {
+  do_check_true(aNode.bookmarkGuid && aNode.bookmarkGuid.length > 0);
+  let item = yield PlacesUtils.promiseBookmarksTree(aNode.bookmarkGuid, aOptions);
+  yield* compareToNode(item, aNode, true, aExcludedGuids);
+
+  for (let i = 0; i < aNode.childCount; i++) {
+    let child = aNode.getChild(i);
+    if (child.itemId != PlacesUtils.tagsFolderId)
+      yield test_promiseBookmarksTreeForEachNode(child,
+                                                 { includeItemIds: true },
+                                                 aExcludedGuids);
+  }
+  return item;
+}
+
+function* test_promiseBookmarksTreeAgainstResult(aItemGuid = "",
+                                                 aOptions = { includeItemIds: true },
+                                                 aExcludedGuids) {
+  let itemId = aItemGuid ?
+    yield PlacesUtils.promiseItemId(aItemGuid) : PlacesUtils.placesRootId;
+  let node = PlacesUtils.getFolderContents(itemId).root;
+  return yield test_promiseBookmarksTreeForEachNode(node, aOptions, aExcludedGuids);
+}
+
+add_task(function* () {
+  // Add some bookmarks to cover various use cases.
+  yield new_bookmark({ parentGuid: PlacesUtils.bookmarks.toolbarGuid });
+  yield new_folder({ parentGuid: PlacesUtils.bookmarks.menuGuid,
+                     annotations: [{ name: "TestAnnoA", value: "TestVal" },
+                                   { name: "TestAnnoB", value: 0 }]});
+  let sepInfo = { parentGuid: PlacesUtils.bookmarks.menuGuid };
+  yield PlacesTransactions.NewSeparator(sepInfo).transact();
+  let folderGuid = yield new_folder({ parentGuid: PlacesUtils.bookmarks.menuGuid });
+  yield new_bookmark({ title: null,
+                       parentGuid: folderGuid,
+                       keyword: "test_keyword",
+                       tags: ["TestTagA", "TestTagB"],
+                       annotations: [{ name: "TestAnnoA", value: "TestVal2"}]});
+  let urlWithCharsetAndFavicon = uri("http://charset.and.favicon");
+  yield new_bookmark({ parentGuid: folderGuid, url: urlWithCharsetAndFavicon });
+  yield PlacesUtils.setCharsetForURI(urlWithCharsetAndFavicon, "UTF-8");
+  yield promiseSetIconForPage(urlWithCharsetAndFavicon, SMALLPNG_DATA_URI);
+  // Test the default places root without specifying it.
+  yield test_promiseBookmarksTreeAgainstResult();
+
+  // Do specify it
+  yield test_promiseBookmarksTreeAgainstResult(PlacesUtils.bookmarks.rootGuid);
+
+  // Exclude the bookmarks menu.
+  // The calllback should be four times - once for the toolbar, once for
+  // the bookmark we inserted under, and once for the menu (and not
+  // at all for any of its descendants) and once for the unsorted bookmarks
+  // folder.  However, promiseBookmarksTree is called multiple times, so
+  // rather than counting the calls, we count the number of unique items
+  // passed in.
+  let guidsPassedToExcludeCallback = new Set();
+  let placesRootWithoutTheMenu =
+  yield test_promiseBookmarksTreeAgainstResult(PlacesUtils.bookmarks.rootGuid, {
+    excludeItemsCallback: aItem =>  {
+      guidsPassedToExcludeCallback.add(aItem.guid);
+      return aItem.root == "bookmarksMenuFolder";
+    },
+    includeItemIds: true
+  }, [PlacesUtils.bookmarks.menuGuid]);
+  do_check_eq(guidsPassedToExcludeCallback.size, 5);
+  do_check_eq(placesRootWithoutTheMenu.children.length, 3);
+});
diff --git a/toolkit/components/places/tests/unit/test_resolveNullBookmarkTitles.js b/toolkit/components/places/tests/unit/test_resolveNullBookmarkTitles.js
new file mode 100644
index 000000000..01fb3eef9
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_resolveNullBookmarkTitles.js
@@ -0,0 +1,49 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+function run_test() {
+  run_next_test();
+}
+
+add_test(function test_resolveNullBookmarkTitles() {
+  let uri1 = uri("http://foo.tld/");
+  let uri2 = uri("https://bar.tld/");
+
+  PlacesTestUtils.addVisits([
+    { uri: uri1, title: "foo title" },
+    { uri: uri2, title: "bar title" }
+  ]).then(function () {
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.bookmarksMenuFolderId,
+                                         uri1,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         null);
+    PlacesUtils.bookmarks.insertBookmark(PlacesUtils.bookmarksMenuFolderId,
+                                         uri2,
+                                         PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                         null);
+
+    PlacesUtils.tagging.tagURI(uri1, ["tag 1"]);
+    PlacesUtils.tagging.tagURI(uri2, ["tag 2"]);
+
+    let options = PlacesUtils.history.getNewQueryOptions();
+    options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;
+    options.resultType = options.RESULTS_AS_TAG_CONTENTS;
+
+    let query = PlacesUtils.history.getNewQuery();
+    // if we don't set a tag folder, RESULTS_AS_TAG_CONTENTS will return all
+    // tagged URIs
+    let root = PlacesUtils.history.executeQuery(query, options).root;
+    root.containerOpen = true;
+    do_check_eq(root.childCount, 2);
+    // actually RESULTS_AS_TAG_CONTENTS return results ordered by place_id DESC
+    // so they are reversed
+    do_check_eq(root.getChild(0).title, "bar title");
+    do_check_eq(root.getChild(1).title, "foo title");
+    root.containerOpen = false;
+
+    run_next_test();
+  });
+});
diff --git a/toolkit/components/places/tests/unit/test_result_sort.js b/toolkit/components/places/tests/unit/test_result_sort.js
new file mode 100644
index 000000000..35405ac50
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_result_sort.js
@@ -0,0 +1,139 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+const NHQO = Ci.nsINavHistoryQueryOptions;
+
+/**
+ * Waits for onItemVisited notifications to be received.
+ */
+function promiseOnItemVisited() {
+  let defer = Promise.defer();
+  let bookmarksObserver = {
+    __proto__: NavBookmarkObserver.prototype,
+    onItemVisited: function BO_onItemVisited() {
+      PlacesUtils.bookmarks.removeObserver(this);
+      // Enqueue to be sure that all onItemVisited notifications ran.
+      do_execute_soon(defer.resolve);
+    }
+  };
+  PlacesUtils.bookmarks.addObserver(bookmarksObserver, false);
+  return defer.promise;
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test() {
+  let testFolder = PlacesUtils.bookmarks.createFolder(
+    PlacesUtils.bookmarks.placesRoot,
+    "Result-sort functionality tests root",
+    PlacesUtils.bookmarks.DEFAULT_INDEX);
+
+  let uri1 = NetUtil.newURI("http://foo.tld/a");
+  let uri2 = NetUtil.newURI("http://foo.tld/b");
+
+  let id1 = PlacesUtils.bookmarks.insertBookmark(
+    testFolder, uri1, PlacesUtils.bookmarks.DEFAULT_INDEX, "b");
+  let id2 = PlacesUtils.bookmarks.insertBookmark(
+    testFolder, uri2, PlacesUtils.bookmarks.DEFAULT_INDEX, "a");
+  // url of id1, title of id2
+  let id3 = PlacesUtils.bookmarks.insertBookmark(
+    testFolder, uri1, PlacesUtils.bookmarks.DEFAULT_INDEX, "a");
+
+  // query with natural order
+  let result = PlacesUtils.getFolderContents(testFolder);
+  let root = result.root;
+
+  do_check_eq(root.childCount, 3);
+
+  function checkOrder(a, b, c) {
+    do_check_eq(root.getChild(0).itemId, a);
+    do_check_eq(root.getChild(1).itemId, b);
+    do_check_eq(root.getChild(2).itemId, c);
+  }
+
+  // natural order
+  do_print("Natural order");
+  checkOrder(id1, id2, id3);
+
+  // title: id3 should precede id2 since we fall-back to URI-based sorting
+  do_print("Sort by title asc");
+  result.sortingMode = NHQO.SORT_BY_TITLE_ASCENDING;
+  checkOrder(id3, id2, id1);
+
+  // In reverse
+  do_print("Sort by title desc");
+  result.sortingMode = NHQO.SORT_BY_TITLE_DESCENDING;
+  checkOrder(id1, id2, id3);
+
+  // uri sort: id1 should precede id3 since we fall-back to natural order
+  do_print("Sort by uri asc");
+  result.sortingMode = NHQO.SORT_BY_URI_ASCENDING;
+  checkOrder(id1, id3, id2);
+
+  // test live update
+  do_print("Change bookmark uri liveupdate");
+  PlacesUtils.bookmarks.changeBookmarkURI(id1, uri2);
+  checkOrder(id3, id1, id2);
+  PlacesUtils.bookmarks.changeBookmarkURI(id1, uri1);
+  checkOrder(id1, id3, id2);
+
+  // keyword sort
+  do_print("Sort by keyword asc");
+  result.sortingMode = NHQO.SORT_BY_KEYWORD_ASCENDING;
+  checkOrder(id3, id2, id1);  // no keywords set - falling back to title sort
+  yield PlacesUtils.keywords.insert({ url: uri1.spec, keyword: "a" });
+  yield PlacesUtils.keywords.insert({ url: uri2.spec, keyword: "z" });
+  checkOrder(id3, id1, id2);
+
+  // XXXtodo: test history sortings (visit count, visit date)
+  // XXXtodo: test different item types once folderId and bookmarkId are merged.
+  // XXXtodo: test sortingAnnotation functionality with non-bookmark nodes
+
+  do_print("Sort by annotation desc");
+  PlacesUtils.annotations.setItemAnnotation(id1, "testAnno", "a", 0, 0);
+  PlacesUtils.annotations.setItemAnnotation(id3, "testAnno", "b", 0, 0);
+  result.sortingAnnotation = "testAnno";
+  result.sortingMode = NHQO.SORT_BY_ANNOTATION_DESCENDING;
+
+  // id1 precedes id2 per title-descending fallback
+  checkOrder(id3, id1, id2);
+
+  // XXXtodo:  test dateAdded sort
+  // XXXtodo:  test lastModified sort
+
+  // test live update
+  do_print("Annotation liveupdate");
+  PlacesUtils.annotations.setItemAnnotation(id1, "testAnno", "c", 0, 0);
+  checkOrder(id1, id3, id2);
+
+  // Add a visit, then check frecency ordering.
+
+  // When the bookmarks service gets onVisit, it asynchronously fetches all
+  // items for that visit, and then notifies onItemVisited.  Thus we must
+  // explicitly wait for that.
+  let waitForVisited = promiseOnItemVisited();
+  yield PlacesTestUtils.addVisits({ uri: uri2, transition: TRANSITION_TYPED });
+  yield waitForVisited;
+
+  do_print("Sort by frecency desc");
+  result.sortingMode = NHQO.SORT_BY_FRECENCY_DESCENDING;
+  for (let i = 0; i < root.childCount; ++i) {
+    print(root.getChild(i).uri + " " + root.getChild(i).title);
+  }
+  // For id1 and id3, since they have same frecency and no visits, fallback
+  // to sort by the newest bookmark.
+  checkOrder(id2, id3, id1);
+  do_print("Sort by frecency asc");
+  result.sortingMode = NHQO.SORT_BY_FRECENCY_ASCENDING;
+  for (let i = 0; i < root.childCount; ++i) {
+    print(root.getChild(i).uri + " " + root.getChild(i).title);
+  }
+  checkOrder(id1, id3, id2);
+
+  root.containerOpen = false;
+});
diff --git a/toolkit/components/places/tests/unit/test_resultsAsVisit_details.js b/toolkit/components/places/tests/unit/test_resultsAsVisit_details.js
new file mode 100644
index 000000000..8e71ffd0d
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_resultsAsVisit_details.js
@@ -0,0 +1,85 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+
+const {bookmarks, history} = PlacesUtils
+
+add_task(function* test_addVisitCheckFields() {
+  let uri = NetUtil.newURI("http://test4.com/");
+  yield PlacesTestUtils.addVisits([
+    { uri },
+    { uri, referrer: uri },
+    { uri, transition: history.TRANSITION_TYPED },
+  ]);
+
+
+  let options = history.getNewQueryOptions();
+  let query = history.getNewQuery();
+
+  query.uri = uri;
+
+
+  // Check RESULTS_AS_VISIT node.
+  options.resultType = options.RESULTS_AS_VISIT;
+
+  let root = history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  equal(root.childCount, 3);
+
+  let child = root.getChild(0);
+  equal(child.visitType, history.TRANSITION_LINK, "Visit type should be TRANSITION_LINK");
+  equal(child.visitId, 1, "Visit ID should be 1");
+  equal(child.fromVisitId, -1, "Should have no referrer visit ID");
+
+  child = root.getChild(1);
+  equal(child.visitType, history.TRANSITION_LINK, "Visit type should be TRANSITION_LINK");
+  equal(child.visitId, 2, "Visit ID should be 2");
+  equal(child.fromVisitId, 1, "First visit should be the referring visit");
+
+  child = root.getChild(2);
+  equal(child.visitType, history.TRANSITION_TYPED, "Visit type should be TRANSITION_TYPED");
+  equal(child.visitId, 3, "Visit ID should be 3");
+  equal(child.fromVisitId, -1, "Should have no referrer visit ID");
+
+  root.containerOpen = false;
+
+
+  // Check RESULTS_AS_URI node.
+  options.resultType = options.RESULTS_AS_URI;
+
+  root = history.executeQuery(query, options).root;
+  root.containerOpen = true;
+
+  equal(root.childCount, 1);
+
+  child = root.getChild(0);
+  equal(child.visitType, 0, "Visit type should be 0");
+  equal(child.visitId, -1, "Visit ID should be -1");
+  equal(child.fromVisitId, -1, "Referrer visit id should be -1");
+
+  root.containerOpen = false;
+
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* test_bookmarkFields() {
+  let folder = bookmarks.createFolder(bookmarks.placesRoot, "test folder", bookmarks.DEFAULT_INDEX);
+  bookmarks.insertBookmark(folder, uri("http://test4.com/"),
+                           bookmarks.DEFAULT_INDEX, "test4 title");
+
+  let root = PlacesUtils.getFolderContents(folder).root;
+  equal(root.childCount, 1);
+
+  equal(root.visitType, 0, "Visit type should be 0");
+  equal(root.visitId, -1, "Visit ID should be -1");
+  equal(root.fromVisitId, -1, "Referrer visit id should be -1");
+
+  let child = root.getChild(0);
+  equal(child.visitType, 0, "Visit type should be 0");
+  equal(child.visitId, -1, "Visit ID should be -1");
+  equal(child.fromVisitId, -1, "Referrer visit id should be -1");
+
+  root.containerOpen = false;
+
+  yield bookmarks.eraseEverything();
+});
diff --git a/toolkit/components/places/tests/unit/test_sql_guid_functions.js b/toolkit/components/places/tests/unit/test_sql_guid_functions.js
new file mode 100644
index 000000000..41e6bab9e
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_sql_guid_functions.js
@@ -0,0 +1,106 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests that the guid function generates a guid of the proper length,
+ * with no invalid characters.
+ */
+
+/**
+ * Checks all our invariants about our guids for a given result.
+ *
+ * @param aGuid
+ *        The guid to check.
+ */
+function check_invariants(aGuid)
+{
+  do_print("Checking guid '" + aGuid + "'");
+
+  do_check_valid_places_guid(aGuid);
+}
+
+// Test Functions
+
+function test_guid_invariants()
+{
+  const kExpectedChars = 64;
+  const kAllowedChars =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
+  do_check_eq(kAllowedChars.length, kExpectedChars);
+  const kGuidLength = 12;
+
+  let checkedChars = [];
+  for (let i = 0; i < kGuidLength; i++) {
+    checkedChars[i] = {};
+    for (let j = 0; j < kAllowedChars; j++) {
+      checkedChars[i][kAllowedChars[j]] = false;
+    }
+  }
+
+  // We run this until we've seen every character that we expect to see in every
+  // position.
+  let seenChars = 0;
+  let stmt = DBConn().createStatement("SELECT GENERATE_GUID()");
+  while (seenChars != (kExpectedChars * kGuidLength)) {
+    do_check_true(stmt.executeStep());
+    let guid = stmt.getString(0);
+    check_invariants(guid);
+
+    for (let i = 0; i < guid.length; i++) {
+      let character = guid[i];
+      if (!checkedChars[i][character]) {
+        checkedChars[i][character] = true;
+        seenChars++;
+      }
+    }
+    stmt.reset();
+  }
+  stmt.finalize();
+
+  // One last reality check - make sure all of our characters were seen.
+  for (let i = 0; i < kGuidLength; i++) {
+    for (let j = 0; j < kAllowedChars; j++) {
+      do_check_true(checkedChars[i][kAllowedChars[j]]);
+    }
+  }
+
+  run_next_test();
+}
+
+function test_guid_on_background()
+{
+  // We should not assert if we execute this asynchronously.
+  let stmt = DBConn().createAsyncStatement("SELECT GENERATE_GUID()");
+  let checked = false;
+  stmt.executeAsync({
+    handleResult: function(aResult) {
+      try {
+        let row = aResult.getNextRow();
+        check_invariants(row.getResultByIndex(0));
+        do_check_eq(aResult.getNextRow(), null);
+        checked = true;
+      }
+      catch (e) {
+        do_throw(e);
+      }
+    },
+    handleCompletion: function(aReason) {
+      do_check_eq(aReason, Ci.mozIStorageStatementCallback.REASON_FINISHED);
+      do_check_true(checked);
+      run_next_test();
+    }
+  });
+  stmt.finalize();
+}
+
+// Test Runner
+
+[
+  test_guid_invariants,
+  test_guid_on_background,
+].forEach(add_test);
+
+function run_test()
+{
+  run_next_test();
+}
diff --git a/toolkit/components/places/tests/unit/test_svg_favicon.js b/toolkit/components/places/tests/unit/test_svg_favicon.js
new file mode 100644
index 000000000..cec40ddef
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_svg_favicon.js
@@ -0,0 +1,31 @@
+const PAGEURI = NetUtil.newURI("http://deliciousbacon.com/");
+
+add_task(function* () {
+  // First, add a history entry or else Places can't save a favicon.
+  yield PlacesTestUtils.addVisits({
+    uri: PAGEURI,
+    transition: TRANSITION_LINK,
+    visitDate: Date.now() * 1000
+  });
+
+  yield new Promise(resolve => {
+    function onSetComplete(aURI, aDataLen, aData, aMimeType) {
+      equal(aURI.spec, SMALLSVG_DATA_URI.spec, "setFavicon aURI check");
+      equal(aDataLen, 263, "setFavicon aDataLen check");
+      equal(aMimeType, "image/svg+xml", "setFavicon aMimeType check");
+      resolve();
+    }
+
+    PlacesUtils.favicons.setAndFetchFaviconForPage(PAGEURI, SMALLSVG_DATA_URI,
+                                                   false,
+                                                   PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+                                                   onSetComplete,
+                                                   Services.scriptSecurityManager.getSystemPrincipal());
+  });
+
+  let data = yield PlacesUtils.promiseFaviconData(PAGEURI.spec);
+  equal(data.uri.spec, SMALLSVG_DATA_URI.spec, "getFavicon aURI check");
+  equal(data.dataLen, 263, "getFavicon aDataLen check");
+  equal(data.mimeType, "image/svg+xml", "getFavicon aMimeType check");
+});
+
diff --git a/toolkit/components/places/tests/unit/test_sync_utils.js b/toolkit/components/places/tests/unit/test_sync_utils.js
new file mode 100644
index 000000000..f8c7e6b58
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_sync_utils.js
@@ -0,0 +1,1150 @@
+Cu.import("resource://gre/modules/PlacesSyncUtils.jsm");
+Cu.import("resource://testing-common/httpd.js");
+Cu.importGlobalProperties(["crypto", "URLSearchParams"]);
+
+const DESCRIPTION_ANNO = "bookmarkProperties/description";
+const LOAD_IN_SIDEBAR_ANNO = "bookmarkProperties/loadInSidebar";
+const SYNC_PARENT_ANNO = "sync/parent";
+
+function makeGuid() {
+  return ChromeUtils.base64URLEncode(crypto.getRandomValues(new Uint8Array(9)), {
+    pad: false,
+  });
+}
+
+function makeLivemarkServer() {
+  let server = new HttpServer();
+  server.registerPrefixHandler("/feed/", do_get_file("./livemark.xml"));
+  server.start(-1);
+  return {
+    server,
+    get site() {
+      let { identity } = server;
+      let host = identity.primaryHost.includes(":") ?
+        `[${identity.primaryHost}]` : identity.primaryHost;
+      return `${identity.primaryScheme}://${host}:${identity.primaryPort}`;
+    },
+    stopServer() {
+      return new Promise(resolve => server.stop(resolve));
+    },
+  };
+}
+
+function shuffle(array) {
+  let results = [];
+  for (let i = 0; i < array.length; ++i) {
+    let randomIndex = Math.floor(Math.random() * (i + 1));
+    results[i] = results[randomIndex];
+    results[randomIndex] = array[i];
+  }
+  return results;
+}
+
+function compareAscending(a, b) {
+  if (a > b) {
+    return 1;
+  }
+  if (a < b) {
+    return -1;
+  }
+  return 0;
+}
+
+function assertTagForURLs(tag, urls, message) {
+  let taggedURLs = PlacesUtils.tagging.getURIsForTag(tag).map(uri => uri.spec);
+  deepEqual(taggedURLs.sort(compareAscending), urls.sort(compareAscending), message);
+}
+
+function assertURLHasTags(url, tags, message) {
+  let actualTags = PlacesUtils.tagging.getTagsForURI(uri(url));
+  deepEqual(actualTags.sort(compareAscending), tags, message);
+}
+
+var populateTree = Task.async(function* populate(parentGuid, ...items) {
+  let guids = {};
+
+  for (let index = 0; index < items.length; index++) {
+    let item = items[index];
+    let guid = makeGuid();
+
+    switch (item.kind) {
+      case "bookmark":
+      case "query":
+        yield PlacesUtils.bookmarks.insert({
+          type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+          url: item.url,
+          title: item.title,
+          parentGuid, guid, index,
+        });
+        break;
+
+      case "separator":
+        yield PlacesUtils.bookmarks.insert({
+          type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
+          parentGuid, guid,
+        });
+        break;
+
+      case "folder":
+        yield PlacesUtils.bookmarks.insert({
+          type: PlacesUtils.bookmarks.TYPE_FOLDER,
+          title: item.title,
+          parentGuid, guid,
+        });
+        if (item.children) {
+          Object.assign(guids, yield* populate(guid, ...item.children));
+        }
+        break;
+
+      default:
+        throw new Error(`Unsupported item type: ${item.type}`);
+    }
+
+    if (item.exclude) {
+      let itemId = yield PlacesUtils.promiseItemId(guid);
+      PlacesUtils.annotations.setItemAnnotation(
+        itemId, PlacesUtils.EXCLUDE_FROM_BACKUP_ANNO, "Don't back this up", 0,
+        PlacesUtils.annotations.EXPIRE_NEVER);
+    }
+
+    guids[item.title] = guid;
+  }
+
+  return guids;
+});
+
+var syncIdToId = Task.async(function* syncIdToId(syncId) {
+  let guid = yield PlacesSyncUtils.bookmarks.syncIdToGuid(syncId);
+  return PlacesUtils.promiseItemId(guid);
+});
+
+add_task(function* test_order() {
+  do_print("Insert some bookmarks");
+  let guids = yield populateTree(PlacesUtils.bookmarks.menuGuid, {
+    kind: "bookmark",
+    title: "childBmk",
+    url: "http://getfirefox.com",
+  }, {
+    kind: "bookmark",
+    title: "siblingBmk",
+    url: "http://getthunderbird.com",
+  }, {
+    kind: "folder",
+    title: "siblingFolder",
+  }, {
+    kind: "separator",
+    title: "siblingSep",
+  });
+
+  do_print("Reorder inserted bookmarks");
+  {
+    let order = [guids.siblingFolder, guids.siblingSep, guids.childBmk,
+      guids.siblingBmk];
+    yield PlacesSyncUtils.bookmarks.order(PlacesUtils.bookmarks.menuGuid, order);
+    let childSyncIds = yield PlacesSyncUtils.bookmarks.fetchChildSyncIds(PlacesUtils.bookmarks.menuGuid);
+    deepEqual(childSyncIds, order, "New bookmarks should be reordered according to array");
+  }
+
+  do_print("Reorder with unspecified children");
+  {
+    yield PlacesSyncUtils.bookmarks.order(PlacesUtils.bookmarks.menuGuid, [
+      guids.siblingSep, guids.siblingBmk,
+    ]);
+    let childSyncIds = yield PlacesSyncUtils.bookmarks.fetchChildSyncIds(
+      PlacesUtils.bookmarks.menuGuid);
+    deepEqual(childSyncIds, [guids.siblingSep, guids.siblingBmk,
+      guids.siblingFolder, guids.childBmk],
+      "Unordered children should be moved to end");
+  }
+
+  do_print("Reorder with nonexistent children");
+  {
+    yield PlacesSyncUtils.bookmarks.order(PlacesUtils.bookmarks.menuGuid, [
+      guids.childBmk, makeGuid(), guids.siblingBmk, guids.siblingSep,
+      makeGuid(), guids.siblingFolder, makeGuid()]);
+    let childSyncIds = yield PlacesSyncUtils.bookmarks.fetchChildSyncIds(
+      PlacesUtils.bookmarks.menuGuid);
+    deepEqual(childSyncIds, [guids.childBmk, guids.siblingBmk, guids.siblingSep,
+      guids.siblingFolder], "Nonexistent children should be ignored");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_changeGuid_invalid() {
+  yield rejects(PlacesSyncUtils.bookmarks.changeGuid(makeGuid()),
+    "Should require a new GUID");
+  yield rejects(PlacesSyncUtils.bookmarks.changeGuid(makeGuid(), "!@#$"),
+    "Should reject invalid GUIDs");
+  yield rejects(PlacesSyncUtils.bookmarks.changeGuid(makeGuid(), makeGuid()),
+    "Should reject nonexistent item GUIDs");
+  yield rejects(
+    PlacesSyncUtils.bookmarks.changeGuid(PlacesUtils.bookmarks.menuGuid,
+      makeGuid()),
+    "Should reject roots");
+});
+
+add_task(function* test_changeGuid() {
+  let item = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.menuGuid,
+    type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+    url: "https://mozilla.org",
+  });
+  let id = yield PlacesUtils.promiseItemId(item.guid);
+
+  let newGuid = makeGuid();
+  let result = yield PlacesSyncUtils.bookmarks.changeGuid(item.guid, newGuid);
+  equal(result, newGuid, "Should return new GUID");
+
+  equal(yield PlacesUtils.promiseItemId(newGuid), id, "Should map ID to new GUID");
+  yield rejects(PlacesUtils.promiseItemId(item.guid), "Should not map ID to old GUID");
+  equal(yield PlacesUtils.promiseItemGuid(id), newGuid, "Should map new GUID to ID");
+});
+
+add_task(function* test_order_roots() {
+  let oldOrder = yield PlacesSyncUtils.bookmarks.fetchChildSyncIds(
+    PlacesUtils.bookmarks.rootGuid);
+  yield PlacesSyncUtils.bookmarks.order(PlacesUtils.bookmarks.rootGuid,
+    shuffle(oldOrder));
+  let newOrder = yield PlacesSyncUtils.bookmarks.fetchChildSyncIds(
+    PlacesUtils.bookmarks.rootGuid);
+  deepEqual(oldOrder, newOrder, "Should ignore attempts to reorder roots");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_update_tags() {
+  do_print("Insert item without tags");
+  let item = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "bookmark",
+    url: "https://mozilla.org",
+    syncId: makeGuid(),
+    parentSyncId: "menu",
+  });
+
+  do_print("Add tags");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: item.syncId,
+      tags: ["foo", "bar"],
+    });
+    deepEqual(updatedItem.tags, ["foo", "bar"], "Should return new tags");
+    assertURLHasTags("https://mozilla.org", ["bar", "foo"],
+      "Should set new tags for URL");
+  }
+
+  do_print("Add new tag, remove existing tag");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: item.syncId,
+      tags: ["foo", "baz"],
+    });
+    deepEqual(updatedItem.tags, ["foo", "baz"], "Should return updated tags");
+    assertURLHasTags("https://mozilla.org", ["baz", "foo"],
+      "Should update tags for URL");
+    assertTagForURLs("bar", [], "Should remove existing tag");
+  }
+
+  do_print("Tags with whitespace");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: item.syncId,
+      tags: [" leading", "trailing ", " baz ", " "],
+    });
+    deepEqual(updatedItem.tags, ["leading", "trailing", "baz"],
+      "Should return filtered tags");
+    assertURLHasTags("https://mozilla.org", ["baz", "leading", "trailing"],
+      "Should trim whitespace and filter blank tags");
+  }
+
+  do_print("Remove all tags");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: item.syncId,
+      tags: null,
+    });
+    deepEqual(updatedItem.tags, [], "Should return empty tag array");
+    assertURLHasTags("https://mozilla.org", [],
+      "Should remove all existing tags");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_update_keyword() {
+  do_print("Insert item without keyword");
+  let item = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "bookmark",
+    parentSyncId: "menu",
+    url: "https://mozilla.org",
+    syncId: makeGuid(),
+  });
+
+  do_print("Add item keyword");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: item.syncId,
+      keyword: "moz",
+    });
+    equal(updatedItem.keyword, "moz", "Should return new keyword");
+    let entryByKeyword = yield PlacesUtils.keywords.fetch("moz");
+    equal(entryByKeyword.url.href, "https://mozilla.org/",
+      "Should set new keyword for URL");
+    let entryByURL = yield PlacesUtils.keywords.fetch({
+      url: "https://mozilla.org",
+    });
+    equal(entryByURL.keyword, "moz", "Looking up URL should return new keyword");
+  }
+
+  do_print("Change item keyword");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: item.syncId,
+      keyword: "m",
+    });
+    equal(updatedItem.keyword, "m", "Should return updated keyword");
+    let newEntry = yield PlacesUtils.keywords.fetch("m");
+    equal(newEntry.url.href, "https://mozilla.org/", "Should update keyword for URL");
+    let oldEntry = yield PlacesUtils.keywords.fetch("moz");
+    ok(!oldEntry, "Should remove old keyword");
+  }
+
+  do_print("Remove existing keyword");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: item.syncId,
+      keyword: null,
+    });
+    ok(!updatedItem.keyword,
+      "Should not include removed keyword in properties");
+    let entry = yield PlacesUtils.keywords.fetch({
+      url: "https://mozilla.org",
+    });
+    ok(!entry, "Should remove new keyword from URL");
+  }
+
+  do_print("Remove keyword for item without keyword");
+  {
+    yield PlacesSyncUtils.bookmarks.update({
+      syncId: item.syncId,
+      keyword: null,
+    });
+    let entry = yield PlacesUtils.keywords.fetch({
+      url: "https://mozilla.org",
+    });
+    ok(!entry,
+      "Removing keyword for URL without existing keyword should succeed");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_update_annos() {
+  let guids = yield populateTree(PlacesUtils.bookmarks.menuGuid, {
+    kind: "folder",
+    title: "folder",
+  }, {
+    kind: "bookmark",
+    title: "bmk",
+    url: "https://example.com",
+  });
+
+  do_print("Add folder description");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: guids.folder,
+      description: "Folder description",
+    });
+    equal(updatedItem.description, "Folder description",
+      "Should return new description");
+    let id = yield syncIdToId(updatedItem.syncId);
+    equal(PlacesUtils.annotations.getItemAnnotation(id, DESCRIPTION_ANNO),
+      "Folder description", "Should set description anno");
+  }
+
+  do_print("Clear folder description");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: guids.folder,
+      description: null,
+    });
+    ok(!updatedItem.description, "Should not return cleared description");
+    let id = yield syncIdToId(updatedItem.syncId);
+    ok(!PlacesUtils.annotations.itemHasAnnotation(id, DESCRIPTION_ANNO),
+      "Should remove description anno");
+  }
+
+  do_print("Add bookmark sidebar anno");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: guids.bmk,
+      loadInSidebar: true,
+    });
+    ok(updatedItem.loadInSidebar, "Should return sidebar anno");
+    let id = yield syncIdToId(updatedItem.syncId);
+    ok(PlacesUtils.annotations.itemHasAnnotation(id, LOAD_IN_SIDEBAR_ANNO),
+      "Should set sidebar anno for existing bookmark");
+  }
+
+  do_print("Clear bookmark sidebar anno");
+  {
+    let updatedItem = yield PlacesSyncUtils.bookmarks.update({
+      syncId: guids.bmk,
+      loadInSidebar: false,
+    });
+    ok(!updatedItem.loadInSidebar, "Should not return cleared sidebar anno");
+    let id = yield syncIdToId(updatedItem.syncId);
+    ok(!PlacesUtils.annotations.itemHasAnnotation(id, LOAD_IN_SIDEBAR_ANNO),
+      "Should clear sidebar anno for existing bookmark");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_update_move_root() {
+  do_print("Move root to same parent");
+  {
+    // This should be a no-op.
+    let sameRoot = yield PlacesSyncUtils.bookmarks.update({
+      syncId: "menu",
+      parentSyncId: "places",
+    });
+    equal(sameRoot.syncId, "menu",
+      "Menu root GUID should not change");
+    equal(sameRoot.parentSyncId, "places",
+      "Parent Places root GUID should not change");
+  }
+
+  do_print("Try reparenting root");
+  yield rejects(PlacesSyncUtils.bookmarks.update({
+    syncId: "menu",
+    parentSyncId: "toolbar",
+  }));
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_insert() {
+  do_print("Insert bookmark");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.insert({
+      kind: "bookmark",
+      syncId: makeGuid(),
+      parentSyncId: "menu",
+      url: "https://example.org",
+    });
+    let { type } = yield PlacesUtils.bookmarks.fetch({ guid: item.syncId });
+    equal(type, PlacesUtils.bookmarks.TYPE_BOOKMARK,
+      "Bookmark should have correct type");
+  }
+
+  do_print("Insert query");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.insert({
+      kind: "query",
+      syncId: makeGuid(),
+      parentSyncId: "menu",
+      url: "place:terms=term&folder=TOOLBAR&queryType=1",
+      folder: "Saved search",
+    });
+    let { type } = yield PlacesUtils.bookmarks.fetch({ guid: item.syncId });
+    equal(type, PlacesUtils.bookmarks.TYPE_BOOKMARK,
+      "Queries should be stored as bookmarks");
+  }
+
+  do_print("Insert folder");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.insert({
+      kind: "folder",
+      syncId: makeGuid(),
+      parentSyncId: "menu",
+      title: "New folder",
+    });
+    let { type } = yield PlacesUtils.bookmarks.fetch({ guid: item.syncId });
+    equal(type, PlacesUtils.bookmarks.TYPE_FOLDER,
+      "Folder should have correct type");
+  }
+
+  do_print("Insert separator");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.insert({
+      kind: "separator",
+      syncId: makeGuid(),
+      parentSyncId: "menu",
+    });
+    let { type } = yield PlacesUtils.bookmarks.fetch({ guid: item.syncId });
+    equal(type, PlacesUtils.bookmarks.TYPE_SEPARATOR,
+      "Separator should have correct type");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_insert_livemark() {
+  let { site, stopServer } = makeLivemarkServer();
+
+  try {
+    do_print("Insert livemark with feed URL");
+    {
+      let livemark = yield PlacesSyncUtils.bookmarks.insert({
+        kind: "livemark",
+        syncId: makeGuid(),
+        feed: site + "/feed/1",
+        parentSyncId: "menu",
+      });
+      let bmk = yield PlacesUtils.bookmarks.fetch({
+        guid: yield PlacesSyncUtils.bookmarks.syncIdToGuid(livemark.syncId),
+      })
+      equal(bmk.type, PlacesUtils.bookmarks.TYPE_FOLDER,
+        "Livemarks should be stored as folders");
+    }
+
+    let livemarkSyncId;
+    do_print("Insert livemark with site and feed URLs");
+    {
+      let livemark = yield PlacesSyncUtils.bookmarks.insert({
+        kind: "livemark",
+        syncId: makeGuid(),
+        site,
+        feed: site + "/feed/1",
+        parentSyncId: "menu",
+      });
+      livemarkSyncId = livemark.syncId;
+    }
+
+    do_print("Try inserting livemark into livemark");
+    {
+      let livemark = yield PlacesSyncUtils.bookmarks.insert({
+        kind: "livemark",
+        syncId: makeGuid(),
+        site,
+        feed: site + "/feed/1",
+        parentSyncId: livemarkSyncId,
+      });
+      ok(!livemark, "Should not insert livemark as child of livemark");
+    }
+  } finally {
+    yield stopServer();
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_update_livemark() {
+  let { site, stopServer } = makeLivemarkServer();
+  let feedURI = uri(site + "/feed/1");
+
+  try {
+    // We shouldn't reinsert the livemark if the URLs are the same.
+    do_print("Update livemark with same URLs");
+    {
+      let livemark = yield PlacesUtils.livemarks.addLivemark({
+        parentGuid: PlacesUtils.bookmarks.menuGuid,
+        feedURI,
+        siteURI: uri(site),
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+      });
+
+      yield PlacesSyncUtils.bookmarks.update({
+        syncId: livemark.guid,
+        feed: feedURI,
+      });
+      // `nsLivemarkService` returns references to `Livemark` instances, so we
+      // can compare them with `==` to make sure they haven't been replaced.
+      equal(yield PlacesUtils.livemarks.getLivemark({
+        guid: livemark.guid,
+      }), livemark, "Livemark with same feed URL should not be replaced");
+
+      yield PlacesSyncUtils.bookmarks.update({
+        syncId: livemark.guid,
+        site,
+      });
+      equal(yield PlacesUtils.livemarks.getLivemark({
+        guid: livemark.guid,
+      }), livemark, "Livemark with same site URL should not be replaced");
+
+      yield PlacesSyncUtils.bookmarks.update({
+        syncId: livemark.guid,
+        feed: feedURI,
+        site,
+      });
+      equal(yield PlacesUtils.livemarks.getLivemark({
+        guid: livemark.guid,
+      }), livemark, "Livemark with same feed and site URLs should not be replaced");
+    }
+
+    do_print("Change livemark feed URL");
+    {
+      let livemark = yield PlacesUtils.livemarks.addLivemark({
+        parentGuid: PlacesUtils.bookmarks.menuGuid,
+        feedURI,
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+      });
+
+      // Since we're reinserting, we need to pass all properties required
+      // for a new livemark. `update` won't merge the old and new ones.
+      yield rejects(PlacesSyncUtils.bookmarks.update({
+        syncId: livemark.guid,
+        feed: site + "/feed/2",
+      }), "Reinserting livemark with changed feed URL requires full record");
+
+      let newLivemark = yield PlacesSyncUtils.bookmarks.update({
+        kind: "livemark",
+        parentSyncId: "menu",
+        syncId: livemark.guid,
+        feed: site + "/feed/2",
+      });
+      equal(newLivemark.syncId, livemark.guid,
+        "GUIDs should match for reinserted livemark with changed feed URL");
+      equal(newLivemark.feed.href, site + "/feed/2",
+        "Reinserted livemark should have changed feed URI");
+    }
+
+    do_print("Add livemark site URL");
+    {
+      let livemark = yield PlacesUtils.livemarks.addLivemark({
+        parentGuid: PlacesUtils.bookmarks.menuGuid,
+        feedURI,
+      });
+      ok(livemark.feedURI.equals(feedURI), "Livemark feed URI should match");
+      ok(!livemark.siteURI, "Livemark should not have site URI");
+
+      yield rejects(PlacesSyncUtils.bookmarks.update({
+        syncId: livemark.guid,
+        site,
+      }), "Reinserting livemark with new site URL requires full record");
+
+      let newLivemark = yield PlacesSyncUtils.bookmarks.update({
+        kind: "livemark",
+        parentSyncId: "menu",
+        syncId: livemark.guid,
+        feed: feedURI,
+        site,
+      });
+      notEqual(newLivemark, livemark,
+        "Livemark with new site URL should replace old livemark");
+      equal(newLivemark.syncId, livemark.guid,
+        "GUIDs should match for reinserted livemark with new site URL");
+      equal(newLivemark.site.href, site + "/",
+        "Reinserted livemark should have new site URI");
+      equal(newLivemark.feed.href, feedURI.spec,
+        "Reinserted livemark with new site URL should have same feed URI");
+    }
+
+    do_print("Remove livemark site URL");
+    {
+      let livemark = yield PlacesUtils.livemarks.addLivemark({
+        parentGuid: PlacesUtils.bookmarks.menuGuid,
+        feedURI,
+        siteURI: uri(site),
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+      });
+
+      yield rejects(PlacesSyncUtils.bookmarks.update({
+        syncId: livemark.guid,
+        site: null,
+      }), "Reinserting livemark witout site URL requires full record");
+
+      let newLivemark = yield PlacesSyncUtils.bookmarks.update({
+        kind: "livemark",
+        parentSyncId: "menu",
+        syncId: livemark.guid,
+        feed: feedURI,
+        site: null,
+      });
+      notEqual(newLivemark, livemark,
+        "Livemark without site URL should replace old livemark");
+      equal(newLivemark.syncId, livemark.guid,
+        "GUIDs should match for reinserted livemark without site URL");
+      ok(!newLivemark.site, "Reinserted livemark should not have site URI");
+    }
+
+    do_print("Change livemark site URL");
+    {
+      let livemark = yield PlacesUtils.livemarks.addLivemark({
+        parentGuid: PlacesUtils.bookmarks.menuGuid,
+        feedURI,
+        siteURI: uri(site),
+        index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+      });
+
+      yield rejects(PlacesSyncUtils.bookmarks.update({
+        syncId: livemark.guid,
+        site: site + "/new",
+      }), "Reinserting livemark with changed site URL requires full record");
+
+      let newLivemark = yield PlacesSyncUtils.bookmarks.update({
+        kind: "livemark",
+        parentSyncId: "menu",
+        syncId: livemark.guid,
+        feed:feedURI,
+        site: site + "/new",
+      });
+      notEqual(newLivemark, livemark,
+        "Livemark with changed site URL should replace old livemark");
+      equal(newLivemark.syncId, livemark.guid,
+        "GUIDs should match for reinserted livemark with changed site URL");
+      equal(newLivemark.site.href, site + "/new",
+        "Reinserted livemark should have changed site URI");
+    }
+
+    // Livemarks are stored as folders, but have different kinds. We should
+    // remove the folder and insert a livemark with the same GUID instead of
+    // trying to update the folder in-place.
+    do_print("Replace folder with livemark");
+    {
+      let folder = yield PlacesUtils.bookmarks.insert({
+        type: PlacesUtils.bookmarks.TYPE_FOLDER,
+        parentGuid: PlacesUtils.bookmarks.menuGuid,
+        title: "Plain folder",
+      });
+      let livemark = yield PlacesSyncUtils.bookmarks.update({
+        kind: "livemark",
+        parentSyncId: "menu",
+        syncId: folder.guid,
+        feed: feedURI,
+      });
+      equal(livemark.guid, folder.syncId,
+        "Livemark should have same GUID as replaced folder");
+    }
+  } finally {
+    yield stopServer();
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_insert_tags() {
+  yield Promise.all([{
+    kind: "bookmark",
+    url: "https://example.com",
+    syncId: makeGuid(),
+    parentSyncId: "menu",
+    tags: ["foo", "bar"],
+  }, {
+    kind: "bookmark",
+    url: "https://example.org",
+    syncId: makeGuid(),
+    parentSyncId: "toolbar",
+    tags: ["foo", "baz"],
+  }, {
+    kind: "query",
+    url: "place:queryType=1&sort=12&maxResults=10",
+    syncId: makeGuid(),
+    parentSyncId: "toolbar",
+    folder: "bar",
+    tags: ["baz", "qux"],
+    title: "bar",
+  }].map(info => PlacesSyncUtils.bookmarks.insert(info)));
+
+  assertTagForURLs("foo", ["https://example.com/", "https://example.org/"],
+    "2 URLs with new tag");
+  assertTagForURLs("bar", ["https://example.com/"], "1 URL with existing tag");
+  assertTagForURLs("baz", ["https://example.org/",
+    "place:queryType=1&sort=12&maxResults=10"],
+    "Should support tagging URLs and tag queries");
+  assertTagForURLs("qux", ["place:queryType=1&sort=12&maxResults=10"],
+    "Should support tagging tag queries");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_insert_tags_whitespace() {
+  do_print("Untrimmed and blank tags");
+  let taggedBlanks = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "bookmark",
+    url: "https://example.org",
+    syncId: makeGuid(),
+    parentSyncId: "menu",
+    tags: [" untrimmed ", " ", "taggy"],
+  });
+  deepEqual(taggedBlanks.tags, ["untrimmed", "taggy"],
+    "Should not return empty tags");
+  assertURLHasTags("https://example.org/", ["taggy", "untrimmed"],
+    "Should set trimmed tags and ignore dupes");
+
+  do_print("Dupe tags");
+  let taggedDupes = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "bookmark",
+    url: "https://example.net",
+    syncId: makeGuid(),
+    parentSyncId: "toolbar",
+    tags: [" taggy", "taggy ", " taggy ", "taggy"],
+  });
+  deepEqual(taggedDupes.tags, ["taggy", "taggy", "taggy", "taggy"],
+    "Should return trimmed and dupe tags");
+  assertURLHasTags("https://example.net/", ["taggy"],
+    "Should ignore dupes when setting tags");
+
+  assertTagForURLs("taggy", ["https://example.net/", "https://example.org/"],
+    "Should exclude falsy tags");
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_insert_keyword() {
+  do_print("Insert item with new keyword");
+  {
+    yield PlacesSyncUtils.bookmarks.insert({
+      kind: "bookmark",
+      parentSyncId: "menu",
+      url: "https://example.com",
+      keyword: "moz",
+      syncId: makeGuid(),
+    });
+    let entry = yield PlacesUtils.keywords.fetch("moz");
+    equal(entry.url.href, "https://example.com/",
+      "Should add keyword for item");
+  }
+
+  do_print("Insert item with existing keyword");
+  {
+    yield PlacesSyncUtils.bookmarks.insert({
+      kind: "bookmark",
+      parentSyncId: "menu",
+      url: "https://mozilla.org",
+      keyword: "moz",
+      syncId: makeGuid(),
+    });
+    let entry = yield PlacesUtils.keywords.fetch("moz");
+    equal(entry.url.href, "https://mozilla.org/",
+      "Should reassign keyword to new item");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_insert_annos() {
+  do_print("Bookmark with description");
+  let descBmk = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "bookmark",
+    url: "https://example.com",
+    syncId: makeGuid(),
+    parentSyncId: "menu",
+    description: "Bookmark description",
+  });
+  {
+    equal(descBmk.description, "Bookmark description",
+      "Should return new bookmark description");
+    let id = yield syncIdToId(descBmk.syncId);
+    equal(PlacesUtils.annotations.getItemAnnotation(id, DESCRIPTION_ANNO),
+      "Bookmark description", "Should set new bookmark description");
+  }
+
+  do_print("Folder with description");
+  let descFolder = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "folder",
+    syncId: makeGuid(),
+    parentSyncId: "menu",
+    description: "Folder description",
+  });
+  {
+    equal(descFolder.description, "Folder description",
+      "Should return new folder description");
+    let id = yield syncIdToId(descFolder.syncId);
+    equal(PlacesUtils.annotations.getItemAnnotation(id, DESCRIPTION_ANNO),
+      "Folder description", "Should set new folder description");
+  }
+
+  do_print("Bookmark with sidebar anno");
+  let sidebarBmk = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "bookmark",
+    url: "https://example.com",
+    syncId: makeGuid(),
+    parentSyncId: "menu",
+    loadInSidebar: true,
+  });
+  {
+    ok(sidebarBmk.loadInSidebar, "Should return sidebar anno for new bookmark");
+    let id = yield syncIdToId(sidebarBmk.syncId);
+    ok(PlacesUtils.annotations.itemHasAnnotation(id, LOAD_IN_SIDEBAR_ANNO),
+      "Should set sidebar anno for new bookmark");
+  }
+
+  do_print("Bookmark without sidebar anno");
+  let noSidebarBmk = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "bookmark",
+    url: "https://example.org",
+    syncId: makeGuid(),
+    parentSyncId: "toolbar",
+    loadInSidebar: false,
+  });
+  {
+    ok(!noSidebarBmk.loadInSidebar,
+      "Should not return sidebar anno for new bookmark");
+    let id = yield syncIdToId(noSidebarBmk.syncId);
+    ok(!PlacesUtils.annotations.itemHasAnnotation(id, LOAD_IN_SIDEBAR_ANNO),
+      "Should not set sidebar anno for new bookmark");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_insert_tag_query() {
+  let tagFolder = -1;
+
+  do_print("Insert tag query for new tag");
+  {
+    deepEqual(PlacesUtils.tagging.allTags, [], "New tag should not exist yet");
+    let query = yield PlacesSyncUtils.bookmarks.insert({
+      kind: "query",
+      syncId: makeGuid(),
+      parentSyncId: "toolbar",
+      url: "place:type=7&folder=90",
+      folder: "taggy",
+      title: "Tagged stuff",
+    });
+    notEqual(query.url.href, "place:type=7&folder=90",
+      "Tag query URL for new tag should differ");
+
+    [, tagFolder] = /\bfolder=(\d+)\b/.exec(query.url.pathname);
+    ok(tagFolder > 0, "New tag query URL should contain valid folder");
+    deepEqual(PlacesUtils.tagging.allTags, ["taggy"], "New tag should exist");
+  }
+
+  do_print("Insert tag query for existing tag");
+  {
+    let url = "place:type=7&folder=90&maxResults=15";
+    let query = yield PlacesSyncUtils.bookmarks.insert({
+      kind: "query",
+      url,
+      folder: "taggy",
+      title: "Sorted and tagged",
+      syncId: makeGuid(),
+      parentSyncId: "menu",
+    });
+    notEqual(query.url.href, url, "Tag query URL for existing tag should differ");
+    let params = new URLSearchParams(query.url.pathname);
+    equal(params.get("type"), "7", "Should preserve query type");
+    equal(params.get("maxResults"), "15", "Should preserve additional params");
+    equal(params.get("folder"), tagFolder, "Should update tag folder");
+    deepEqual(PlacesUtils.tagging.allTags, ["taggy"], "Should not duplicate existing tags");
+  }
+
+  do_print("Use the public tagging API to ensure we added the tag correctly");
+  {
+    yield PlacesUtils.bookmarks.insert({
+      parentGuid: PlacesUtils.bookmarks.menuGuid,
+      type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
+      url: "https://mozilla.org",
+      title: "Mozilla",
+    });
+    PlacesUtils.tagging.tagURI(uri("https://mozilla.org"), ["taggy"]);
+    assertURLHasTags("https://mozilla.org/", ["taggy"],
+      "Should set tags using the tagging API");
+  }
+
+  do_print("Removing the tag should clean up the tag folder");
+  {
+    PlacesUtils.tagging.untagURI(uri("https://mozilla.org"), null);
+    deepEqual(PlacesUtils.tagging.allTags, [],
+      "Should remove tag folder once last item is untagged");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_insert_orphans() {
+  let grandParentGuid = makeGuid();
+  let parentGuid = makeGuid();
+  let childGuid = makeGuid();
+  let childId;
+
+  do_print("Insert an orphaned child");
+  {
+    let child = yield PlacesSyncUtils.bookmarks.insert({
+      kind: "bookmark",
+      parentSyncId: parentGuid,
+      syncId: childGuid,
+      url: "https://mozilla.org",
+    });
+    equal(child.syncId, childGuid,
+      "Should insert orphan with requested GUID");
+    equal(child.parentSyncId, "unfiled",
+      "Should reparent orphan to unfiled");
+
+    childId = yield PlacesUtils.promiseItemId(childGuid);
+    equal(PlacesUtils.annotations.getItemAnnotation(childId, SYNC_PARENT_ANNO),
+      parentGuid, "Should set anno to missing parent GUID");
+  }
+
+  do_print("Insert the grandparent");
+  {
+    yield PlacesSyncUtils.bookmarks.insert({
+      kind: "folder",
+      parentSyncId: "menu",
+      syncId: grandParentGuid,
+    });
+    equal(PlacesUtils.annotations.getItemAnnotation(childId, SYNC_PARENT_ANNO),
+      parentGuid, "Child should still have orphan anno");
+  }
+
+  // Note that only `PlacesSyncUtils` reparents orphans, though Sync adds an
+  // observer that removes the orphan anno if the orphan is manually moved.
+  do_print("Insert the missing parent");
+  {
+    let parent = yield PlacesSyncUtils.bookmarks.insert({
+      kind: "folder",
+      parentSyncId: grandParentGuid,
+      syncId: parentGuid,
+    });
+    equal(parent.syncId, parentGuid, "Should insert parent with requested GUID");
+    equal(parent.parentSyncId, grandParentGuid,
+      "Parent should be child of grandparent");
+    ok(!PlacesUtils.annotations.itemHasAnnotation(childId, SYNC_PARENT_ANNO),
+      "Orphan anno should be removed after reparenting");
+
+    let child = yield PlacesUtils.bookmarks.fetch({ guid: childGuid });
+    equal(child.parentGuid, parentGuid,
+      "Should reparent child after inserting missing parent");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_fetch() {
+  let folder = yield PlacesSyncUtils.bookmarks.insert({
+    syncId: makeGuid(),
+    parentSyncId: "menu",
+    kind: "folder",
+    description: "Folder description",
+  });
+  let bmk = yield PlacesSyncUtils.bookmarks.insert({
+    syncId: makeGuid(),
+    parentSyncId: "menu",
+    kind: "bookmark",
+    url: "https://example.com",
+    description: "Bookmark description",
+    loadInSidebar: true,
+    tags: ["taggy"],
+  });
+  let folderBmk = yield PlacesSyncUtils.bookmarks.insert({
+    syncId: makeGuid(),
+    parentSyncId: folder.syncId,
+    kind: "bookmark",
+    url: "https://example.org",
+    keyword: "kw",
+  });
+  let folderSep = yield PlacesSyncUtils.bookmarks.insert({
+    syncId: makeGuid(),
+    parentSyncId: folder.syncId,
+    kind: "separator",
+  });
+  let tagQuery = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "query",
+    syncId: makeGuid(),
+    parentSyncId: "toolbar",
+    url: "place:type=7&folder=90",
+    folder: "taggy",
+    title: "Tagged stuff",
+  });
+  let [, tagFolderId] = /\bfolder=(\d+)\b/.exec(tagQuery.url.pathname);
+  let smartBmk = yield PlacesSyncUtils.bookmarks.insert({
+    kind: "query",
+    syncId: makeGuid(),
+    parentSyncId: "toolbar",
+    url: "place:folder=TOOLBAR",
+    query: "BookmarksToolbar",
+    title: "Bookmarks toolbar query",
+  });
+
+  do_print("Fetch empty folder with description");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.fetch(folder.syncId);
+    deepEqual(item, {
+      syncId: folder.syncId,
+      kind: "folder",
+      parentSyncId: "menu",
+      description: "Folder description",
+      childSyncIds: [folderBmk.syncId, folderSep.syncId],
+      parentTitle: "Bookmarks Menu",
+      title: "",
+    }, "Should include description, children, title, and parent title in folder");
+  }
+
+  do_print("Fetch bookmark with description, sidebar anno, and tags");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.fetch(bmk.syncId);
+    deepEqual(Object.keys(item).sort(), ["syncId", "kind", "parentSyncId",
+      "url", "tags", "description", "loadInSidebar", "parentTitle", "title"].sort(),
+      "Should include bookmark-specific properties");
+    equal(item.syncId, bmk.syncId, "Sync ID should match");
+    equal(item.url.href, "https://example.com/", "Should return URL");
+    equal(item.parentSyncId, "menu", "Should return parent sync ID");
+    deepEqual(item.tags, ["taggy"], "Should return tags");
+    equal(item.description, "Bookmark description", "Should return bookmark description");
+    strictEqual(item.loadInSidebar, true, "Should return sidebar anno");
+    equal(item.parentTitle, "Bookmarks Menu", "Should return parent title");
+    strictEqual(item.title, "", "Should return empty title");
+  }
+
+  do_print("Fetch bookmark with keyword; without parent title or annos");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.fetch(folderBmk.syncId);
+    deepEqual(Object.keys(item).sort(), ["syncId", "kind", "parentSyncId",
+      "url", "keyword", "tags", "loadInSidebar", "parentTitle", "title"].sort(),
+      "Should omit blank bookmark-specific properties");
+    strictEqual(item.loadInSidebar, false, "Should not load bookmark in sidebar");
+    deepEqual(item.tags, [], "Tags should be empty");
+    equal(item.keyword, "kw", "Should return keyword");
+    strictEqual(item.parentTitle, "", "Should include parent title even if empty");
+    strictEqual(item.title, "", "Should include bookmark title even if empty");
+  }
+
+  do_print("Fetch separator");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.fetch(folderSep.syncId);
+    strictEqual(item.index, 1, "Should return separator position");
+  }
+
+  do_print("Fetch tag query");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.fetch(tagQuery.syncId);
+    deepEqual(Object.keys(item).sort(), ["syncId", "kind", "parentSyncId",
+      "url", "title", "folder", "parentTitle"].sort(),
+      "Should include query-specific properties");
+    equal(item.url.href, `place:type=7&folder=${tagFolderId}`, "Should not rewrite outgoing tag queries");
+    equal(item.folder, "taggy", "Should return tag name for tag queries");
+  }
+
+  do_print("Fetch smart bookmark");
+  {
+    let item = yield PlacesSyncUtils.bookmarks.fetch(smartBmk.syncId);
+    deepEqual(Object.keys(item).sort(), ["syncId", "kind", "parentSyncId",
+      "url", "title", "query", "parentTitle"].sort(),
+      "Should include smart bookmark-specific properties");
+    equal(item.query, "BookmarksToolbar", "Should return query name for smart bookmarks");
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
+
+add_task(function* test_fetch_livemark() {
+  let { site, stopServer } = makeLivemarkServer();
+
+  try {
+    do_print("Create livemark");
+    let livemark = yield PlacesUtils.livemarks.addLivemark({
+      parentGuid: PlacesUtils.bookmarks.menuGuid,
+      feedURI: uri(site + "/feed/1"),
+      siteURI: uri(site),
+      index: PlacesUtils.bookmarks.DEFAULT_INDEX,
+    });
+    PlacesUtils.annotations.setItemAnnotation(livemark.id, DESCRIPTION_ANNO,
+      "Livemark description", 0, PlacesUtils.annotations.EXPIRE_NEVER);
+
+    do_print("Fetch livemark");
+    let item = yield PlacesSyncUtils.bookmarks.fetch(livemark.guid);
+    deepEqual(Object.keys(item).sort(), ["syncId", "kind", "parentSyncId",
+      "description", "feed", "site", "parentTitle", "title"].sort(),
+      "Should include livemark-specific properties");
+    equal(item.description, "Livemark description", "Should return description");
+    equal(item.feed.href, site + "/feed/1", "Should return feed URL");
+    equal(item.site.href, site + "/", "Should return site URL");
+    strictEqual(item.title, "", "Should include livemark title even if empty");
+  } finally {
+    yield stopServer();
+  }
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
diff --git a/toolkit/components/places/tests/unit/test_tag_autocomplete_search.js b/toolkit/components/places/tests/unit/test_tag_autocomplete_search.js
new file mode 100644
index 000000000..92930e329
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_tag_autocomplete_search.js
@@ -0,0 +1,137 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var current_test = 0;
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+// Get tagging service
+try {
+  var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+                getService(Ci.nsITaggingService);
+} catch (ex) {
+  do_throw("Could not get tagging service\n");
+}
+
+function ensure_tag_results(results, searchTerm)
+{
+  var controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput(["places-tag-autocomplete"]);
+
+  controller.input = input;
+
+  var numSearchesStarted = 0;
+  input.onSearchBegin = function input_onSearchBegin() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  input.onSearchComplete = function input_onSearchComplete() {
+    do_check_eq(numSearchesStarted, 1);
+    if (results.length)
+      do_check_eq(controller.searchStatus,
+                  Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+    else
+      do_check_eq(controller.searchStatus,
+                  Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH);
+
+    do_check_eq(controller.matchCount, results.length);
+    for (var i=0; i<controller.matchCount; i++) {
+      do_check_eq(controller.getValueAt(i), results[i]);
+    }
+
+    if (current_test < (tests.length - 1)) {
+      current_test++;
+      tests[current_test]();
+    }
+    else {
+      // finish once all tests have run
+      do_test_finished();
+    }
+  };
+
+  controller.startSearch(searchTerm);
+}
+
+var uri1 = uri("http://site.tld/1");
+
+var tests = [
+  function test1() { ensure_tag_results(["bar", "Baz", "boo"], "b"); },
+  function test2() { ensure_tag_results(["bar", "Baz"], "ba"); },
+  function test3() { ensure_tag_results(["bar", "Baz"], "Ba"); },
+  function test4() { ensure_tag_results(["bar"], "bar"); },
+  function test5() { ensure_tag_results(["Baz"], "Baz"); },
+  function test6() { ensure_tag_results([], "barb"); },
+  function test7() { ensure_tag_results([], "foo"); },
+  function test8() { ensure_tag_results(["first tag, bar", "first tag, Baz"], "first tag, ba"); },
+  function test9() { ensure_tag_results(["first tag;  bar", "first tag;  Baz"], "first tag;  ba"); }
+];
+
+/**
+ * Test tag autocomplete
+ */
+function run_test() {
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  tagssvc.tagURI(uri1, ["bar", "Baz", "boo", "*nix"]);
+
+  tests[0]();
+}
diff --git a/toolkit/components/places/tests/unit/test_tagging.js b/toolkit/components/places/tests/unit/test_tagging.js
new file mode 100644
index 000000000..ccb287050
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_tagging.js
@@ -0,0 +1,189 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// Notice we use createInstance because later we will have to terminate the
+// service and restart it.
+var tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+              createInstance().QueryInterface(Ci.nsITaggingService);
+
+function run_test() {
+  var options = PlacesUtils.history.getNewQueryOptions();
+  var query = PlacesUtils.history.getNewQuery();
+
+  query.setFolders([PlacesUtils.tagsFolderId], 1);
+  var result = PlacesUtils.history.executeQuery(query, options);
+  var tagRoot = result.root;
+  tagRoot.containerOpen = true;
+
+  do_check_eq(tagRoot.childCount, 0);
+
+  var uri1 = uri("http://foo.tld/");
+  var uri2 = uri("https://bar.tld/");
+
+  // this also tests that the multiple folders are not created for the same tag
+  tagssvc.tagURI(uri1, ["tag 1"]);
+  tagssvc.tagURI(uri2, ["tag 1"]);
+  do_check_eq(tagRoot.childCount, 1);
+
+  var tag1node = tagRoot.getChild(0)
+                        .QueryInterface(Ci.nsINavHistoryContainerResultNode);
+  var tag1itemId = tag1node.itemId;
+
+  do_check_eq(tag1node.title, "tag 1");
+  tag1node.containerOpen = true;
+  do_check_eq(tag1node.childCount, 2);
+
+  // Tagging the same url twice (or even thrice!) with the same tag should be a
+  // no-op
+  tagssvc.tagURI(uri1, ["tag 1"]);
+  do_check_eq(tag1node.childCount, 2);
+  tagssvc.tagURI(uri1, [tag1itemId]);
+  do_check_eq(tag1node.childCount, 2);
+  do_check_eq(tagRoot.childCount, 1);
+
+  // also tests bug 407575
+  tagssvc.tagURI(uri1, [tag1itemId, "tag 1", "tag 2", "Tag 1", "Tag 2"]);
+  do_check_eq(tagRoot.childCount, 2);
+  do_check_eq(tag1node.childCount, 2);
+
+  // test getTagsForURI
+  var uri1tags = tagssvc.getTagsForURI(uri1);
+  do_check_eq(uri1tags.length, 2);
+  do_check_eq(uri1tags[0], "Tag 1");
+  do_check_eq(uri1tags[1], "Tag 2");
+  var uri2tags = tagssvc.getTagsForURI(uri2);
+  do_check_eq(uri2tags.length, 1);
+  do_check_eq(uri2tags[0], "Tag 1");
+
+  // test getURIsForTag
+  var tag1uris = tagssvc.getURIsForTag("tag 1");
+  do_check_eq(tag1uris.length, 2);
+  do_check_true(tag1uris[0].equals(uri1));
+  do_check_true(tag1uris[1].equals(uri2));
+
+  // test allTags attribute
+  var allTags = tagssvc.allTags;
+  do_check_eq(allTags.length, 2);
+  do_check_eq(allTags[0], "Tag 1");
+  do_check_eq(allTags[1], "Tag 2");
+
+  // test untagging
+  tagssvc.untagURI(uri1, ["tag 1"]);
+  do_check_eq(tag1node.childCount, 1);
+
+  // removing the last uri from a tag should remove the tag-container
+  tagssvc.untagURI(uri2, ["tag 1"]);
+  do_check_eq(tagRoot.childCount, 1);
+
+  // cleanup
+  tag1node.containerOpen = false;
+
+  // get array of tag folder ids => title
+  // for testing tagging with mixed folder ids and tags
+  var child = tagRoot.getChild(0);
+  var tagId = child.itemId;
+  var tagTitle = child.title;
+
+  // test mixed id/name tagging
+  // as well as non-id numeric tags
+  var uri3 = uri("http://testuri/3");
+  tagssvc.tagURI(uri3, [tagId, "tag 3", "456"]);
+  var tags = tagssvc.getTagsForURI(uri3);
+  do_check_true(tags.includes(tagTitle));
+  do_check_true(tags.includes("tag 3"));
+  do_check_true(tags.includes("456"));
+
+  // test mixed id/name tagging
+  tagssvc.untagURI(uri3, [tagId, "tag 3", "456"]);
+  tags = tagssvc.getTagsForURI(uri3);
+  do_check_eq(tags.length, 0);
+
+  // Terminate tagging service, fire up a new instance and check that existing
+  // tags are there.  This will ensure that any internal caching system is
+  // correctly filled at startup and we are not losing previously existing tags.
+  var uri4 = uri("http://testuri/4");
+  tagssvc.tagURI(uri4, [tagId, "tag 3", "456"]);
+  tagssvc = null;
+  tagssvc = Cc["@mozilla.org/browser/tagging-service;1"].
+            getService(Ci.nsITaggingService);
+  var uri4Tags = tagssvc.getTagsForURI(uri4);
+  do_check_eq(uri4Tags.length, 3);
+  do_check_true(uri4Tags.includes(tagTitle));
+  do_check_true(uri4Tags.includes("tag 3"));
+  do_check_true(uri4Tags.includes("456"));
+
+  // Test sparse arrays.
+  let curChildCount = tagRoot.childCount;
+
+  try {
+    tagssvc.tagURI(uri1, [, "tagSparse"]);
+    do_check_eq(tagRoot.childCount, curChildCount + 1);
+  } catch (ex) {
+    do_throw("Passing a sparse array should not throw");
+  }
+  try {
+    tagssvc.untagURI(uri1, [, "tagSparse"]);
+    do_check_eq(tagRoot.childCount, curChildCount);
+  } catch (ex) {
+    do_throw("Passing a sparse array should not throw");
+  }
+
+  // Test that the API throws for bad arguments.
+  try {
+    tagssvc.tagURI(uri1, ["", "test"]);
+    do_throw("Passing a bad tags array should throw");
+  } catch (ex) {
+    do_check_eq(ex.name, "NS_ERROR_ILLEGAL_VALUE");
+  }
+  try {
+    tagssvc.untagURI(uri1, ["", "test"]);
+    do_throw("Passing a bad tags array should throw");
+  } catch (ex) {
+    do_check_eq(ex.name, "NS_ERROR_ILLEGAL_VALUE");
+  }
+  try {
+    tagssvc.tagURI(uri1, [0, "test"]);
+    do_throw("Passing a bad tags array should throw");
+  } catch (ex) {
+    do_check_eq(ex.name, "NS_ERROR_ILLEGAL_VALUE");
+  }
+  try {
+    tagssvc.tagURI(uri1, [0, "test"]);
+    do_throw("Passing a bad tags array should throw");
+  } catch (ex) {
+    do_check_eq(ex.name, "NS_ERROR_ILLEGAL_VALUE");
+  }
+
+  // Tag name length should be limited to nsITaggingService.MAX_TAG_LENGTH (bug407821)
+  try {
+
+    // generate a long tag name. i.e. looooo...oong_tag
+    var n = Ci.nsITaggingService.MAX_TAG_LENGTH;
+    var someOos = new Array(n).join('o');
+    var longTagName = "l" + someOos + "ng_tag";
+
+    tagssvc.tagURI(uri1, ["short_tag", longTagName]);
+    do_throw("Passing a bad tags array should throw");
+
+  } catch (ex) {
+    do_check_eq(ex.name, "NS_ERROR_ILLEGAL_VALUE");
+  }
+
+  // cleanup
+  tagRoot.containerOpen = false;
+
+  // Tagging service should trim tags (Bug967196)
+  let exampleURI = uri("http://www.example.com/");
+  PlacesUtils.tagging.tagURI(exampleURI, [ " test " ]);
+
+  let exampleTags = PlacesUtils.tagging.getTagsForURI(exampleURI);
+  do_check_eq(exampleTags.length, 1);
+  do_check_eq(exampleTags[0], "test");
+
+  PlacesUtils.tagging.untagURI(exampleURI, [ "test" ]);
+  exampleTags = PlacesUtils.tagging.getTagsForURI(exampleURI);
+  do_check_eq(exampleTags.length, 0);
+}
diff --git a/toolkit/components/places/tests/unit/test_telemetry.js b/toolkit/components/places/tests/unit/test_telemetry.js
new file mode 100644
index 000000000..99f36d78c
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_telemetry.js
@@ -0,0 +1,166 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Tests common Places telemetry probes by faking the telemetry service.
+
+Components.utils.import("resource://gre/modules/PlacesDBUtils.jsm");
+
+var histograms = {
+  PLACES_PAGES_COUNT: val => do_check_eq(val, 1),
+  PLACES_BOOKMARKS_COUNT: val => do_check_eq(val, 1),
+  PLACES_TAGS_COUNT: val => do_check_eq(val, 1),
+  PLACES_KEYWORDS_COUNT: val => do_check_eq(val, 1),
+  PLACES_SORTED_BOOKMARKS_PERC: val => do_check_eq(val, 100),
+  PLACES_TAGGED_BOOKMARKS_PERC: val => do_check_eq(val, 100),
+  PLACES_DATABASE_FILESIZE_MB: val => do_check_true(val > 0),
+  PLACES_DATABASE_PAGESIZE_B: val => do_check_eq(val, 32768),
+  PLACES_DATABASE_SIZE_PER_PAGE_B: val => do_check_true(val > 0),
+  PLACES_EXPIRATION_STEPS_TO_CLEAN2: val => do_check_true(val > 1),
+  // PLACES_AUTOCOMPLETE_1ST_RESULT_TIME_MS:  val => do_check_true(val > 1),
+  PLACES_IDLE_FRECENCY_DECAY_TIME_MS: val => do_check_true(val >= 0),
+  PLACES_IDLE_MAINTENANCE_TIME_MS: val => do_check_true(val > 0),
+  // One from the `setItemAnnotation` call; the other from the mobile root.
+  // This can be removed along with the anno in bug 1306445.
+  PLACES_ANNOS_BOOKMARKS_COUNT: val => do_check_eq(val, 2),
+  PLACES_ANNOS_PAGES_COUNT: val => do_check_eq(val, 1),
+  PLACES_MAINTENANCE_DAYSFROMLAST: val => do_check_true(val >= 0),
+}
+
+/**
+ * Forces an expiration run.
+ *
+ * @param [optional] aLimit
+ *        Limit for the expiration.  Pass -1 for unlimited.
+ *        Any other non-positive value will just expire orphans.
+ *
+ * @return {Promise}
+ * @resolves When expiration finishes.
+ * @rejects Never.
+ */
+function promiseForceExpirationStep(aLimit) {
+  let promise = promiseTopicObserved(PlacesUtils.TOPIC_EXPIRATION_FINISHED);
+  let expire = Cc["@mozilla.org/places/expiration;1"].getService(Ci.nsIObserver);
+  expire.observe(null, "places-debug-start-expiration", aLimit);
+  return promise;
+}
+
+/**
+ * Returns a PRTime in the past usable to add expirable visits.
+ *
+ * param [optional] daysAgo
+ *       Expiration ignores any visit added in the last 7 days, so by default
+ *       this will be set to 7.
+ * @note to be safe against DST issues we go back one day more.
+ */
+function getExpirablePRTime(daysAgo = 7) {
+  let dateObj = new Date();
+  // Normalize to midnight
+  dateObj.setHours(0);
+  dateObj.setMinutes(0);
+  dateObj.setSeconds(0);
+  dateObj.setMilliseconds(0);
+  dateObj = new Date(dateObj.getTime() - (daysAgo + 1) * 86400000);
+  return dateObj.getTime() * 1000;
+}
+
+add_task(function* test_execute()
+{
+  // Put some trash in the database.
+  let uri = NetUtil.newURI("http://moz.org/");
+
+  let folderId = PlacesUtils.bookmarks.createFolder(PlacesUtils.unfiledBookmarksFolderId,
+                                                    "moz test",
+                                                    PlacesUtils.bookmarks.DEFAULT_INDEX);
+  let itemId = PlacesUtils.bookmarks.insertBookmark(folderId,
+                                                    uri,
+                                                    PlacesUtils.bookmarks.DEFAULT_INDEX,
+                                                    "moz test");
+  PlacesUtils.tagging.tagURI(uri, ["tag"]);
+  yield PlacesUtils.keywords.insert({ url: uri.spec, keyword: "keyword"});
+
+  // Set a large annotation.
+  let content = "";
+  while (content.length < 1024) {
+    content += "0";
+  }
+  PlacesUtils.annotations.setItemAnnotation(itemId, "test-anno", content, 0,
+                                            PlacesUtils.annotations.EXPIRE_NEVER);
+  PlacesUtils.annotations.setPageAnnotation(uri, "test-anno", content, 0,
+                                            PlacesUtils.annotations.EXPIRE_NEVER);
+
+  // Request to gather telemetry data.
+  Cc["@mozilla.org/places/categoriesStarter;1"]
+    .getService(Ci.nsIObserver)
+    .observe(null, "gather-telemetry", null);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+
+  // Test expiration probes.
+  let timeInMicroseconds = getExpirablePRTime(8);
+
+  function newTimeInMicroseconds() {
+    timeInMicroseconds = timeInMicroseconds + 1000;
+    return timeInMicroseconds;
+  }
+
+  for (let i = 0; i < 3; i++) {
+    yield PlacesTestUtils.addVisits({
+      uri: NetUtil.newURI("http://" +  i + ".moz.org/"),
+      visitDate: newTimeInMicroseconds()
+    });
+  }
+  Services.prefs.setIntPref("places.history.expiration.max_pages", 0);
+  yield promiseForceExpirationStep(2);
+  yield promiseForceExpirationStep(2);
+
+  // Test autocomplete probes.
+  /*
+  // This is useful for manual testing by changing the minimum time for
+  // autocomplete telemetry to 0, but there is no way to artificially delay
+  // autocomplete by more than 50ms in a realiable way.
+  Services.prefs.setIntPref("browser.urlbar.search.sources", 3);
+  Services.prefs.setIntPref("browser.urlbar.default.behavior", 0);
+  function AutoCompleteInput(aSearches) {
+    this.searches = aSearches;
+  }
+  AutoCompleteInput.prototype = {
+    timeout: 10,
+    textValue: "",
+    searchParam: "",
+    popupOpen: false,
+    minResultsForPopup: 0,
+    invalidate: function() {},
+    disableAutoComplete: false,
+    completeDefaultIndex: false,
+    get popup() { return this; },
+    onSearchBegin: function() {},
+    onSearchComplete: function() {},
+    setSelectedIndex: function() {},
+    get searchCount() { return this.searches.length; },
+    getSearchAt: function(aIndex) { return this.searches[aIndex]; },
+    QueryInterface: XPCOMUtils.generateQI([
+      Ci.nsIAutoCompleteInput,
+      Ci.nsIAutoCompletePopup,
+    ])
+  };
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+  controller.input = new AutoCompleteInput(["unifiedcomplete"]);
+  controller.startSearch("moz");
+  */
+
+  // Test idle probes.
+  PlacesUtils.history.QueryInterface(Ci.nsIObserver)
+                     .observe(null, "idle-daily", null);
+  PlacesDBUtils.maintenanceOnIdle();
+
+  yield promiseTopicObserved("places-maintenance-finished");
+
+  for (let histogramId in histograms) {
+    do_print("checking histogram " + histogramId);
+    let validate = histograms[histogramId];
+    let snapshot = Services.telemetry.getHistogramById(histogramId).snapshot();
+    validate(snapshot.sum);
+    do_check_true(snapshot.counts.reduce((a, b) => a + b) > 0);
+  }
+});
diff --git a/toolkit/components/places/tests/unit/test_update_frecency_after_delete.js b/toolkit/components/places/tests/unit/test_update_frecency_after_delete.js
new file mode 100644
index 000000000..662ea0841
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_update_frecency_after_delete.js
@@ -0,0 +1,151 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Bug 455315
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=412132
+ *
+ * Ensures that the frecency of a bookmark's URI is what it should be after the
+ * bookmark is deleted.
+ */
+
+add_task(function* removed_bookmark() {
+  do_print("After removing bookmark, frecency of bookmark's URI should be " +
+           "zero if URI is unvisited and no longer bookmarked.");
+  const TEST_URI = NetUtil.newURI("http://example.com/1");
+  let bm = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    title: "bookmark title",
+    url: TEST_URI
+  });
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("Bookmarked => frecency of URI should be != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.remove(bm);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("Unvisited URI no longer bookmarked => frecency should = 0");
+  do_check_eq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* removed_but_visited_bookmark() {
+  do_print("After removing bookmark, frecency of bookmark's URI should " +
+           "not be zero if URI is visited.");
+  const TEST_URI = NetUtil.newURI("http://example.com/1");
+  let bm = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    title: "bookmark title",
+    url: TEST_URI
+  });
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("Bookmarked => frecency of URI should be != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesTestUtils.addVisits(TEST_URI);
+  yield PlacesUtils.bookmarks.remove(bm);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("*Visited* URI no longer bookmarked => frecency should != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* remove_bookmark_still_bookmarked() {
+  do_print("After removing bookmark, frecency of bookmark's URI should " +
+           "not be zero if URI is still bookmarked.");
+  const TEST_URI = NetUtil.newURI("http://example.com/1");
+  let bm1 = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    title: "bookmark 1 title",
+    url: TEST_URI
+  });
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    title: "bookmark 2 title",
+    url: TEST_URI
+  });
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("Bookmarked => frecency of URI should be != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.remove(bm1);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("URI still bookmarked => frecency should != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* cleared_parent_of_visited_bookmark() {
+  do_print("After removing all children from bookmark's parent, frecency " +
+           "of bookmark's URI should not be zero if URI is visited.");
+  const TEST_URI = NetUtil.newURI("http://example.com/1");
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    title: "bookmark title",
+    url: TEST_URI
+  });
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("Bookmarked => frecency of URI should be != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesTestUtils.addVisits(TEST_URI);
+  PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.unfiledBookmarksFolderId);
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("*Visited* URI no longer bookmarked => frecency should != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
+
+add_task(function* cleared_parent_of_bookmark_still_bookmarked() {
+  do_print("After removing all children from bookmark's parent, frecency " +
+           "of bookmark's URI should not be zero if URI is still " +
+           "bookmarked.");
+  const TEST_URI = NetUtil.newURI("http://example.com/1");
+  yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.toolbarGuid,
+    title: "bookmark 1 title",
+    url: TEST_URI
+  });
+
+  let folder = yield PlacesUtils.bookmarks.insert({
+    parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+    type: PlacesUtils.bookmarks.TYPE_FOLDER,
+    title: "bookmark 2 folder"
+  });
+  yield PlacesUtils.bookmarks.insert({
+    title: "bookmark 2 title",
+    parentGuid: folder.guid,
+    url: TEST_URI
+  });
+
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  do_print("Bookmarked => frecency of URI should be != 0");
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.remove(folder);
+  yield PlacesTestUtils.promiseAsyncUpdates();
+  // URI still bookmarked => frecency should != 0.
+  do_check_neq(frecencyForUrl(TEST_URI), 0);
+
+  yield PlacesUtils.bookmarks.eraseEverything();
+  yield PlacesTestUtils.clearHistory();
+});
diff --git a/toolkit/components/places/tests/unit/test_utils_backups_create.js b/toolkit/components/places/tests/unit/test_utils_backups_create.js
new file mode 100644
index 000000000..a30589c44
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_utils_backups_create.js
@@ -0,0 +1,90 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+ /**
+  * Check for correct functionality of bookmarks backups
+  */
+
+const NUMBER_OF_BACKUPS = 10;
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* () {
+  // Generate random dates.
+  let dateObj = new Date();
+  let dates = [];
+  while (dates.length < NUMBER_OF_BACKUPS) {
+    // Use last year to ensure today's backup is the newest.
+    let randomDate = new Date(dateObj.getFullYear() - 1,
+                              Math.floor(12 * Math.random()),
+                              Math.floor(28 * Math.random()));
+    if (!dates.includes(randomDate.getTime()))
+      dates.push(randomDate.getTime());
+  }
+  // Sort dates from oldest to newest.
+  dates.sort();
+
+  // Get and cleanup the backups folder.
+  let backupFolderPath = yield PlacesBackups.getBackupFolder();
+  let bookmarksBackupDir = new FileUtils.File(backupFolderPath);
+
+  // Fake backups are created backwards to ensure we won't consider file
+  // creation time.
+  // Create fake backups for the newest dates.
+  for (let i = dates.length - 1; i >= 0; i--) {
+    let backupFilename = PlacesBackups.getFilenameForDate(new Date(dates[i]));
+    let backupFile = bookmarksBackupDir.clone();
+    backupFile.append(backupFilename);
+    backupFile.create(Ci.nsIFile.NORMAL_FILE_TYPE, parseInt("0666", 8));
+    do_print("Creating fake backup " + backupFile.leafName);
+    if (!backupFile.exists())
+      do_throw("Unable to create fake backup " + backupFile.leafName);
+  }
+
+  yield PlacesBackups.create(NUMBER_OF_BACKUPS);
+  // Add today's backup.
+  dates.push(dateObj.getTime());
+
+  // Check backups.  We have 11 dates but we the max number is 10 so the
+  // oldest backup should have been removed.
+  for (let i = 0; i < dates.length; i++) {
+    let backupFilename;
+    let shouldExist;
+    let backupFile;
+    if (i > 0) {
+      let files = bookmarksBackupDir.directoryEntries;
+      while (files.hasMoreElements()) {
+        let entry = files.getNext().QueryInterface(Ci.nsIFile);
+        if (PlacesBackups.filenamesRegex.test(entry.leafName)) {
+          backupFilename = entry.leafName;
+          backupFile = entry;
+          break;
+        }
+      }
+      shouldExist = true;
+    }
+    else {
+      backupFilename = PlacesBackups.getFilenameForDate(new Date(dates[i]));
+      backupFile = bookmarksBackupDir.clone();
+      backupFile.append(backupFilename);
+      shouldExist = false;
+    }
+    if (backupFile.exists() != shouldExist)
+      do_throw("Backup should " + (shouldExist ? "" : "not") + " exist: " + backupFilename);
+  }
+
+  // Cleanup backups folder.
+  // XXX: Can't use bookmarksBackupDir.remove(true) because file lock happens
+  // on WIN XP.
+  let files = bookmarksBackupDir.directoryEntries;
+  while (files.hasMoreElements()) {
+    let entry = files.getNext().QueryInterface(Ci.nsIFile);
+    entry.remove(false);
+  }
+  do_check_false(bookmarksBackupDir.directoryEntries.hasMoreElements());
+});
diff --git a/toolkit/components/places/tests/unit/test_utils_getURLsForContainerNode.js b/toolkit/components/places/tests/unit/test_utils_getURLsForContainerNode.js
new file mode 100644
index 000000000..ecebce94a
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_utils_getURLsForContainerNode.js
@@ -0,0 +1,180 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+ /**
+  * Check for correct functionality of PlacesUtils.getURLsForContainerNode and
+  * PlacesUtils.hasChildURIs (those helpers share almost all of their code)
+  */
+
+var PU = PlacesUtils;
+var hs = PU.history;
+var bs = PU.bookmarks;
+
+var tests = [
+
+function() {
+  dump("\n\n*** TEST: folder\n");
+  // This is the folder we will check for children.
+  var folderId = bs.createFolder(bs.toolbarFolder, "folder", bs.DEFAULT_INDEX);
+
+  // Create a folder and a query node inside it, these should not be considered
+  // uri nodes.
+  bs.createFolder(folderId, "inside folder", bs.DEFAULT_INDEX);
+  bs.insertBookmark(folderId, uri("place:sort=1"),
+                    bs.DEFAULT_INDEX, "inside query");
+
+  var query = hs.getNewQuery();
+  query.setFolders([bs.toolbarFolder], 1);
+  var options = hs.getNewQueryOptions();
+
+  dump("Check folder without uri nodes\n");
+  check_uri_nodes(query, options, 0);
+
+  dump("Check folder with uri nodes\n");
+  // Add an uri node, this should be considered.
+  bs.insertBookmark(folderId, uri("http://www.mozilla.org/"),
+                    bs.DEFAULT_INDEX, "bookmark");
+  check_uri_nodes(query, options, 1);
+},
+
+function() {
+  dump("\n\n*** TEST: folder in an excludeItems root\n");
+  // This is the folder we will check for children.
+  var folderId = bs.createFolder(bs.toolbarFolder, "folder", bs.DEFAULT_INDEX);
+
+  // Create a folder and a query node inside it, these should not be considered
+  // uri nodes.
+  bs.createFolder(folderId, "inside folder", bs.DEFAULT_INDEX);
+  bs.insertBookmark(folderId, uri("place:sort=1"), bs.DEFAULT_INDEX, "inside query");
+
+  var query = hs.getNewQuery();
+  query.setFolders([bs.toolbarFolder], 1);
+  var options = hs.getNewQueryOptions();
+  options.excludeItems = true;
+
+  dump("Check folder without uri nodes\n");
+  check_uri_nodes(query, options, 0);
+
+  dump("Check folder with uri nodes\n");
+  // Add an uri node, this should be considered.
+  bs.insertBookmark(folderId, uri("http://www.mozilla.org/"),
+                    bs.DEFAULT_INDEX, "bookmark");
+  check_uri_nodes(query, options, 1);
+},
+
+function() {
+  dump("\n\n*** TEST: query\n");
+  // This is the query we will check for children.
+  bs.insertBookmark(bs.toolbarFolder, uri("place:folder=BOOKMARKS_MENU&sort=1"),
+                    bs.DEFAULT_INDEX, "inside query");
+
+  // Create a folder and a query node inside it, these should not be considered
+  // uri nodes.
+  bs.createFolder(bs.bookmarksMenuFolder, "inside folder", bs.DEFAULT_INDEX);
+  bs.insertBookmark(bs.bookmarksMenuFolder, uri("place:sort=1"),
+                    bs.DEFAULT_INDEX, "inside query");
+
+  var query = hs.getNewQuery();
+  query.setFolders([bs.toolbarFolder], 1);
+  var options = hs.getNewQueryOptions();
+
+  dump("Check query without uri nodes\n");
+  check_uri_nodes(query, options, 0);
+
+  dump("Check query with uri nodes\n");
+  // Add an uri node, this should be considered.
+  bs.insertBookmark(bs.bookmarksMenuFolder, uri("http://www.mozilla.org/"),
+                    bs.DEFAULT_INDEX, "bookmark");
+  check_uri_nodes(query, options, 1);
+},
+
+function() {
+  dump("\n\n*** TEST: excludeItems Query\n");
+  // This is the query we will check for children.
+  bs.insertBookmark(bs.toolbarFolder, uri("place:folder=BOOKMARKS_MENU&sort=8"),
+                    bs.DEFAULT_INDEX, "inside query");
+
+  // Create a folder and a query node inside it, these should not be considered
+  // uri nodes.
+  bs.createFolder(bs.bookmarksMenuFolder, "inside folder", bs.DEFAULT_INDEX);
+  bs.insertBookmark(bs.bookmarksMenuFolder, uri("place:sort=1"),
+                    bs.DEFAULT_INDEX, "inside query");
+
+  var query = hs.getNewQuery();
+  query.setFolders([bs.toolbarFolder], 1);
+  var options = hs.getNewQueryOptions();
+  options.excludeItems = true;
+
+  dump("Check folder without uri nodes\n");
+  check_uri_nodes(query, options, 0);
+
+  dump("Check folder with uri nodes\n");
+  // Add an uri node, this should be considered.
+  bs.insertBookmark(bs.bookmarksMenuFolder, uri("http://www.mozilla.org/"),
+                    bs.DEFAULT_INDEX, "bookmark");
+  check_uri_nodes(query, options, 1);
+},
+
+function() {
+  dump("\n\n*** TEST: !expandQueries Query\n");
+  // This is the query we will check for children.
+  bs.insertBookmark(bs.toolbarFolder, uri("place:folder=BOOKMARKS_MENU&sort=8"),
+                    bs.DEFAULT_INDEX, "inside query");
+
+  // Create a folder and a query node inside it, these should not be considered
+  // uri nodes.
+  bs.createFolder(bs.bookmarksMenuFolder, "inside folder", bs.DEFAULT_INDEX);
+  bs.insertBookmark(bs.bookmarksMenuFolder, uri("place:sort=1"),
+                    bs.DEFAULT_INDEX, "inside query");
+
+  var query = hs.getNewQuery();
+  query.setFolders([bs.toolbarFolder], 1);
+  var options = hs.getNewQueryOptions();
+  options.expandQueries = false;
+
+  dump("Check folder without uri nodes\n");
+  check_uri_nodes(query, options, 0);
+
+  dump("Check folder with uri nodes\n");
+  // Add an uri node, this should be considered.
+  bs.insertBookmark(bs.bookmarksMenuFolder, uri("http://www.mozilla.org/"),
+                    bs.DEFAULT_INDEX, "bookmark");
+  check_uri_nodes(query, options, 1);
+}
+
+];
+
+/**
+ * Executes a query and checks number of uri nodes in the first container in
+ * query's results.  To correctly test a container ensure that the query will
+ * return only your container in the first level.
+ *
+ * @param  aQuery
+ *         nsINavHistoryQuery object defining the query
+ * @param  aOptions
+ *         nsINavHistoryQueryOptions object defining the query's options
+ * @param  aExpectedURINodes
+ *         number of expected uri nodes
+ */
+function check_uri_nodes(aQuery, aOptions, aExpectedURINodes) {
+  var result = hs.executeQuery(aQuery, aOptions);
+  var root = result.root;
+  root.containerOpen = true;
+  var node = root.getChild(0);
+  do_check_eq(PU.hasChildURIs(node), aExpectedURINodes > 0);
+  do_check_eq(PU.getURLsForContainerNode(node).length, aExpectedURINodes);
+  root.containerOpen = false;
+}
+
+add_task(function* () {
+  for (let test of tests) {
+    yield PlacesUtils.bookmarks.eraseEverything();
+    test();
+  }
+
+  // Cleanup.
+  yield PlacesUtils.bookmarks.eraseEverything();
+});
diff --git a/toolkit/components/places/tests/unit/test_utils_setAnnotationsFor.js b/toolkit/components/places/tests/unit/test_utils_setAnnotationsFor.js
new file mode 100644
index 000000000..62947620d
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_utils_setAnnotationsFor.js
@@ -0,0 +1,79 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+ /**
+  * Check for correct functionality of PlacesUtils.setAnnotationsForItem/URI
+  */
+
+var hs = PlacesUtils.history;
+var bs = PlacesUtils.bookmarks;
+var as = PlacesUtils.annotations;
+
+const TEST_URL = "http://test.mozilla.org/";
+
+function run_test() {
+  var testURI = uri(TEST_URL);
+  // add a bookmark
+  var itemId = bs.insertBookmark(bs.unfiledBookmarksFolder, testURI,
+                                 bs.DEFAULT_INDEX, "test");
+
+  // create annotations array
+  var testAnnos = [{ name: "testAnno/test0",
+                     flags: 0,
+                     value: "test0",
+                     expires: Ci.nsIAnnotationService.EXPIRE_NEVER },
+                   { name: "testAnno/test1",
+                     flags: 0,
+                     value: "test1",
+                     expires: Ci.nsIAnnotationService.EXPIRE_NEVER },
+                   { name: "testAnno/test2",
+                     flags: 0,
+                     value: "test2",
+                     expires: Ci.nsIAnnotationService.EXPIRE_NEVER },
+                   { name: "testAnno/test3",
+                     flags: 0,
+                     value: 0,
+                     expires: Ci.nsIAnnotationService.EXPIRE_NEVER }];
+
+  // Add item annotations
+  PlacesUtils.setAnnotationsForItem(itemId, testAnnos);
+  // Check for correct addition
+  testAnnos.forEach(function(anno) {
+    do_check_true(as.itemHasAnnotation(itemId, anno.name));
+    do_check_eq(as.getItemAnnotation(itemId, anno.name), anno.value);
+  });
+
+  // Add page annotations
+  PlacesUtils.setAnnotationsForURI(testURI, testAnnos);
+  // Check for correct addition
+  testAnnos.forEach(function(anno) {
+    do_check_true(as.pageHasAnnotation(testURI, anno.name));
+    do_check_eq(as.getPageAnnotation(testURI, anno.name), anno.value);
+  });
+
+  // To unset annotations we unset their values or set them to
+  // null/undefined
+  testAnnos[0].value = null;
+  testAnnos[1].value = undefined;
+  delete testAnnos[2].value;
+  delete testAnnos[3].value;
+
+  // Unset all item annotations
+  PlacesUtils.setAnnotationsForItem(itemId, testAnnos);
+  // Check for correct removal
+  testAnnos.forEach(function(anno) {
+    do_check_false(as.itemHasAnnotation(itemId, anno.name));
+    // sanity: page annotations should not be removed here
+    do_check_true(as.pageHasAnnotation(testURI, anno.name));
+  });
+
+  // Unset all page annotations
+  PlacesUtils.setAnnotationsForURI(testURI, testAnnos);
+  // Check for correct removal
+  testAnnos.forEach(function(anno) {
+    do_check_false(as.pageHasAnnotation(testURI, anno.name));
+  });
+}
diff --git a/toolkit/components/places/tests/unit/test_visitsInDB.js b/toolkit/components/places/tests/unit/test_visitsInDB.js
new file mode 100644
index 000000000..3cab39ed9
--- /dev/null
+++ b/toolkit/components/places/tests/unit/test_visitsInDB.js
@@ -0,0 +1,12 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+
+add_task(function* test_execute() {
+  const TEST_URI = uri("http://mozilla.com");
+
+  do_check_eq(0, yield PlacesTestUtils.visitsInDB(TEST_URI));
+  yield PlacesTestUtils.addVisits({uri: TEST_URI});
+  do_check_eq(1, yield PlacesTestUtils.visitsInDB(TEST_URI));
+  yield PlacesTestUtils.addVisits({uri: TEST_URI});
+  do_check_eq(2, yield PlacesTestUtils.visitsInDB(TEST_URI));
+});
diff --git a/toolkit/components/places/tests/unit/xpcshell.ini b/toolkit/components/places/tests/unit/xpcshell.ini
new file mode 100644
index 000000000..60bba4758
--- /dev/null
+++ b/toolkit/components/places/tests/unit/xpcshell.ini
@@ -0,0 +1,163 @@
+[DEFAULT]
+head = head_bookmarks.js
+tail =
+firefox-appdir = browser
+skip-if = toolkit == 'android'
+support-files =
+  bookmarks.corrupt.html
+  bookmarks.json
+  bookmarks.preplaces.html
+  bookmarks_html_singleframe.html
+  bug476292.sqlite
+  corruptDB.sqlite
+  default.sqlite
+  livemark.xml
+  mobile_bookmarks_folder_import.json
+  mobile_bookmarks_folder_merge.json
+  mobile_bookmarks_multiple_folders.json
+  mobile_bookmarks_root_import.json
+  mobile_bookmarks_root_merge.json
+  nsDummyObserver.js
+  nsDummyObserver.manifest
+  places.sparse.sqlite
+
+[test_000_frecency.js]
+[test_317472.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_331487.js]
+[test_384370.js]
+[test_385397.js]
+# Bug 676989: test fails consistently on Android
+fail-if = os == "android"
+[test_399264_query_to_string.js]
+[test_399264_string_to_query.js]
+[test_399266.js]
+# Bug 676989: test fails consistently on Android
+fail-if = os == "android"
+# Bug 821781: test fails intermittently on Linux
+skip-if = os == "linux"
+[test_402799.js]
+[test_405497.js]
+[test_408221.js]
+[test_412132.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_413784.js]
+[test_415460.js]
+[test_415757.js]
+[test_418643_removeFolderChildren.js]
+[test_419731.js]
+[test_419792_node_tags_property.js]
+[test_425563.js]
+[test_429505_remove_shortcuts.js]
+[test_433317_query_title_update.js]
+[test_433525_hasChildren_crash.js]
+[test_452777.js]
+[test_454977.js]
+[test_463863.js]
+[test_485442_crash_bug_nsNavHistoryQuery_GetUri.js]
+[test_486978_sort_by_date_queries.js]
+[test_536081.js]
+[test_1085291.js]
+[test_1105208.js]
+[test_1105866.js]
+[test_adaptive.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_adaptive_bug527311.js]
+[test_analyze.js]
+[test_annotations.js]
+[test_asyncExecuteLegacyQueries.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_async_history_api.js]
+[test_async_in_batchmode.js]
+[test_async_transactions.js]
+skip-if = (os == "win" && os_version == "5.1") # Bug 1158887
+[test_autocomplete_stopSearch_no_throw.js]
+[test_bookmark_catobs.js]
+[test_bookmarks_json.js]
+[test_bookmarks_html.js]
+[test_bookmarks_html_corrupt.js]
+[test_bookmarks_html_import_tags.js]
+[test_bookmarks_html_singleframe.js]
+[test_bookmarks_restore_notification.js]
+[test_bookmarks_setNullTitle.js]
+[test_broken_folderShortcut_result.js]
+[test_browserhistory.js]
+[test_bug636917_isLivemark.js]
+[test_childlessTags.js]
+[test_corrupt_telemetry.js]
+[test_crash_476292.js]
+[test_database_replaceOnStartup.js]
+[test_download_history.js]
+# Bug 676989: test fails consistently on Android
+fail-if = os == "android"
+[test_frecency.js]
+[test_frecency_zero_updated.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_getChildIndex.js]
+[test_getPlacesInfo.js]
+[test_history.js]
+[test_history_autocomplete_tags.js]
+[test_history_catobs.js]
+[test_history_clear.js]
+[test_history_notifications.js]
+[test_history_observer.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_history_sidebar.js]
+[test_hosts_triggers.js]
+[test_import_mobile_bookmarks.js]
+[test_isPageInDB.js]
+[test_isURIVisited.js]
+[test_isvisited.js]
+[test_keywords.js]
+[test_lastModified.js]
+[test_markpageas.js]
+[test_mozIAsyncLivemarks.js]
+[test_multi_queries.js]
+# Bug 676989: test fails consistently on Android
+fail-if = os == "android"
+[test_multi_word_tags.js]
+[test_nsINavHistoryViewer.js]
+# Bug 902248: intermittent timeouts on all platforms
+skip-if = true
+[test_null_interfaces.js]
+[test_onItemChanged_tags.js]
+[test_pageGuid_bookmarkGuid.js]
+[test_frecency_observers.js]
+[test_placeURIs.js]
+[test_PlacesSearchAutocompleteProvider.js]
+[test_PlacesUtils_asyncGetBookmarkIds.js]
+[test_PlacesUtils_invalidateCachedGuidFor.js]
+[test_PlacesUtils_lazyobservers.js]
+[test_placesTxn.js]
+[test_preventive_maintenance.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_preventive_maintenance_checkAndFixDatabase.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_preventive_maintenance_runTasks.js]
+[test_promiseBookmarksTree.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_resolveNullBookmarkTitles.js]
+[test_result_sort.js]
+[test_resultsAsVisit_details.js]
+[test_sql_guid_functions.js]
+[test_svg_favicon.js]
+[test_sync_utils.js]
+[test_tag_autocomplete_search.js]
+[test_tagging.js]
+[test_telemetry.js]
+[test_update_frecency_after_delete.js]
+# Bug 676989: test hangs consistently on Android
+skip-if = os == "android"
+[test_utils_backups_create.js]
+[test_utils_getURLsForContainerNode.js]
+[test_utils_setAnnotationsFor.js]
+[test_visitsInDB.js]