Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2098 insertions, 0 deletions

diff --git a/toolkit/components/places/PlacesSyncUtils.sys.mjs b/toolkit/components/places/PlacesSyncUtils.sys.mjs
new file mode 100644
index 0000000000..6da1b91243
--- /dev/null
+++ b/toolkit/components/places/PlacesSyncUtils.sys.mjs
@@ -0,0 +1,2098 @@
+/* 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 lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Log: "resource://gre/modules/Log.sys.mjs",
+  PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
+});
+
+/**
+ * This module exports functions for Sync to use when applying remote
+ * records. The calls are similar to those in `Bookmarks.jsm` and
+ * `nsINavBookmarksService`, with special handling for
+ * tags, keywords, synced annotations, and missing parents.
+ */
+export var PlacesSyncUtils = {};
+
+const { SOURCE_SYNC } = Ci.nsINavBookmarksService;
+
+const MICROSECONDS_PER_SECOND = 1000000;
+
+const MOBILE_BOOKMARKS_PREF = "browser.bookmarks.showMobileBookmarks";
+
+// These are defined as lazy getters to defer initializing the bookmarks
+// service until it's needed.
+ChromeUtils.defineLazyGetter(lazy, "ROOT_RECORD_ID_TO_GUID", () => ({
+  menu: lazy.PlacesUtils.bookmarks.menuGuid,
+  places: lazy.PlacesUtils.bookmarks.rootGuid,
+  tags: lazy.PlacesUtils.bookmarks.tagsGuid,
+  toolbar: lazy.PlacesUtils.bookmarks.toolbarGuid,
+  unfiled: lazy.PlacesUtils.bookmarks.unfiledGuid,
+  mobile: lazy.PlacesUtils.bookmarks.mobileGuid,
+}));
+
+ChromeUtils.defineLazyGetter(lazy, "ROOT_GUID_TO_RECORD_ID", () => ({
+  [lazy.PlacesUtils.bookmarks.menuGuid]: "menu",
+  [lazy.PlacesUtils.bookmarks.rootGuid]: "places",
+  [lazy.PlacesUtils.bookmarks.tagsGuid]: "tags",
+  [lazy.PlacesUtils.bookmarks.toolbarGuid]: "toolbar",
+  [lazy.PlacesUtils.bookmarks.unfiledGuid]: "unfiled",
+  [lazy.PlacesUtils.bookmarks.mobileGuid]: "mobile",
+}));
+
+ChromeUtils.defineLazyGetter(lazy, "ROOTS", () =>
+  Object.keys(lazy.ROOT_RECORD_ID_TO_GUID)
+);
+
+// Gets the history transition values we ignore and do not sync, as a
+// string, which is a comma-separated set of values - ie, something which can
+// be used with sqlite's IN operator. Does *not* includes the parens.
+ChromeUtils.defineLazyGetter(lazy, "IGNORED_TRANSITIONS_AS_SQL_LIST", () =>
+  // * We don't sync `TRANSITION_FRAMED_LINK` visits - these are excluded when
+  //   rendering the history menu, so we use the same constraints for Sync.
+  // * We don't sync `TRANSITION_DOWNLOAD` because it makes no sense to see
+  //   these on other devices - the downloaded file can not exist.
+  // * We don't want to sync TRANSITION_EMBED visits, but these aren't
+  //   stored in the DB, so no need to specify them.
+  // * 0 is invalid, and hopefully don't exist, but let's exclude it anyway.
+  // Array.toString() semantics are well defined and exactly what we need, so..
+  [
+    0,
+    lazy.PlacesUtils.history.TRANSITION_FRAMED_LINK,
+    lazy.PlacesUtils.history.TRANSITION_DOWNLOAD,
+  ].toString()
+);
+
+const HistorySyncUtils = (PlacesSyncUtils.history = Object.freeze({
+  SYNC_ID_META_KEY: "sync/history/syncId",
+  LAST_SYNC_META_KEY: "sync/history/lastSync",
+
+  /**
+   * Returns the current history sync ID, or `""` if one isn't set.
+   */
+  getSyncId() {
+    return lazy.PlacesUtils.metadata.get(HistorySyncUtils.SYNC_ID_META_KEY, "");
+  },
+
+  /**
+   * Assigns a new sync ID. This is called when we sync for the first time with
+   * a new account, and when we're the first to sync after a node reassignment.
+   *
+   * @return {Promise} resolved once the ID has been updated.
+   * @resolves to the new sync ID.
+   */
+  resetSyncId() {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "HistorySyncUtils: resetSyncId",
+      function (db) {
+        let newSyncId = lazy.PlacesUtils.history.makeGuid();
+        return db.executeTransaction(async function () {
+          await setHistorySyncId(db, newSyncId);
+          return newSyncId;
+        });
+      }
+    );
+  },
+
+  /**
+   * Ensures that the existing local sync ID, if any, is up-to-date with the
+   * server. This is called when we sync with an existing account.
+   *
+   * @param newSyncId
+   *        The server's sync ID.
+   * @return {Promise} resolved once the ID has been updated.
+   */
+  async ensureCurrentSyncId(newSyncId) {
+    if (!newSyncId || typeof newSyncId != "string") {
+      throw new TypeError("Invalid new history sync ID");
+    }
+    await lazy.PlacesUtils.withConnectionWrapper(
+      "HistorySyncUtils: ensureCurrentSyncId",
+      async function (db) {
+        let existingSyncId = await lazy.PlacesUtils.metadata.getWithConnection(
+          db,
+          HistorySyncUtils.SYNC_ID_META_KEY,
+          ""
+        );
+
+        if (existingSyncId == newSyncId) {
+          lazy.HistorySyncLog.trace("History sync ID up-to-date", {
+            existingSyncId,
+          });
+          return;
+        }
+
+        lazy.HistorySyncLog.info(
+          "History sync ID changed; resetting metadata",
+          {
+            existingSyncId,
+            newSyncId,
+          }
+        );
+        await db.executeTransaction(function () {
+          return setHistorySyncId(db, newSyncId);
+        });
+      }
+    );
+  },
+
+  /**
+   * Returns the last sync time, in seconds, for the history collection, or 0
+   * if history has never synced before.
+   */
+  async getLastSync() {
+    let lastSync = await lazy.PlacesUtils.metadata.get(
+      HistorySyncUtils.LAST_SYNC_META_KEY,
+      0
+    );
+    return lastSync / 1000;
+  },
+
+  /**
+   * Updates the history collection last sync time.
+   *
+   * @param lastSyncSeconds
+   *        The collection last sync time, in seconds, as a number or string.
+   */
+  async setLastSync(lastSyncSeconds) {
+    let lastSync = Math.floor(lastSyncSeconds * 1000);
+    if (!Number.isInteger(lastSync)) {
+      throw new TypeError("Invalid history last sync timestamp");
+    }
+    await lazy.PlacesUtils.metadata.set(
+      HistorySyncUtils.LAST_SYNC_META_KEY,
+      lastSync
+    );
+  },
+
+  /**
+   * Removes all history visits and pages from the database. Sync calls this
+   * method when it receives a command from a remote client to wipe all stored
+   * data.
+   *
+   * @return {Promise} resolved once all pages and visits have been removed.
+   */
+  async wipe() {
+    await lazy.PlacesUtils.history.clear();
+    await HistorySyncUtils.reset();
+  },
+
+  /**
+   * Removes the sync ID and last sync time for the history collection. Unlike
+   * `wipe`, this keeps all existing history pages and visits.
+   *
+   * @return {Promise} resolved once the metadata have been removed.
+   */
+  reset() {
+    return lazy.PlacesUtils.metadata.delete(
+      HistorySyncUtils.SYNC_ID_META_KEY,
+      HistorySyncUtils.LAST_SYNC_META_KEY
+    );
+  },
+
+  /**
+   * Clamps a history visit date between the current date and the earliest
+   * sensible date.
+   *
+   * @param {Date} visitDate
+   *        The visit date.
+   * @return {Date} The clamped visit date.
+   */
+  clampVisitDate(visitDate) {
+    let currentDate = new Date();
+    if (visitDate > currentDate) {
+      return currentDate;
+    }
+    if (visitDate < BookmarkSyncUtils.EARLIEST_BOOKMARK_TIMESTAMP) {
+      return new Date(BookmarkSyncUtils.EARLIEST_BOOKMARK_TIMESTAMP);
+    }
+    return visitDate;
+  },
+
+  /**
+   * Fetches the frecency for the URL provided
+   *
+   * @param url
+   * @returns {Number} The frecency of the given url
+   */
+  async fetchURLFrecency(url) {
+    let canonicalURL = lazy.PlacesUtils.SYNC_BOOKMARK_VALIDATORS.url(url);
+
+    let db = await lazy.PlacesUtils.promiseDBConnection();
+    let rows = await db.executeCached(
+      `
+      SELECT frecency
+      FROM moz_places
+      WHERE url_hash = hash(:url) AND url = :url
+      LIMIT 1`,
+      { url: canonicalURL.href }
+    );
+
+    return rows.length ? rows[0].getResultByName("frecency") : -1;
+  },
+
+  /**
+   * Filters syncable places from a collection of places guids.
+   *
+   * @param guids
+   *
+   * @returns {Array} new Array with the guids that aren't syncable
+   */
+  async determineNonSyncableGuids(guids) {
+    // Filter out hidden pages and transitions that we don't sync.
+    let db = await lazy.PlacesUtils.promiseDBConnection();
+    let nonSyncableGuids = [];
+    for (let chunk of lazy.PlacesUtils.chunkArray(guids, db.variableLimit)) {
+      let rows = await db.execute(
+        `
+        SELECT DISTINCT p.guid FROM moz_places p
+        JOIN moz_historyvisits v ON p.id = v.place_id
+        WHERE p.guid IN (${new Array(chunk.length).fill("?").join(",")}) AND
+            (p.hidden = 1 OR v.visit_type IN (${
+              lazy.IGNORED_TRANSITIONS_AS_SQL_LIST
+            }))
+      `,
+        chunk
+      );
+      nonSyncableGuids = nonSyncableGuids.concat(
+        rows.map(row => row.getResultByName("guid"))
+      );
+    }
+    return nonSyncableGuids;
+  },
+
+  /**
+   * Change the guid of the given uri
+   *
+   * @param uri
+   * @param guid
+   */
+  changeGuid(uri, guid) {
+    let canonicalURL = lazy.PlacesUtils.SYNC_BOOKMARK_VALIDATORS.url(uri);
+    let validatedGuid = lazy.PlacesUtils.BOOKMARK_VALIDATORS.guid(guid);
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "PlacesSyncUtils.history: changeGuid",
+      async function (db) {
+        await db.executeCached(
+          `
+            UPDATE moz_places
+            SET guid = :guid
+            WHERE url_hash = hash(:page_url) AND url = :page_url`,
+          { guid: validatedGuid, page_url: canonicalURL.href }
+        );
+      }
+    );
+  },
+
+  /**
+   * Fetch the last 20 visits (date and type of it) corresponding to a given url
+   *
+   * @param url
+   * @returns {Array} Each element of the Array is an object with members: date and type
+   */
+  async fetchVisitsForURL(url) {
+    let canonicalURL = lazy.PlacesUtils.SYNC_BOOKMARK_VALIDATORS.url(url);
+    let db = await lazy.PlacesUtils.promiseDBConnection();
+    let rows = await db.executeCached(
+      `
+      SELECT visit_type type, visit_date date,
+      json_extract(e.sync_json, '$.unknown_sync_fields') as unknownSyncFields
+      FROM moz_historyvisits v
+      JOIN moz_places h ON h.id = v.place_id
+      LEFT OUTER JOIN moz_historyvisits_extra e ON e.visit_id = v.id
+      WHERE url_hash = hash(:url) AND url = :url
+      ORDER BY date DESC LIMIT 20`,
+      { url: canonicalURL.href }
+    );
+    return rows.map(row => {
+      let visitDate = row.getResultByName("date");
+      let visitType = row.getResultByName("type");
+      let visit = { date: visitDate, type: visitType };
+
+      // We should grab unknown fields to roundtrip them
+      // back to the server
+      let unknownFields = row.getResultByName("unknownSyncFields");
+      if (unknownFields) {
+        let unknownFieldsObj = JSON.parse(unknownFields);
+        for (const key in unknownFieldsObj) {
+          // We have to manually add it to the cleartext since that's
+          // what gets processed during upload
+          visit[key] = unknownFieldsObj[key];
+        }
+      }
+      return visit;
+    });
+  },
+
+  /**
+   * Fetches the guid of a uri
+   *
+   * @param uri
+   * @returns {String} The guid of the given uri
+   */
+  async fetchGuidForURL(url) {
+    let canonicalURL = lazy.PlacesUtils.SYNC_BOOKMARK_VALIDATORS.url(url);
+    let db = await lazy.PlacesUtils.promiseDBConnection();
+    let rows = await db.executeCached(
+      `
+        SELECT guid
+        FROM moz_places
+        WHERE url_hash = hash(:page_url) AND url = :page_url`,
+      { page_url: canonicalURL.href }
+    );
+    if (!rows.length) {
+      return null;
+    }
+    return rows[0].getResultByName("guid");
+  },
+
+  /**
+   * Fetch information about a guid (url, title and frecency)
+   *
+   * @param guid
+   * @returns {Object} Object with three members: url, title and frecency of the given guid
+   */
+  async fetchURLInfoForGuid(guid) {
+    let db = await lazy.PlacesUtils.promiseDBConnection();
+    let rows = await db.executeCached(
+      `
+      SELECT url, IFNULL(title, '') AS title, frecency,
+      json_extract(e.sync_json, '$.unknown_sync_fields') as unknownSyncFields
+      FROM moz_places h
+      LEFT OUTER JOIN moz_places_extra e ON e.place_id = h.id
+      WHERE guid = :guid`,
+      { guid }
+    );
+    if (rows.length === 0) {
+      return null;
+    }
+
+    let info = {
+      url: rows[0].getResultByName("url"),
+      title: rows[0].getResultByName("title"),
+      frecency: rows[0].getResultByName("frecency"),
+    };
+    let unknownFields = rows[0].getResultByName("unknownSyncFields");
+    if (unknownFields) {
+      // This will be unfurled at the caller since the
+      // cleartext process will drop this
+      info.unknownFields = unknownFields;
+    }
+    return info;
+  },
+
+  /**
+   * Get all URLs filtered by the limit and since members of the options object.
+   *
+   * @param options
+   *        Options object with two members, since and limit. Both of them must be provided
+   * @returns {Array} - Up to limit number of URLs starting from the date provided by since
+   *
+   * Note that some visit types are explicitly excluded - downloads and framed
+   * links.
+   */
+  async getAllURLs(options) {
+    // Check that the limit property is finite number.
+    if (!Number.isFinite(options.limit)) {
+      throw new Error("The number provided in options.limit is not finite.");
+    }
+    // Check that the since property is of type Date.
+    if (
+      !options.since ||
+      Object.prototype.toString.call(options.since) != "[object Date]"
+    ) {
+      throw new Error(
+        "The property since of the options object must be of type Date."
+      );
+    }
+    let db = await lazy.PlacesUtils.promiseDBConnection();
+    let sinceInMicroseconds = lazy.PlacesUtils.toPRTime(options.since);
+    let rows = await db.executeCached(
+      `
+      SELECT DISTINCT p.url
+      FROM moz_places p
+      JOIN moz_historyvisits v ON p.id = v.place_id
+      WHERE p.last_visit_date > :cutoff_date AND
+            p.hidden = 0 AND
+            v.visit_type NOT IN (${lazy.IGNORED_TRANSITIONS_AS_SQL_LIST})
+      ORDER BY frecency DESC
+      LIMIT :max_results`,
+      { cutoff_date: sinceInMicroseconds, max_results: options.limit }
+    );
+    return rows.map(row => row.getResultByName("url"));
+  },
+  /**
+   * Insert or update the unknownFields that this client doesn't understand (yet)
+   * but stores & roundtrips them to prevent other clients from losing that data
+   *
+   * @param updates array of objects
+   *  an update object needs to have either a:
+   *  placeId: if we're putting unknownFields for a moz_places item
+   *  visitId: if we're putting unknownFields for a moz_historyvisits item
+   *  Note: Supplying none or both will result in that record being ignored
+   *  unknownFields: the stringified json to insert
+   */
+  async updateUnknownFieldsBatch(updates) {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "HistorySyncUtils: updateUnknownFieldsBatch",
+      async function (db) {
+        await db.executeTransaction(async () => {
+          for await (const update of updates) {
+            // Validate we only have one of these props
+            if (
+              (update.placeId && update.visitId) ||
+              (!update.placeId && !update.visitId)
+            ) {
+              continue;
+            }
+            let tableName = update.placeId
+              ? "moz_places_extra"
+              : "moz_historyvisits_extra";
+            let keyName = update.placeId ? "place_id" : "visit_id";
+            await db.executeCached(
+              `
+            INSERT INTO ${tableName} (${keyName}, sync_json)
+            VALUES (
+              :keyValue,
+              json_object('unknown_sync_fields', :unknownFields)
+            )
+            ON CONFLICT(${keyName}) DO UPDATE SET
+            sync_json=json_patch(${tableName}.sync_json, json_object('unknown_sync_fields',:unknownFields))
+            `,
+              {
+                keyValue: update.placeId ?? update.visitId,
+                unknownFields: update.unknownFields,
+              }
+            );
+          }
+        });
+      }
+    );
+  },
+  // End of history freeze
+}));
+
+const BookmarkSyncUtils = (PlacesSyncUtils.bookmarks = Object.freeze({
+  SYNC_ID_META_KEY: "sync/bookmarks/syncId",
+  LAST_SYNC_META_KEY: "sync/bookmarks/lastSync",
+  WIPE_REMOTE_META_KEY: "sync/bookmarks/wipeRemote",
+
+  // Jan 23, 1993 in milliseconds since 1970. Corresponds roughly to the release
+  // of the original NCSA Mosiac. We can safely assume that any dates before
+  // this time are invalid.
+  EARLIEST_BOOKMARK_TIMESTAMP: Date.UTC(1993, 0, 23),
+
+  KINDS: {
+    BOOKMARK: "bookmark",
+    QUERY: "query",
+    FOLDER: "folder",
+    LIVEMARK: "livemark",
+    SEPARATOR: "separator",
+  },
+
+  get ROOTS() {
+    return lazy.ROOTS;
+  },
+
+  /**
+   * Returns the current bookmarks sync ID, or `""` if one isn't set.
+   */
+  getSyncId() {
+    return lazy.PlacesUtils.metadata.get(
+      BookmarkSyncUtils.SYNC_ID_META_KEY,
+      ""
+    );
+  },
+
+  /**
+   * Indicates if the bookmarks engine should erase all bookmarks on the server
+   * and all other clients, because the user manually restored their bookmarks
+   * from a backup on this client.
+   */
+  async shouldWipeRemote() {
+    let shouldWipeRemote = await lazy.PlacesUtils.metadata.get(
+      BookmarkSyncUtils.WIPE_REMOTE_META_KEY,
+      false
+    );
+    return !!shouldWipeRemote;
+  },
+
+  /**
+   * Assigns a new sync ID, bumps the change counter, and flags all items as
+   * "NEW" for upload. This is called when we sync for the first time with a
+   * new account, when we're the first to sync after a node reassignment, and
+   * on the first sync after a manual restore.
+   *
+   * @return {Promise} resolved once the ID and all items have been updated.
+   * @resolves to the new sync ID.
+   */
+  resetSyncId() {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: resetSyncId",
+      function (db) {
+        let newSyncId = lazy.PlacesUtils.history.makeGuid();
+        return db.executeTransaction(async function () {
+          await setBookmarksSyncId(db, newSyncId);
+          await resetAllSyncStatuses(
+            db,
+            lazy.PlacesUtils.bookmarks.SYNC_STATUS.NEW
+          );
+          return newSyncId;
+        });
+      }
+    );
+  },
+
+  /**
+   * Ensures that the existing local sync ID, if any, is up-to-date with the
+   * server. This is called when we sync with an existing account.
+   *
+   * We always take the server's sync ID. If we don't have an existing ID,
+   * we're either syncing for the first time with an existing account, or Places
+   * has automatically restored from a backup. If the sync IDs don't match,
+   * we're likely syncing after a node reassignment, where another client
+   * uploaded their bookmarks first.
+   *
+   * @param newSyncId
+   *        The server's sync ID.
+   * @return {Promise} resolved once the ID and all items have been updated.
+   */
+  async ensureCurrentSyncId(newSyncId) {
+    if (!newSyncId || typeof newSyncId != "string") {
+      throw new TypeError("Invalid new bookmarks sync ID");
+    }
+    await lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: ensureCurrentSyncId",
+      async function (db) {
+        let existingSyncId = await lazy.PlacesUtils.metadata.getWithConnection(
+          db,
+          BookmarkSyncUtils.SYNC_ID_META_KEY,
+          ""
+        );
+
+        // If we don't have a sync ID, take the server's without resetting
+        // sync statuses.
+        if (!existingSyncId) {
+          lazy.BookmarkSyncLog.info("Taking new bookmarks sync ID", {
+            newSyncId,
+          });
+          await db.executeTransaction(() => setBookmarksSyncId(db, newSyncId));
+          return;
+        }
+
+        // If the existing sync ID matches the server, great!
+        if (existingSyncId == newSyncId) {
+          lazy.BookmarkSyncLog.trace("Bookmarks sync ID up-to-date", {
+            existingSyncId,
+          });
+          return;
+        }
+
+        // Otherwise, we have a sync ID, but it doesn't match, so we were likely
+        // node reassigned. Take the server's sync ID and reset all items to
+        // "UNKNOWN" so that we can merge.
+        lazy.BookmarkSyncLog.info(
+          "Bookmarks sync ID changed; resetting sync statuses",
+          { existingSyncId, newSyncId }
+        );
+        await db.executeTransaction(async function () {
+          await setBookmarksSyncId(db, newSyncId);
+          await resetAllSyncStatuses(
+            db,
+            lazy.PlacesUtils.bookmarks.SYNC_STATUS.UNKNOWN
+          );
+        });
+      }
+    );
+  },
+
+  /**
+   * Returns the last sync time, in seconds, for the bookmarks collection, or 0
+   * if bookmarks have never synced before.
+   */
+  async getLastSync() {
+    let lastSync = await lazy.PlacesUtils.metadata.get(
+      BookmarkSyncUtils.LAST_SYNC_META_KEY,
+      0
+    );
+    return lastSync / 1000;
+  },
+
+  /**
+   * Updates the bookmarks collection last sync time.
+   *
+   * @param lastSyncSeconds
+   *        The collection last sync time, in seconds, as a number or string.
+   */
+  async setLastSync(lastSyncSeconds) {
+    let lastSync = Math.floor(lastSyncSeconds * 1000);
+    if (!Number.isInteger(lastSync)) {
+      throw new TypeError("Invalid bookmarks last sync timestamp");
+    }
+    await lazy.PlacesUtils.metadata.set(
+      BookmarkSyncUtils.LAST_SYNC_META_KEY,
+      lastSync
+    );
+  },
+
+  /**
+   * Resets Sync metadata for bookmarks in Places. This function behaves
+   * differently depending on the change source, and may be called from
+   * `PlacesSyncUtils.bookmarks.reset` or
+   * `PlacesUtils.bookmarks.eraseEverything`.
+   *
+   * - RESTORE: The user is restoring from a backup. Drop the sync ID, last
+   *   sync time, and tombstones; reset sync statuses for remaining items to
+   *   "NEW"; then set a flag to wipe the server and all other clients. On the
+   *   next sync, we'll replace their bookmarks with ours.
+   *
+   * - RESTORE_ON_STARTUP: Places is automatically restoring from a backup to
+   *   recover from a corrupt database. The sync ID, last sync time, and
+   *   tombstones don't exist, since we don't back them up; reset sync statuses
+   *   for the roots to "UNKNOWN"; but don't wipe the server. On the next sync,
+   *   we'll merge the restored bookmarks with the ones on the server.
+   *
+   * - SYNC: Either another client told us to erase our bookmarks
+   *   (`PlacesSyncUtils.bookmarks.wipe`), or the user disconnected Sync
+   *   (`PlacesSyncUtils.bookmarks.reset`). In both cases, drop the existing
+   *   sync ID, last sync time, and tombstones; reset sync statuses for
+   *   remaining items to "NEW"; and don't wipe the server.
+   *
+   * @param db
+   *        the Sqlite.sys.mjs connection handle.
+   * @param source
+   *        the change source constant.
+   */
+  async resetSyncMetadata(db, source) {
+    if (
+      ![
+        lazy.PlacesUtils.bookmarks.SOURCES.RESTORE,
+        lazy.PlacesUtils.bookmarks.SOURCES.RESTORE_ON_STARTUP,
+        lazy.PlacesUtils.bookmarks.SOURCES.SYNC,
+      ].includes(source)
+    ) {
+      return;
+    }
+
+    // Remove the sync ID and last sync time in all cases.
+    await lazy.PlacesUtils.metadata.deleteWithConnection(
+      db,
+      BookmarkSyncUtils.SYNC_ID_META_KEY,
+      BookmarkSyncUtils.LAST_SYNC_META_KEY
+    );
+
+    // If we're manually restoring from a backup, wipe the server and other
+    // clients, so that we replace their bookmarks with the restored tree. If
+    // we're automatically restoring to recover from a corrupt database, don't
+    // wipe; we want to merge the restored tree with the one on the server.
+    await lazy.PlacesUtils.metadata.setWithConnection(
+      db,
+      new Map([
+        [
+          BookmarkSyncUtils.WIPE_REMOTE_META_KEY,
+          source == lazy.PlacesUtils.bookmarks.SOURCES.RESTORE,
+        ],
+      ])
+    );
+
+    // Reset change counters and sync statuses for roots and remaining
+    // items, and drop tombstones.
+    let syncStatus =
+      source == lazy.PlacesUtils.bookmarks.SOURCES.RESTORE_ON_STARTUP
+        ? lazy.PlacesUtils.bookmarks.SYNC_STATUS.UNKNOWN
+        : lazy.PlacesUtils.bookmarks.SYNC_STATUS.NEW;
+    await resetAllSyncStatuses(db, syncStatus);
+  },
+
+  /**
+   * Converts a Places GUID to a Sync record ID. Record IDs are identical to
+   * Places GUIDs for all items except roots.
+   */
+  guidToRecordId(guid) {
+    return lazy.ROOT_GUID_TO_RECORD_ID[guid] || guid;
+  },
+
+  /**
+   * Converts a Sync record ID to a Places GUID.
+   */
+  recordIdToGuid(recordId) {
+    return lazy.ROOT_RECORD_ID_TO_GUID[recordId] || recordId;
+  },
+
+  /**
+   * Fetches the record IDs for a folder's children, ordered by their position
+   * within the folder.
+   * Used only be tests - but that includes tps, so it lives here.
+   */
+  fetchChildRecordIds(parentRecordId) {
+    lazy.PlacesUtils.SYNC_BOOKMARK_VALIDATORS.recordId(parentRecordId);
+    let parentGuid = BookmarkSyncUtils.recordIdToGuid(parentRecordId);
+
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: fetchChildRecordIds",
+      async function (db) {
+        let childGuids = await fetchChildGuids(db, parentGuid);
+        return childGuids.map(guid => BookmarkSyncUtils.guidToRecordId(guid));
+      }
+    );
+  },
+
+  /**
+   * Migrates an array of `{ recordId, modified }` tuples from the old JSON-based
+   * tracker to the new sync change counter. `modified` is when the change was
+   * added to the old tracker, in milliseconds.
+   *
+   * Sync calls this method before the first bookmark sync after the Places
+   * schema migration.
+   */
+  migrateOldTrackerEntries(entries) {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: migrateOldTrackerEntries",
+      function (db) {
+        return db.executeTransaction(async function () {
+          // Mark all existing bookmarks as synced, and clear their change
+          // counters to avoid a full upload on the next sync. Note that
+          // this means we'll miss changes made between startup and the first
+          // post-migration sync, as well as changes made on a new release
+          // channel that weren't synced before the user downgraded. This is
+          // unfortunate, but no worse than the behavior of the old tracker.
+          //
+          // We also likely have bookmarks that don't exist on the server,
+          // because the old tracker missed them. We'll eventually fix the
+          // server once we decide on a repair strategy.
+          await db.executeCached(
+            `
+            WITH RECURSIVE
+            syncedItems(id) AS (
+              SELECT b.id FROM moz_bookmarks b
+              WHERE b.guid IN ('menu________', 'toolbar_____', 'unfiled_____',
+                               'mobile______')
+              UNION ALL
+              SELECT b.id FROM moz_bookmarks b
+              JOIN syncedItems s ON b.parent = s.id
+            )
+            UPDATE moz_bookmarks SET
+              syncStatus = :syncStatus,
+              syncChangeCounter = 0
+            WHERE id IN syncedItems`,
+            { syncStatus: lazy.PlacesUtils.bookmarks.SYNC_STATUS.NORMAL }
+          );
+
+          await db.executeCached(`DELETE FROM moz_bookmarks_deleted`);
+
+          await db.executeCached(`CREATE TEMP TABLE moz_bookmarks_tracked (
+            guid TEXT PRIMARY KEY,
+            time INTEGER
+          )`);
+
+          try {
+            for (let { recordId, modified } of entries) {
+              let guid = BookmarkSyncUtils.recordIdToGuid(recordId);
+              if (!lazy.PlacesUtils.isValidGuid(guid)) {
+                lazy.BookmarkSyncLog.warn(
+                  `migrateOldTrackerEntries: Ignoring ` +
+                    `change for invalid item ${guid}`
+                );
+                continue;
+              }
+              let time = lazy.PlacesUtils.toPRTime(
+                Number.isFinite(modified) ? modified : Date.now()
+              );
+              await db.executeCached(
+                `
+                INSERT OR IGNORE INTO moz_bookmarks_tracked (guid, time)
+                VALUES (:guid, :time)`,
+                { guid, time }
+              );
+            }
+
+            // Bump the change counter for existing tracked items.
+            await db.executeCached(`
+              INSERT OR REPLACE INTO moz_bookmarks (id, fk, type, parent,
+                                                    position, title,
+                                                    dateAdded, lastModified,
+                                                    guid, syncChangeCounter,
+                                                    syncStatus)
+              SELECT b.id, b.fk, b.type, b.parent, b.position, b.title,
+                     b.dateAdded, MAX(b.lastModified, t.time), b.guid,
+                     b.syncChangeCounter + 1, b.syncStatus
+              FROM moz_bookmarks b
+              JOIN moz_bookmarks_tracked t ON b.guid = t.guid`);
+
+            // Insert tombstones for nonexistent tracked items, using the most
+            // recent deletion date for more accurate reconciliation. We assume
+            // the tracked item belongs to a synced root.
+            await db.executeCached(`
+              INSERT OR REPLACE INTO moz_bookmarks_deleted (guid, dateRemoved)
+              SELECT t.guid, MAX(IFNULL((SELECT dateRemoved FROM moz_bookmarks_deleted
+                                         WHERE guid = t.guid), 0), t.time)
+              FROM moz_bookmarks_tracked t
+              LEFT JOIN moz_bookmarks b ON t.guid = b.guid
+              WHERE b.guid IS NULL`);
+          } finally {
+            await db.executeCached(`DROP TABLE moz_bookmarks_tracked`);
+          }
+        });
+      }
+    );
+  },
+
+  /**
+   * Reorders a folder's children, based on their order in the array of sync
+   * IDs.
+   *
+   * Sync uses this method to reorder all synced children after applying all
+   * incoming records.
+   *
+   * @return {Promise} resolved when reordering is complete.
+   * @rejects if an error happens while reordering.
+   * @throws if the arguments are invalid.
+   */
+  order(parentRecordId, childRecordIds) {
+    lazy.PlacesUtils.SYNC_BOOKMARK_VALIDATORS.recordId(parentRecordId);
+    if (!childRecordIds.length) {
+      return undefined;
+    }
+    let parentGuid = BookmarkSyncUtils.recordIdToGuid(parentRecordId);
+    if (parentGuid == lazy.PlacesUtils.bookmarks.rootGuid) {
+      // Reordering roots doesn't make sense, but Sync will do this on the
+      // first sync.
+      return undefined;
+    }
+    let orderedChildrenGuids = childRecordIds.map(
+      BookmarkSyncUtils.recordIdToGuid
+    );
+    return lazy.PlacesUtils.bookmarks.reorder(
+      parentGuid,
+      orderedChildrenGuids,
+      {
+        source: SOURCE_SYNC,
+      }
+    );
+  },
+
+  /**
+   * Resolves to true if there are known sync changes.
+   */
+  havePendingChanges() {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: havePendingChanges",
+      async function (db) {
+        let rows = await db.executeCached(`
+          WITH RECURSIVE
+          syncedItems(id, guid, syncChangeCounter) AS (
+            SELECT b.id, b.guid, b.syncChangeCounter
+             FROM moz_bookmarks b
+             WHERE b.guid IN ('menu________', 'toolbar_____', 'unfiled_____',
+                              'mobile______')
+            UNION ALL
+            SELECT b.id, b.guid, b.syncChangeCounter
+            FROM moz_bookmarks b
+            JOIN syncedItems s ON b.parent = s.id
+          ),
+          changedItems(guid) AS (
+            SELECT guid FROM syncedItems
+            WHERE syncChangeCounter >= 1
+            UNION ALL
+            SELECT guid FROM moz_bookmarks_deleted
+          )
+          SELECT EXISTS(SELECT guid FROM changedItems) AS haveChanges`);
+        return !!rows[0].getResultByName("haveChanges");
+      }
+    );
+  },
+
+  /**
+   * Returns a changeset containing local bookmark changes since the last sync.
+   *
+   * @return {Promise} resolved once all items have been fetched.
+   * @resolves to an object containing records for changed bookmarks, keyed by
+   *           the record ID.
+   * @see pullSyncChanges for the implementation, and markChangesAsSyncing for
+   *      an explanation of why we update the sync status.
+   */
+  pullChanges() {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: pullChanges",
+      pullSyncChanges
+    );
+  },
+
+  /**
+   * Updates the sync status of all "NEW" bookmarks to "NORMAL", so that Sync
+   * can recover correctly after an interrupted sync.
+   *
+   * @param changeRecords
+   *        A changeset containing sync change records, as returned by
+   *        `pullChanges`.
+   * @return {Promise} resolved once all records have been updated.
+   */
+  markChangesAsSyncing(changeRecords) {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: markChangesAsSyncing",
+      db => markChangesAsSyncing(db, changeRecords)
+    );
+  },
+
+  /**
+   * Decrements the sync change counter, updates the sync status, and cleans up
+   * tombstones for successfully synced items. Sync calls this method at the
+   * end of each bookmark sync.
+   *
+   * @param changeRecords
+   *        A changeset containing sync change records, as returned by
+   *        `pullChanges`.
+   * @return {Promise} resolved once all records have been updated.
+   */
+  pushChanges(changeRecords) {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: pushChanges",
+      async function (db) {
+        let skippedCount = 0;
+        let weakCount = 0;
+        let updateParams = [];
+        let tombstoneGuidsToRemove = [];
+
+        for (let recordId in changeRecords) {
+          // Validate change records to catch coding errors.
+          let changeRecord = validateChangeRecord(
+            "BookmarkSyncUtils: pushChanges",
+            changeRecords[recordId],
+            {
+              tombstone: { required: true },
+              counter: { required: true },
+              synced: { required: true },
+            }
+          );
+
+          // Skip weakly uploaded records.
+          if (!changeRecord.counter) {
+            weakCount++;
+            continue;
+          }
+
+          // Sync sets the `synced` flag for reconciled or successfully
+          // uploaded items. If upload failed, ignore the change; we'll
+          // try again on the next sync.
+          if (!changeRecord.synced) {
+            skippedCount++;
+            continue;
+          }
+
+          let guid = BookmarkSyncUtils.recordIdToGuid(recordId);
+          if (changeRecord.tombstone) {
+            tombstoneGuidsToRemove.push(guid);
+          } else {
+            updateParams.push({
+              guid,
+              syncChangeDelta: changeRecord.counter,
+              syncStatus: lazy.PlacesUtils.bookmarks.SYNC_STATUS.NORMAL,
+            });
+          }
+        }
+
+        // Reduce the change counter and update the sync status for
+        // reconciled and uploaded items. If the bookmark was updated
+        // during the sync, its change counter will still be > 0 for the
+        // next sync.
+        if (updateParams.length || tombstoneGuidsToRemove.length) {
+          await db.executeTransaction(async function () {
+            if (updateParams.length) {
+              await db.executeCached(
+                `
+                UPDATE moz_bookmarks
+                SET syncChangeCounter = MAX(syncChangeCounter - :syncChangeDelta, 0),
+                    syncStatus = :syncStatus
+                WHERE guid = :guid`,
+                updateParams
+              );
+              // and if there are *both* bookmarks and tombstones for these
+              // items, we nuke the tombstones.
+              // This should be unlikely, but bad if it happens.
+              let dupedGuids = updateParams.map(({ guid }) => guid);
+              await removeUndeletedTombstones(db, dupedGuids);
+            }
+            await removeTombstones(db, tombstoneGuidsToRemove);
+          });
+        }
+
+        lazy.BookmarkSyncLog.debug(`pushChanges: Processed change records`, {
+          weak: weakCount,
+          skipped: skippedCount,
+          updated: updateParams.length,
+        });
+      }
+    );
+  },
+
+  /**
+   * Removes items from the database. Sync buffers incoming tombstones, and
+   * calls this method to apply them at the end of each sync. Deletion
+   * happens in three steps:
+   *
+   *  1. Remove all non-folder items. Deleting a folder on a remote client
+   *     uploads tombstones for the folder and its children at the time of
+   *     deletion. This preserves any new children we've added locally since
+   *     the last sync.
+   *  2. Reparent remaining children to the tombstoned folder's parent. This
+   *     bumps the change counter for the children and their new parent.
+   *  3. Remove the tombstoned folder. Because we don't do this in a
+   *     transaction, the user might move new items into the folder before we
+   *     can remove it. In that case, we keep the folder and upload the new
+   *     subtree to the server.
+   *
+   * See the comment above `BookmarksStore::deletePending` for the details on
+   * why delete works the way it does.
+   */
+  remove(recordIds) {
+    if (!recordIds.length) {
+      return null;
+    }
+
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: remove",
+      async function (db) {
+        let folderGuids = [];
+        for (let recordId of recordIds) {
+          if (recordId in lazy.ROOT_RECORD_ID_TO_GUID) {
+            lazy.BookmarkSyncLog.warn(
+              `remove: Refusing to remove root ${recordId}`
+            );
+            continue;
+          }
+          let guid = BookmarkSyncUtils.recordIdToGuid(recordId);
+          let bookmarkItem = await lazy.PlacesUtils.bookmarks.fetch(guid);
+          if (!bookmarkItem) {
+            lazy.BookmarkSyncLog.trace(`remove: Item ${guid} already removed`);
+            continue;
+          }
+          let kind = await getKindForItem(db, bookmarkItem);
+          if (kind == BookmarkSyncUtils.KINDS.FOLDER) {
+            folderGuids.push(bookmarkItem.guid);
+            continue;
+          }
+          let wasRemoved = await deleteSyncedAtom(bookmarkItem);
+          if (wasRemoved) {
+            lazy.BookmarkSyncLog.trace(
+              `remove: Removed item ${guid} with kind ${kind}`
+            );
+          }
+        }
+
+        for (let guid of folderGuids) {
+          let bookmarkItem = await lazy.PlacesUtils.bookmarks.fetch(guid);
+          if (!bookmarkItem) {
+            lazy.BookmarkSyncLog.trace(
+              `remove: Folder ${guid} already removed`
+            );
+            continue;
+          }
+          let wasRemoved = await deleteSyncedFolder(db, bookmarkItem);
+          if (wasRemoved) {
+            lazy.BookmarkSyncLog.trace(
+              `remove: Removed folder ${bookmarkItem.guid}`
+            );
+          }
+        }
+
+        // TODO (Bug 1313890): Refactor the bookmarks engine to pull change records
+        // before uploading, instead of returning records to merge into the engine's
+        // initial changeset.
+        return pullSyncChanges(db);
+      }
+    );
+  },
+
+  /**
+   * Removes all bookmarks and tombstones from the database. Sync calls this
+   * method when it receives a command from a remote client to wipe all stored
+   * data.
+   *
+   * @return {Promise} resolved once all items have been removed.
+   */
+  wipe() {
+    return lazy.PlacesUtils.bookmarks.eraseEverything({
+      source: SOURCE_SYNC,
+    });
+  },
+
+  /**
+   * Marks all bookmarks as "NEW" and removes all tombstones. Unlike `wipe`,
+   * this keeps all existing bookmarks, and only clears their sync change
+   * tracking info.
+   *
+   * @return {Promise} resolved once all items have been updated.
+   */
+  reset() {
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: reset",
+      function (db) {
+        return db.executeTransaction(async function () {
+          await BookmarkSyncUtils.resetSyncMetadata(db, SOURCE_SYNC);
+        });
+      }
+    );
+  },
+
+  /**
+   * Fetches a Sync bookmark object for an item in the tree.
+   *
+   * Should only be used by SYNC TESTS.
+   * We should remove this in bug XXXXXX, updating the tests to use
+   * PlacesUtils.bookmarks.fetch.
+   *
+   * The object contains
+   * the following properties, depending on the item's kind:
+   *
+   *  - kind (all): A string representing the item's kind.
+   *  - recordId (all): The item's record ID.
+   *  - parentRecordId (all): The record ID of the item's parent.
+   *  - parentTitle (all): The title of the item's parent, used for de-duping.
+   *    Omitted for the Places root and parents with empty titles.
+   *  - dateAdded (all): Timestamp in milliseconds, when the bookmark was added
+   *    or created on a remote device if known.
+   *  - title ("bookmark", "folder", "query"): The item's title.
+   *    Omitted if empty.
+   *  - url ("bookmark", "query"): The item's URL.
+   *  - tags ("bookmark", "query"): An array containing the item's tags.
+   *  - keyword ("bookmark"): The bookmark's keyword, if one exists.
+   *  - childRecordIds ("folder"): An array containing the record IDs of the item's
+   *    children, used to determine child order.
+   *  - folder ("query"): The tag folder name, if this is a tag query.
+   *  - index ("separator"): The separator's position within its parent.
+   */
+  async fetch(recordId) {
+    let guid = BookmarkSyncUtils.recordIdToGuid(recordId);
+    let bookmarkItem = await lazy.PlacesUtils.bookmarks.fetch(guid);
+    if (!bookmarkItem) {
+      return null;
+    }
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkSyncUtils: fetch",
+      async function (db) {
+        // Convert the Places bookmark object to a Sync bookmark and add
+        // kind-specific properties. Titles are required for bookmarks,
+        // and folders; optional for queries, and omitted for separators.
+        let kind = await getKindForItem(db, bookmarkItem);
+        let item;
+        switch (kind) {
+          case BookmarkSyncUtils.KINDS.BOOKMARK:
+            item = await fetchBookmarkItem(db, bookmarkItem);
+            break;
+
+          case BookmarkSyncUtils.KINDS.QUERY:
+            item = await fetchQueryItem(db, bookmarkItem);
+            break;
+
+          case BookmarkSyncUtils.KINDS.FOLDER:
+            item = await fetchFolderItem(db, bookmarkItem);
+            break;
+
+          case BookmarkSyncUtils.KINDS.SEPARATOR:
+            item = await placesBookmarkToSyncBookmark(db, bookmarkItem);
+            item.index = bookmarkItem.index;
+            break;
+
+          default:
+            throw new Error(`Unknown bookmark kind: ${kind}`);
+        }
+
+        // Sync uses the parent title for de-duping. All Sync bookmark objects
+        // except the Places root should have this property.
+        if (bookmarkItem.parentGuid) {
+          let parent = await lazy.PlacesUtils.bookmarks.fetch(
+            bookmarkItem.parentGuid
+          );
+          item.parentTitle = parent.title || "";
+        }
+
+        return item;
+      }
+    );
+  },
+
+  /**
+   * Returns the sync change counter increment for a change source constant.
+   */
+  determineSyncChangeDelta(source) {
+    // Don't bump the change counter when applying changes made by Sync, to
+    // avoid sync loops.
+    return source == lazy.PlacesUtils.bookmarks.SOURCES.SYNC ? 0 : 1;
+  },
+
+  /**
+   * Returns the sync status for a new item inserted by a change source.
+   */
+  determineInitialSyncStatus(source) {
+    if (source == lazy.PlacesUtils.bookmarks.SOURCES.SYNC) {
+      // Incoming bookmarks are "NORMAL", since they already exist on the server.
+      return lazy.PlacesUtils.bookmarks.SYNC_STATUS.NORMAL;
+    }
+    if (source == lazy.PlacesUtils.bookmarks.SOURCES.RESTORE_ON_STARTUP) {
+      // If the user restores from a backup, or Places automatically recovers
+      // from a corrupt database, all prior sync tracking is lost. Setting the
+      // status to "UNKNOWN" allows Sync to reconcile restored bookmarks with
+      // those on the server.
+      return lazy.PlacesUtils.bookmarks.SYNC_STATUS.UNKNOWN;
+    }
+    // For all other sources, mark items as "NEW". We'll update their statuses
+    // to "NORMAL" after the first sync.
+    return lazy.PlacesUtils.bookmarks.SYNC_STATUS.NEW;
+  },
+
+  /**
+   * An internal helper that bumps the change counter for all bookmarks with
+   * a given URL. This is used to update bookmarks when adding or changing a
+   * tag or keyword entry.
+   *
+   * @param db
+   *        the Sqlite.sys.mjs connection handle.
+   * @param url
+   *        the bookmark URL object.
+   * @param syncChangeDelta
+   *        the sync change counter increment.
+   * @return {Promise} resolved when the counters have been updated.
+   */
+  addSyncChangesForBookmarksWithURL(db, url, syncChangeDelta) {
+    if (!url || !syncChangeDelta) {
+      return Promise.resolve();
+    }
+    return db.executeCached(
+      `
+      UPDATE moz_bookmarks
+        SET syncChangeCounter = syncChangeCounter + :syncChangeDelta
+      WHERE type = :type AND
+            fk = (SELECT id FROM moz_places WHERE url_hash = hash(:url) AND
+                  url = :url)`,
+      {
+        syncChangeDelta,
+        type: lazy.PlacesUtils.bookmarks.TYPE_BOOKMARK,
+        url: url.href,
+      }
+    );
+  },
+
+  /**
+   * Returns `0` if no sensible timestamp could be found.
+   * Otherwise, returns the earliest sensible timestamp between `existingMillis`
+   * and `serverMillis`.
+   */
+  ratchetTimestampBackwards(
+    existingMillis,
+    serverMillis,
+    lowerBound = BookmarkSyncUtils.EARLIEST_BOOKMARK_TIMESTAMP
+  ) {
+    const possible = [+existingMillis, +serverMillis].filter(
+      n => !isNaN(n) && n > lowerBound
+    );
+    if (!possible.length) {
+      return 0;
+    }
+    return Math.min(...possible);
+  },
+
+  /**
+   * Rebuilds the left pane query for the mobile root under "All Bookmarks" if
+   * necessary. Sync calls this method at the end of each bookmark sync. This
+   * code should eventually move to `PlacesUIUtils#maybeRebuildLeftPane`; see
+   * bug 647605.
+   *
+   * - If there are no mobile bookmarks, the query will not be created, or
+   *   will be removed if it already exists.
+   * - If there are mobile bookmarks, the query will be created if it doesn't
+   *   exist, or will be updated with the correct title and URL otherwise.
+   */
+  async ensureMobileQuery() {
+    let db = await lazy.PlacesUtils.promiseDBConnection();
+
+    let mobileChildGuids = await fetchChildGuids(
+      db,
+      lazy.PlacesUtils.bookmarks.mobileGuid
+    );
+    let hasMobileBookmarks = !!mobileChildGuids.length;
+
+    Services.prefs.setBoolPref(MOBILE_BOOKMARKS_PREF, hasMobileBookmarks);
+  },
+}));
+
+PlacesSyncUtils.test = {};
+PlacesSyncUtils.test.bookmarks = Object.freeze({
+  /**
+   * Inserts a synced bookmark into the tree. Only SYNC TESTS should call this
+   * method; other callers should use `PlacesUtils.bookmarks.insert`.
+   *
+   * It is in this file rather than a test-only file because it makes use of
+   * other internal functions here, so moving is not trivial - see bug 1662602.
+   *
+   * The following properties are supported:
+   *  - kind: Required.
+   *  - guid: Required.
+   *  - parentGuid: Required.
+   *  - url: Required for bookmarks.
+   *  - tags: An optional array of tag strings.
+   *  - keyword: An optional keyword string.
+   *
+   * Sync doesn't set the index, since it appends and reorders children
+   * after applying all incoming items.
+   *
+   * @param info
+   *        object representing a synced bookmark.
+   *
+   * @return {Promise} resolved when the creation is complete.
+   * @resolves to an object representing the created bookmark.
+   * @rejects if it's not possible to create the requested bookmark.
+   * @throws if the arguments are invalid.
+   */
+  insert(info) {
+    let insertInfo = validateNewBookmark("BookmarkTestUtils: insert", info);
+
+    return lazy.PlacesUtils.withConnectionWrapper(
+      "BookmarkTestUtils: insert",
+      async db => {
+        // If we're inserting a tag query, make sure the tag exists and fix the
+        // folder ID to refer to the local tag folder.
+        insertInfo = await updateTagQueryFolder(db, insertInfo);
+
+        let bookmarkInfo = syncBookmarkToPlacesBookmark(insertInfo);
+        let bookmarkItem = await lazy.PlacesUtils.bookmarks.insert(
+          bookmarkInfo
+        );
+        let newItem = await insertBookmarkMetadata(
+          db,
+          bookmarkItem,
+          insertInfo
+        );
+
+        return newItem;
+      }
+    );
+  },
+});
+
+ChromeUtils.defineLazyGetter(lazy, "HistorySyncLog", () => {
+  return lazy.Log.repository.getLogger("Sync.Engine.History.HistorySyncUtils");
+});
+
+ChromeUtils.defineLazyGetter(lazy, "BookmarkSyncLog", () => {
+  // Use a sub-log of the bookmarks engine, so setting the level for that
+  // engine also adjust the level of this log.
+  return lazy.Log.repository.getLogger(
+    "Sync.Engine.Bookmarks.BookmarkSyncUtils"
+  );
+});
+
+function validateSyncBookmarkObject(name, input, behavior) {
+  return lazy.PlacesUtils.validateItemProperties(
+    name,
+    lazy.PlacesUtils.SYNC_BOOKMARK_VALIDATORS,
+    input,
+    behavior
+  );
+}
+
+// Validates a sync change record as returned by `pullChanges` and passed to
+// `pushChanges`.
+function validateChangeRecord(name, changeRecord, behavior) {
+  return lazy.PlacesUtils.validateItemProperties(
+    name,
+    lazy.PlacesUtils.SYNC_CHANGE_RECORD_VALIDATORS,
+    changeRecord,
+    behavior
+  );
+}
+
+// Similar to the private `fetchBookmarksByParent` implementation in
+// `Bookmarks.jsm`.
+var fetchChildGuids = async function (db, parentGuid) {
+  let rows = await db.executeCached(
+    `
+    SELECT guid
+    FROM moz_bookmarks
+    WHERE parent = (
+      SELECT id FROM moz_bookmarks WHERE guid = :parentGuid
+    )
+    ORDER BY position`,
+    { parentGuid }
+  );
+  return rows.map(row => row.getResultByName("guid"));
+};
+
+// Legacy tag queries may use a `place:` URL that refers to the tag folder ID.
+// When we apply a synced tag query from a remote client, we need to update the
+// URL to point to the local tag.
+function updateTagQueryFolder(db, info) {
+  if (
+    info.kind != BookmarkSyncUtils.KINDS.QUERY ||
+    !info.folder ||
+    !info.url ||
+    info.url.protocol != "place:"
+  ) {
+    return info;
+  }
+
+  let params = new URLSearchParams(info.url.pathname);
+  let type = +params.get("type");
+  if (type != Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAG_CONTENTS) {
+    return info;
+  }
+
+  lazy.BookmarkSyncLog.debug(
+    `updateTagQueryFolder: Tag query folder: ${info.folder}`
+  );
+
+  // Rewrite the query to directly reference the tag.
+  params.delete("queryType");
+  params.delete("type");
+  params.delete("folder");
+  params.set("tag", info.folder);
+  info.url = new URL(info.url.protocol + params);
+  return info;
+}
+
+// Keywords are a 1 to 1 mapping between strings and pairs of (URL, postData).
+// (the postData is not synced, so we ignore it). Sync associates keywords with
+// bookmarks, which is not really accurate. -- We might already have a keyword
+// with that name, or we might already have another bookmark with that URL with
+// a different keyword, etc.
+//
+// If we don't handle those cases by removing the conflicting keywords first,
+// the insertion  will fail, and the keywords will either be wrong, or missing.
+// This function handles those cases.
+function removeConflictingKeywords(bookmarkURL, newKeyword) {
+  return lazy.PlacesUtils.withConnectionWrapper(
+    "BookmarkSyncUtils: removeConflictingKeywords",
+    async function (db) {
+      let entryForURL = await lazy.PlacesUtils.keywords.fetch({
+        url: bookmarkURL.href,
+      });
+      if (entryForURL && entryForURL.keyword !== newKeyword) {
+        await lazy.PlacesUtils.keywords.remove({
+          keyword: entryForURL.keyword,
+          source: SOURCE_SYNC,
+        });
+        // This will cause us to reupload this record for this sync, but
+        // without it, we will risk data corruption.
+        await BookmarkSyncUtils.addSyncChangesForBookmarksWithURL(
+          db,
+          entryForURL.url,
+          1
+        );
+      }
+      if (!newKeyword) {
+        return;
+      }
+      let entryForNewKeyword = await lazy.PlacesUtils.keywords.fetch({
+        keyword: newKeyword,
+      });
+      if (entryForNewKeyword) {
+        await lazy.PlacesUtils.keywords.remove({
+          keyword: entryForNewKeyword.keyword,
+          source: SOURCE_SYNC,
+        });
+        await BookmarkSyncUtils.addSyncChangesForBookmarksWithURL(
+          db,
+          entryForNewKeyword.url,
+          1
+        );
+      }
+    }
+  );
+}
+
+// Sets annotations, keywords, and tags on a new bookmark. Returns a Sync
+// bookmark object.
+async function insertBookmarkMetadata(db, bookmarkItem, insertInfo) {
+  let newItem = await placesBookmarkToSyncBookmark(db, bookmarkItem);
+
+  try {
+    newItem.tags = tagItem(bookmarkItem, insertInfo.tags);
+  } catch (ex) {
+    lazy.BookmarkSyncLog.warn(
+      `insertBookmarkMetadata: Error tagging item ${insertInfo.recordId}`,
+      ex
+    );
+  }
+
+  if (insertInfo.keyword) {
+    await removeConflictingKeywords(bookmarkItem.url, insertInfo.keyword);
+    await lazy.PlacesUtils.keywords.insert({
+      keyword: insertInfo.keyword,
+      url: bookmarkItem.url.href,
+      source: SOURCE_SYNC,
+    });
+    newItem.keyword = insertInfo.keyword;
+  }
+
+  return newItem;
+}
+
+// Determines the Sync record kind for an existing bookmark.
+async function getKindForItem(db, item) {
+  switch (item.type) {
+    case lazy.PlacesUtils.bookmarks.TYPE_FOLDER: {
+      return BookmarkSyncUtils.KINDS.FOLDER;
+    }
+    case lazy.PlacesUtils.bookmarks.TYPE_BOOKMARK:
+      return item.url.protocol == "place:"
+        ? BookmarkSyncUtils.KINDS.QUERY
+        : BookmarkSyncUtils.KINDS.BOOKMARK;
+
+    case lazy.PlacesUtils.bookmarks.TYPE_SEPARATOR:
+      return BookmarkSyncUtils.KINDS.SEPARATOR;
+  }
+  return null;
+}
+
+// Returns the `nsINavBookmarksService` bookmark type constant for a Sync
+// record kind.
+function getTypeForKind(kind) {
+  switch (kind) {
+    case BookmarkSyncUtils.KINDS.BOOKMARK:
+    case BookmarkSyncUtils.KINDS.QUERY:
+      return lazy.PlacesUtils.bookmarks.TYPE_BOOKMARK;
+
+    case BookmarkSyncUtils.KINDS.FOLDER:
+      return lazy.PlacesUtils.bookmarks.TYPE_FOLDER;
+
+    case BookmarkSyncUtils.KINDS.SEPARATOR:
+      return lazy.PlacesUtils.bookmarks.TYPE_SEPARATOR;
+  }
+  throw new Error(`Unknown bookmark kind: ${kind}`);
+}
+
+function validateNewBookmark(name, info) {
+  let insertInfo = validateSyncBookmarkObject(name, info, {
+    kind: { required: true },
+    recordId: { required: true },
+    url: {
+      requiredIf: b =>
+        [
+          BookmarkSyncUtils.KINDS.BOOKMARK,
+          BookmarkSyncUtils.KINDS.QUERY,
+        ].includes(b.kind),
+      validIf: b =>
+        [
+          BookmarkSyncUtils.KINDS.BOOKMARK,
+          BookmarkSyncUtils.KINDS.QUERY,
+        ].includes(b.kind),
+    },
+    parentRecordId: { required: true },
+    title: {
+      validIf: b =>
+        [
+          BookmarkSyncUtils.KINDS.BOOKMARK,
+          BookmarkSyncUtils.KINDS.QUERY,
+          BookmarkSyncUtils.KINDS.FOLDER,
+        ].includes(b.kind) || b.title === "",
+    },
+    query: { validIf: b => b.kind == BookmarkSyncUtils.KINDS.QUERY },
+    folder: { validIf: b => b.kind == BookmarkSyncUtils.KINDS.QUERY },
+    tags: {
+      validIf: b =>
+        [
+          BookmarkSyncUtils.KINDS.BOOKMARK,
+          BookmarkSyncUtils.KINDS.QUERY,
+        ].includes(b.kind),
+    },
+    keyword: {
+      validIf: b =>
+        [
+          BookmarkSyncUtils.KINDS.BOOKMARK,
+          BookmarkSyncUtils.KINDS.QUERY,
+        ].includes(b.kind),
+    },
+    dateAdded: { required: false },
+  });
+
+  return insertInfo;
+}
+
+function tagItem(item, tags) {
+  if (!item.url) {
+    return [];
+  }
+
+  // Remove leading and trailing whitespace, then filter out empty tags.
+  let newTags = tags ? tags.map(tag => tag.trim()).filter(Boolean) : [];
+
+  // Removing the last tagged item will also remove the tag. To preserve
+  // tag IDs, we temporarily tag a dummy URI, ensuring the tags exist.
+  let dummyURI = lazy.PlacesUtils.toURI("about:weave#BStore_tagURI");
+  let bookmarkURI = lazy.PlacesUtils.toURI(item.url);
+  if (newTags && newTags.length) {
+    lazy.PlacesUtils.tagging.tagURI(dummyURI, newTags, SOURCE_SYNC);
+  }
+  lazy.PlacesUtils.tagging.untagURI(bookmarkURI, null, SOURCE_SYNC);
+  if (newTags && newTags.length) {
+    lazy.PlacesUtils.tagging.tagURI(bookmarkURI, newTags, SOURCE_SYNC);
+  }
+  lazy.PlacesUtils.tagging.untagURI(dummyURI, null, SOURCE_SYNC);
+
+  return newTags;
+}
+
+// Converts a Places bookmark to a Sync bookmark. This function maps Places
+// GUIDs to record IDs and filters out extra Places properties like date added,
+// last modified, and index.
+async function placesBookmarkToSyncBookmark(db, bookmarkItem) {
+  let item = {};
+
+  for (let prop in bookmarkItem) {
+    switch (prop) {
+      // Record IDs are identical to Places GUIDs for all items except roots.
+      case "guid":
+        item.recordId = BookmarkSyncUtils.guidToRecordId(bookmarkItem.guid);
+        break;
+
+      case "parentGuid":
+        item.parentRecordId = BookmarkSyncUtils.guidToRecordId(
+          bookmarkItem.parentGuid
+        );
+        break;
+
+      // Sync uses kinds instead of types, which distinguish between folders,
+      // livemarks, bookmarks, and queries.
+      case "type":
+        item.kind = await getKindForItem(db, bookmarkItem);
+        break;
+
+      case "title":
+      case "url":
+        item[prop] = bookmarkItem[prop];
+        break;
+
+      case "dateAdded":
+        item[prop] = new Date(bookmarkItem[prop]).getTime();
+        break;
+    }
+  }
+
+  return item;
+}
+
+// Converts a Sync bookmark object to a Places bookmark or livemark object.
+// This function maps record IDs to Places GUIDs, and filters out extra Sync
+// properties like keywords, tags. Returns an object that can be passed to
+// `PlacesUtils.bookmarks.{insert, update}`.
+function syncBookmarkToPlacesBookmark(info) {
+  let bookmarkInfo = {
+    source: SOURCE_SYNC,
+  };
+
+  for (let prop in info) {
+    switch (prop) {
+      case "kind":
+        bookmarkInfo.type = getTypeForKind(info.kind);
+        break;
+
+      // Convert record IDs to Places GUIDs for roots.
+      case "recordId":
+        bookmarkInfo.guid = BookmarkSyncUtils.recordIdToGuid(info.recordId);
+        break;
+
+      case "dateAdded":
+        bookmarkInfo.dateAdded = new Date(info.dateAdded);
+        break;
+
+      case "parentRecordId":
+        bookmarkInfo.parentGuid = BookmarkSyncUtils.recordIdToGuid(
+          info.parentRecordId
+        );
+        // Instead of providing an index, Sync reorders children at the end of
+        // the sync using `BookmarkSyncUtils.order`. We explicitly specify the
+        // default index here to prevent `PlacesUtils.bookmarks.update` from
+        // throwing.
+        bookmarkInfo.index = lazy.PlacesUtils.bookmarks.DEFAULT_INDEX;
+        break;
+
+      case "title":
+      case "url":
+        bookmarkInfo[prop] = info[prop];
+        break;
+    }
+  }
+
+  return bookmarkInfo;
+}
+
+// Creates and returns a Sync bookmark object containing the bookmark's
+// tags, keyword.
+var fetchBookmarkItem = async function (db, bookmarkItem) {
+  let item = await placesBookmarkToSyncBookmark(db, bookmarkItem);
+
+  if (!item.title) {
+    item.title = "";
+  }
+
+  item.tags = lazy.PlacesUtils.tagging.getTagsForURI(
+    lazy.PlacesUtils.toURI(bookmarkItem.url)
+  );
+
+  let keywordEntry = await lazy.PlacesUtils.keywords.fetch({
+    url: bookmarkItem.url,
+  });
+  if (keywordEntry) {
+    item.keyword = keywordEntry.keyword;
+  }
+
+  return item;
+};
+
+// Creates and returns a Sync bookmark object containing the folder's children.
+async function fetchFolderItem(db, bookmarkItem) {
+  let item = await placesBookmarkToSyncBookmark(db, bookmarkItem);
+
+  if (!item.title) {
+    item.title = "";
+  }
+
+  let childGuids = await fetchChildGuids(db, bookmarkItem.guid);
+  item.childRecordIds = childGuids.map(guid =>
+    BookmarkSyncUtils.guidToRecordId(guid)
+  );
+
+  return item;
+}
+
+// Creates and returns a Sync bookmark object containing the query's tag
+// folder name.
+async function fetchQueryItem(db, bookmarkItem) {
+  let item = await placesBookmarkToSyncBookmark(db, bookmarkItem);
+
+  let params = new URLSearchParams(bookmarkItem.url.pathname);
+  let tags = params.getAll("tag");
+  if (tags.length == 1) {
+    item.folder = tags[0];
+  }
+
+  return item;
+}
+
+function addRowToChangeRecords(row, changeRecords) {
+  let guid = row.getResultByName("guid");
+  if (!guid) {
+    throw new Error(`Changed item missing GUID`);
+  }
+  let isTombstone = !!row.getResultByName("tombstone");
+  let recordId = BookmarkSyncUtils.guidToRecordId(guid);
+  if (recordId in changeRecords) {
+    let existingRecord = changeRecords[recordId];
+    if (existingRecord.tombstone == isTombstone) {
+      // Should never happen: `moz_bookmarks.guid` has a unique index, and
+      // `moz_bookmarks_deleted.guid` is the primary key.
+      throw new Error(`Duplicate item or tombstone ${recordId} in changeset`);
+    }
+    if (!existingRecord.tombstone && isTombstone) {
+      // Don't replace undeleted items with tombstones...
+      lazy.BookmarkSyncLog.warn(
+        "addRowToChangeRecords: Ignoring tombstone for undeleted item",
+        recordId
+      );
+      return;
+    }
+    // ...But replace undeleted tombstones with items.
+    lazy.BookmarkSyncLog.warn(
+      "addRowToChangeRecords: Replacing tombstone for undeleted item",
+      recordId
+    );
+  }
+  let modifiedAsPRTime = row.getResultByName("modified");
+  let modified = modifiedAsPRTime / MICROSECONDS_PER_SECOND;
+  if (Number.isNaN(modified) || modified <= 0) {
+    lazy.BookmarkSyncLog.error(
+      "addRowToChangeRecords: Invalid modified date for " + recordId,
+      modifiedAsPRTime
+    );
+    modified = 0;
+  }
+  changeRecords[recordId] = {
+    modified,
+    counter: row.getResultByName("syncChangeCounter"),
+    status: row.getResultByName("syncStatus"),
+    tombstone: isTombstone,
+    synced: false,
+  };
+}
+
+/**
+ * Queries the database for synced bookmarks and tombstones, and returns a
+ * changeset for the Sync bookmarks engine.
+ *
+ * @param db
+ *        The Sqlite.sys.mjs connection handle.
+ * @param forGuids
+ *        Fetch Sync tracking information for only the requested GUIDs.
+ * @return {Promise} resolved once all items have been fetched.
+ * @resolves to an object containing records for changed bookmarks, keyed by
+ *           the record ID.
+ */
+var pullSyncChanges = async function (db, forGuids = []) {
+  let changeRecords = {};
+
+  let itemConditions = ["syncChangeCounter >= 1"];
+  let tombstoneConditions = ["1 = 1"];
+  if (forGuids.length) {
+    let restrictToGuids = `guid IN (${forGuids
+      .map(guid => JSON.stringify(guid))
+      .join(",")})`;
+    itemConditions.push(restrictToGuids);
+    tombstoneConditions.push(restrictToGuids);
+  }
+
+  let rows = await db.executeCached(
+    `
+    WITH RECURSIVE
+    syncedItems(id, guid, modified, syncChangeCounter, syncStatus) AS (
+      SELECT b.id, b.guid, b.lastModified, b.syncChangeCounter, b.syncStatus
+       FROM moz_bookmarks b
+       WHERE b.guid IN ('menu________', 'toolbar_____', 'unfiled_____',
+                        'mobile______')
+      UNION ALL
+      SELECT b.id, b.guid, b.lastModified, b.syncChangeCounter, b.syncStatus
+      FROM moz_bookmarks b
+      JOIN syncedItems s ON b.parent = s.id
+    )
+    SELECT guid, modified, syncChangeCounter, syncStatus, 0 AS tombstone
+    FROM syncedItems
+    WHERE ${itemConditions.join(" AND ")}
+    UNION ALL
+    SELECT guid, dateRemoved AS modified, 1 AS syncChangeCounter,
+           :deletedSyncStatus, 1 AS tombstone
+    FROM moz_bookmarks_deleted
+    WHERE ${tombstoneConditions.join(" AND ")}`,
+    { deletedSyncStatus: lazy.PlacesUtils.bookmarks.SYNC_STATUS.NORMAL }
+  );
+  for (let row of rows) {
+    addRowToChangeRecords(row, changeRecords);
+  }
+
+  return changeRecords;
+};
+
+// Moves a synced folder's remaining children to its parent, and deletes the
+// folder if it's empty.
+async function deleteSyncedFolder(db, bookmarkItem) {
+  // At this point, any member in the folder that remains is either a folder
+  // pending deletion (which we'll get to in this function), or an item that
+  // should not be deleted. To avoid deleting these items, we first move them
+  // to the parent of the folder we're about to delete.
+  let childGuids = await fetchChildGuids(db, bookmarkItem.guid);
+  if (!childGuids.length) {
+    // No children -- just delete the folder.
+    return deleteSyncedAtom(bookmarkItem);
+  }
+
+  if (lazy.BookmarkSyncLog.level <= lazy.Log.Level.Trace) {
+    lazy.BookmarkSyncLog.trace(
+      `deleteSyncedFolder: Moving ${JSON.stringify(childGuids)} children of ` +
+        `"${bookmarkItem.guid}" to grandparent
+      "${BookmarkSyncUtils.guidToRecordId(bookmarkItem.parentGuid)}" before ` +
+        `deletion`
+    );
+  }
+
+  // Move children out of the parent and into the grandparent
+  for (let guid of childGuids) {
+    await lazy.PlacesUtils.bookmarks.update({
+      guid,
+      parentGuid: bookmarkItem.parentGuid,
+      index: lazy.PlacesUtils.bookmarks.DEFAULT_INDEX,
+      // `SYNC_REPARENT_REMOVED_FOLDER_CHILDREN` bumps the change counter for
+      // the child and its new parent, without incrementing the bookmark
+      // tracker's score.
+      //
+      // We intentionally don't check if the child is one we'll remove later,
+      // so it's possible we'll bump the change counter of the closest living
+      // ancestor when it's not needed. This avoids inconsistency if removal
+      // is interrupted, since we don't run this operation in a transaction.
+      source:
+        lazy.PlacesUtils.bookmarks.SOURCES
+          .SYNC_REPARENT_REMOVED_FOLDER_CHILDREN,
+    });
+  }
+
+  // Delete the (now empty) parent
+  try {
+    await lazy.PlacesUtils.bookmarks.remove(bookmarkItem.guid, {
+      preventRemovalOfNonEmptyFolders: true,
+      // We don't want to bump the change counter for this deletion, because
+      // a tombstone for the folder is already on the server.
+      source: SOURCE_SYNC,
+    });
+  } catch (e) {
+    // We failed, probably because someone added something to this folder
+    // between when we got the children and now (or the database is corrupt,
+    // or something else happened...) This is unlikely, but possible. To
+    // avoid corruption in this case, we need to reupload the record to the
+    // server.
+    //
+    // (Ideally this whole operation would be done in a transaction, and this
+    // wouldn't be possible).
+    lazy.BookmarkSyncLog.trace(
+      `deleteSyncedFolder: Error removing parent ` +
+        `${bookmarkItem.guid} after reparenting children`,
+      e
+    );
+    return false;
+  }
+
+  return true;
+}
+
+// Removes a synced bookmark or empty folder from the database.
+var deleteSyncedAtom = async function (bookmarkItem) {
+  try {
+    await lazy.PlacesUtils.bookmarks.remove(bookmarkItem.guid, {
+      preventRemovalOfNonEmptyFolders: true,
+      source: SOURCE_SYNC,
+    });
+  } catch (ex) {
+    // Likely already removed.
+    lazy.BookmarkSyncLog.trace(
+      `deleteSyncedAtom: Error removing ` + bookmarkItem.guid,
+      ex
+    );
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Updates the sync status on all "NEW" and "UNKNOWN" bookmarks to "NORMAL".
+ *
+ * We do this when pulling changes instead of in `pushChanges` to make sure
+ * we write tombstones if a new item is deleted after an interrupted sync. (For
+ * example, if a "NEW" record is uploaded or reconciled, then the app is closed
+ * before Sync calls `pushChanges`).
+ */
+function markChangesAsSyncing(db, changeRecords) {
+  let unsyncedGuids = [];
+  for (let recordId in changeRecords) {
+    if (changeRecords[recordId].tombstone) {
+      continue;
+    }
+    if (
+      changeRecords[recordId].status ==
+      lazy.PlacesUtils.bookmarks.SYNC_STATUS.NORMAL
+    ) {
+      continue;
+    }
+    let guid = BookmarkSyncUtils.recordIdToGuid(recordId);
+    unsyncedGuids.push(JSON.stringify(guid));
+  }
+  if (!unsyncedGuids.length) {
+    return Promise.resolve();
+  }
+  return db.execute(
+    `
+    UPDATE moz_bookmarks
+    SET syncStatus = :syncStatus
+    WHERE guid IN (${unsyncedGuids.join(",")})`,
+    { syncStatus: lazy.PlacesUtils.bookmarks.SYNC_STATUS.NORMAL }
+  );
+}
+
+/**
+ * Removes tombstones for successfully synced items.
+ *
+ * @return {Promise}
+ */
+var removeTombstones = function (db, guids) {
+  if (!guids.length) {
+    return Promise.resolve();
+  }
+  return db.execute(`
+    DELETE FROM moz_bookmarks_deleted
+    WHERE guid IN (${guids.map(guid => JSON.stringify(guid)).join(",")})`);
+};
+
+/**
+ * Removes tombstones for successfully synced items where the specified GUID
+ * exists in *both* the bookmarks and tombstones tables.
+ *
+ * @return {Promise}
+ */
+var removeUndeletedTombstones = function (db, guids) {
+  if (!guids.length) {
+    return Promise.resolve();
+  }
+  // sqlite can't join in a DELETE, so we use a subquery.
+  return db.execute(`
+    DELETE FROM moz_bookmarks_deleted
+    WHERE guid IN (${guids.map(guid => JSON.stringify(guid)).join(",")})
+    AND guid IN (SELECT guid from moz_bookmarks)`);
+};
+
+// Sets the history sync ID and clears the last sync time.
+async function setHistorySyncId(db, newSyncId) {
+  await lazy.PlacesUtils.metadata.setWithConnection(
+    db,
+    new Map([[HistorySyncUtils.SYNC_ID_META_KEY, newSyncId]])
+  );
+
+  await lazy.PlacesUtils.metadata.deleteWithConnection(
+    db,
+    HistorySyncUtils.LAST_SYNC_META_KEY
+  );
+}
+
+// Sets the bookmarks sync ID and clears the last sync time.
+async function setBookmarksSyncId(db, newSyncId) {
+  await lazy.PlacesUtils.metadata.setWithConnection(
+    db,
+    new Map([[BookmarkSyncUtils.SYNC_ID_META_KEY, newSyncId]])
+  );
+
+  await lazy.PlacesUtils.metadata.deleteWithConnection(
+    db,
+    BookmarkSyncUtils.LAST_SYNC_META_KEY,
+    BookmarkSyncUtils.WIPE_REMOTE_META_KEY
+  );
+}
+
+// Bumps the change counter and sets the given sync status for all bookmarks,
+// and drops stale tombstones.
+async function resetAllSyncStatuses(db, syncStatus) {
+  await db.execute(
+    `
+    UPDATE moz_bookmarks
+    SET syncChangeCounter = 1,
+        syncStatus = :syncStatus`,
+    { syncStatus }
+  );
+
+  // Drop stale tombstones.
+  await db.execute("DELETE FROM moz_bookmarks_deleted");
+}
+
+/**
+ * Other clients might have new fields we don't quite understand yet,
+ * so we add it to a "unknownFields" field to roundtrip back to the server
+ * so other clients don't experience data loss
+ * @param record: an object, usually from the server, and will iterate through the
+ *  the keys and extract any fields that are unknown to this client
+ * @param validFields: an array of keys we know are valid and should ignore
+ * @returns {String} json object containing unknownfields, null if none found
+ */
+PlacesSyncUtils.extractUnknownFields = (record, validFields) => {
+  let { unknownFields, hasUnknownFields } = Object.keys(record).reduce(
+    ({ unknownFields, hasUnknownFields }, key) => {
+      if (validFields.includes(key)) {
+        return { unknownFields, hasUnknownFields };
+      }
+      unknownFields[key] = record[key];
+      return { unknownFields, hasUnknownFields: true };
+    },
+    { unknownFields: {}, hasUnknownFields: false }
+  );
+  if (hasUnknownFields) {
+    // For simplicity, we store the unknown fields as a string
+    // since we never operate on it and just need it for roundtripping
+    return JSON.stringify(unknownFields);
+  }
+  return null;
+};