--- a/toolkit/components/places/PlacesTransactions.jsm
+++ b/toolkit/components/places/PlacesTransactions.jsm
@@ -1350,58 +1350,16 @@ PT.EditUrl.prototype = Object.seal({
 
     this.redo = async function() {
       updatedInfo = await updateItem();
     };
   }
 });
 
 /**
- * Transaction for setting annotations for an item.
- *
- * Required Input Properties: guid, annotationObject
- */
-PT.Annotate = DefineTransaction(["guids", "annotations"]);
-PT.Annotate.prototype = {
-  async execute({ guids, annotations }) {
-    let undoAnnosForItemId = new Map();
-    for (let guid of guids) {
-      let itemId = await PlacesUtils.promiseItemId(guid);
-      let currentAnnos = await PlacesUtils.promiseAnnotationsForItem(itemId);
-
-      let undoAnnos = [];
-      for (let newAnno of annotations) {
-        let currentAnno = currentAnnos.find(a => a.name == newAnno.name);
-        if (currentAnno) {
-          undoAnnos.push(currentAnno);
-        } else {
-          // An unset value removes the annotation.
-          undoAnnos.push({ name: newAnno.name });
-        }
-      }
-      undoAnnosForItemId.set(itemId, undoAnnos);
-
-      PlacesUtils.setAnnotationsForItem(itemId, annotations);
-    }
-
-    this.undo = function() {
-      for (let [itemId, undoAnnos] of undoAnnosForItemId) {
-        PlacesUtils.setAnnotationsForItem(itemId, undoAnnos);
-      }
-    };
-    this.redo = async function() {
-      for (let guid of guids) {
-        let itemId = await PlacesUtils.promiseItemId(guid);
-        PlacesUtils.setAnnotationsForItem(itemId, annotations);
-      }
-    };
-  }
-};
-
-/**
  * Transaction for setting the keyword for a bookmark.
  *
  * Required Input Properties: guid, keyword.
  * Optional Input Properties: postData, oldKeyword.
  */
 PT.EditKeyword = DefineTransaction(["guid", "keyword"],
                                    ["postData", "oldKeyword"]);
 PT.EditKeyword.prototype = Object.seal({

--- a/toolkit/components/places/tests/unit/test_async_transactions.js
+++ b/toolkit/components/places/tests/unit/test_async_transactions.js
@@ -1552,115 +1552,16 @@ add_task(async function test_untag_uri()
   observer.reset();
   await PT.undo();
   ensureItemsRemoved(bm_info_a, bm_info_b);
 
   await PT.clearTransactionsHistory();
   ensureUndoState();
 });
 
-add_task(async function test_annotate() {
-  let bm_info = { url: "http://test.item.annotation",
-                  parentGuid: PlacesUtils.bookmarks.unfiledGuid };
-  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 = await PT.NewBookmark(bm_info).transact();
-
-  observer.reset();
-  await PT.Annotate({ guid: bm_info.guid, annotation: anno_info }).transact();
-  ensureAnnoState(true);
-
-  observer.reset();
-  await PT.undo();
-  ensureAnnoState(false);
-
-  observer.reset();
-  await PT.redo();
-  ensureAnnoState(true);
-
-  // Test removing the annotation by not passing the |value| property.
-  observer.reset();
-  await PT.Annotate({ guid: bm_info.guid,
-                      annotation: { name: anno_info.name }}).transact();
-  ensureAnnoState(false);
-
-  observer.reset();
-  await PT.undo();
-  ensureAnnoState(true);
-
-  observer.reset();
-  await PT.redo();
-  ensureAnnoState(false);
-
-  // Cleanup
-  await PT.undo();
-  observer.reset();
-});
-
-add_task(async function test_annotate_multiple() {
-  let guid = await PT.NewFolder(createTestFolderInfo()).transact();
-  let itemId = await 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)];
-  }
-
-  async function verifyAnnoValues(a = null, b = null) {
-    let currentAnnos = await PlacesUtils.promiseAnnotationsForItem(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);
-  }
-
-  await PT.Annotate({ guid, annotations: annos(1, 2) }).transact();
-  await verifyAnnoValues(1, 2);
-  await PT.undo();
-  await verifyAnnoValues();
-  await PT.redo();
-  await verifyAnnoValues(1, 2);
-
-  await PT.Annotate({ guid,
-                      annotation: { name: "A" } }).transact();
-  await verifyAnnoValues(null, 2);
-
-  await PT.Annotate({ guid,
-                      annotation: { name: "B", value: 0 } }).transact();
-  await verifyAnnoValues(null, 0);
-  await PT.undo();
-  await verifyAnnoValues(null, 2);
-  await PT.redo();
-  await verifyAnnoValues(null, 0);
-  await PT.undo();
-  await verifyAnnoValues(null, 2);
-  await PT.undo();
-  await verifyAnnoValues(1, 2);
-  await PT.undo();
-  await verifyAnnoValues();
-
-  // Cleanup
-  await PT.undo();
-  observer.reset();
-});
-
 add_task(async function test_sort_folder_by_name() {
   let folder_info = createTestFolderInfo();
 
   let url = "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];
@@ -1908,55 +1809,16 @@ add_task(async function test_invalid_uri
              urls: ["invalid uri spec"] }),
            /TypeError: invalid uri spec is not a valid URL/);
   Assert.throws(() =>
     PT.Tag({ tag: "TheTag",
              urls: ["about:blank", "invalid uri spec"] }),
            /TypeError: invalid uri spec is not a valid URL/);
 });
 
-add_task(async function test_annotate_multiple_items() {
-  let parentGuid = menuGuid;
-  let guids = [
-    await PT.NewBookmark({ url: "about:blank", parentGuid }).transact(),
-    await PT.NewFolder({ title: "Test Folder", parentGuid }).transact()];
-
-  let annotation = { name: "TestAnno", value: "TestValue" };
-  await PT.Annotate({ guids, annotation }).transact();
-
-  async function ensureAnnoSet() {
-    for (let guid of guids) {
-      let itemId = await PlacesUtils.promiseItemId(guid);
-      Assert.equal(annosvc.getItemAnnotation(itemId, annotation.name),
-                   annotation.value);
-    }
-  }
-  async function ensureAnnoUnset() {
-    for (let guid of guids) {
-      let itemId = await PlacesUtils.promiseItemId(guid);
-      Assert.ok(!annosvc.itemHasAnnotation(itemId, annotation.name));
-    }
-  }
-
-  await ensureAnnoSet();
-  await PT.undo();
-  await ensureAnnoUnset();
-  await PT.redo();
-  await ensureAnnoSet();
-  await PT.undo();
-  await ensureAnnoUnset();
-
-  // Cleanup
-  await PT.undo();
-  await PT.undo();
-  await ensureNonExistent(...guids);
-  await PT.clearTransactionsHistory();
-  observer.reset();
-});
-
 add_task(async function test_remove_multiple() {
   let guids = [];
   await PT.batch(async function() {
     let folderGuid = await PT.NewFolder({ title: "Test Folder",
                                           parentGuid: menuGuid }).transact();
     let nestedFolderGuid =
       await PT.NewFolder({ title: "Nested Test Folder",
                            parentGuid: folderGuid }).transact();