Bug 1150678 - Changing url of a bookmark with a keyword breaks the keyword forever. r=adw a=ritu
☠☠ backed out by 3a0fd1bb116a ☠ ☠
authorMarco Bonardo <mbonardo@mozilla.com>
Tue, 06 Sep 2016 15:06:59 -0700
changeset 350106 c62d6e8a740719270dcc4b64148ae8c694343e4a
parent 350105 bdd8924b8ebb02104a5709a6b0c8fd8bd8c4a0d2
child 350107 a4ee689323092f6ac3c81b9d4d4ea3a9f5d8276f
push id1230
push userjlund@mozilla.com
push dateMon, 31 Oct 2016 18:13:35 +0000
treeherdermozilla-release@5e06e3766db2 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersadw, ritu
bugs1150678
milestone50.0a2
Bug 1150678 - Changing url of a bookmark with a keyword breaks the keyword forever. r=adw a=ritu
browser/components/places/content/editBookmarkOverlay.js
toolkit/components/places/Database.cpp
toolkit/components/places/Database.h
toolkit/components/places/PlacesTransactions.jsm
toolkit/components/places/PlacesUtils.jsm
toolkit/components/places/tests/head_common.js
toolkit/components/places/tests/migration/places_v34.sqlite
toolkit/components/places/tests/migration/xpcshell.ini
toolkit/components/places/tests/unit/test_async_transactions.js
toolkit/components/places/tests/unit/test_keywords.js
toolkit/components/places/tests/unit/test_placesTxn.js
--- a/browser/components/places/content/editBookmarkOverlay.js
+++ b/browser/components/places/content/editBookmarkOverlay.js
@@ -126,24 +126,28 @@ var gEditItemOverlay = {
   _initDescriptionField() {
     if (!this._paneInfo.isItem)
       throw new Error("_initDescriptionField called unexpectedly");
 
     this._initTextField(this._descriptionField,
                         PlacesUIUtils.getItemDescription(this._paneInfo.itemId));
   },
 
-  _initKeywordField: Task.async(function* (aNewKeyword) {
-    if (!this._paneInfo.isBookmark)
+  _initKeywordField: Task.async(function* (newKeyword = "") {
+    if (!this._paneInfo.isBookmark) {
       throw new Error("_initKeywordField called unexpectedly");
+    }
 
-    let newKeyword = aNewKeyword;
-    if (newKeyword === undefined) {
-      let itemId = this._paneInfo.itemId;
-      newKeyword = PlacesUtils.bookmarks.getKeywordForBookmark(itemId);
+    if (!newKeyword) {
+      let entries = [];
+      yield PlacesUtils.keywords.fetch({ url: this._paneInfo.uri.spec },
+                                       e => entries.push(e));
+      if (entries.length > 0) {
+        this._keyword = newKeyword = entries[0].keyword;
+      }
     }
     this._initTextField(this._keywordField, newKeyword);
   }),
 
   _initLoadInSidebar: Task.async(function* () {
     if (!this._paneInfo.isBookmark)
       throw new Error("_initLoadInSidebar called unexpectedly");
 
@@ -210,17 +214,17 @@ var gEditItemOverlay = {
     // hide the description field for
     if (showOrCollapse("descriptionRow", isItem && !this.readOnly,
                        "description")) {
       this._initDescriptionField();
       this._descriptionField.readOnly = this.readOnly;
     }
 
     if (showOrCollapse("keywordRow", isBookmark, "keyword")) {
-      this._initKeywordField();
+      this._initKeywordField().catch(Components.utils.reportError);
       this._keywordField.readOnly = this.readOnly;
     }
 
     // Collapse the tag selector if the item does not accept tags.
     if (showOrCollapse("tagsRow", isURI || bulkTagging, "tags"))
       this._initTagsField().catch(Components.utils.reportError);
     else if (!this._element("tagsSelectorRow").collapsed)
       this.toggleTagsSelector().catch(Components.utils.reportError);
@@ -563,17 +567,17 @@ var gEditItemOverlay = {
         return;
       }
       Task.spawn(function* () {
         let guid = this._paneInfo.isTag
                     ? (yield PlacesUtils.promiseItemGuid(this._paneInfo.itemId))
                     : this._paneInfo.itemGuid;
         PlacesTransactions.EditTitle({ guid, title: newTitle })
                           .transact().catch(Components.utils.reportError);
-      }).catch(Cu.reportError);
+      }).catch(Components.utils.reportError);
     }
   },
 
   onDescriptionFieldChange() {
     if (this.readOnly || !this._paneInfo.isItem)
       return;
 
     let itemId = this._paneInfo.itemId;
@@ -620,24 +624,29 @@ var gEditItemOverlay = {
                       .transact().catch(Components.utils.reportError);
   },
 
   onKeywordFieldChange() {
     if (this.readOnly || !this._paneInfo.isBookmark)
       return;
 
     let itemId = this._paneInfo.itemId;
-    let newKeyword = this._keywordField.value;
+    let oldKeyword = this._keyword;
+    let keyword = this._keyword = this._keywordField.value;
+    let postData = this._paneInfo.postData;
     if (!PlacesUIUtils.useAsyncTransactions) {
-      let txn = new PlacesEditBookmarkKeywordTransaction(itemId, newKeyword, this._paneInfo.postData);
+      let txn = new PlacesEditBookmarkKeywordTransaction(itemId,
+                                                         keyword,
+                                                         postData,
+                                                         oldKeyword);
       PlacesUtils.transactionManager.doTransaction(txn);
       return;
     }
     let guid = this._paneInfo.itemGuid;
-    PlacesTransactions.EditKeyword({ guid, keyword: newKeyword })
+    PlacesTransactions.EditKeyword({ guid, keyword, postData, oldKeyword })
                       .transact().catch(Components.utils.reportError);
   },
 
   onLoadInSidebarCheckboxCommand() {
     if (!this.initialized || !this._paneInfo.isBookmark)
       return;
 
     let annotation = { name : PlacesUIUtils.LOAD_IN_SIDEBAR_ANNO };
@@ -1081,17 +1090,17 @@ var gEditItemOverlay = {
         if (this._paneInfo.visibleRows.has("tagsRow")) {
           delete this._paneInfo._cachedCommonTags;
           this._onTagsChange(aItemId);
         }
       }
       break;
     case "keyword":
       if (this._paneInfo.visibleRows.has("keywordRow"))
-        this._initKeywordField(aValue);
+        this._initKeywordField(aValue).catch(Components.utils.reportError);
       break;
     case PlacesUIUtils.DESCRIPTION_ANNO:
       if (this._paneInfo.visibleRows.has("descriptionRow"))
         this._initDescriptionField();
       break;
     case PlacesUIUtils.LOAD_IN_SIDEBAR_ANNO:
       if (this._paneInfo.visibleRows.has("loadInSidebarCheckbox"))
         this._initLoadInSidebar();
--- a/toolkit/components/places/Database.cpp
+++ b/toolkit/components/places/Database.cpp
@@ -847,17 +847,22 @@ Database::InitSchema(bool* aDatabaseMigr
 
       // Firefox 49 uses schema version 32.
 
       if (currentSchemaVersion < 33) {
         rv = MigrateV33Up();
         NS_ENSURE_SUCCESS(rv, rv);
       }
 
-      // Firefox 50 uses schema version 33.
+      if (currentSchemaVersion < 34) {
+        rv = MigrateV34Up();
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+
+      // Firefox 50 uses schema version 34.
 
       // Schema Upgrades must add migration code here.
 
       rv = UpdateBookmarkRootTitles();
       // We don't want a broken localization to cause us to think
       // the database is corrupt and needs to be replaced.
       MOZ_ASSERT(NS_SUCCEEDED(rv));
     }
@@ -1808,16 +1813,31 @@ Database::MigrateV33Up() {
 
   // Create an index on url_hash.
   rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_URL_HASH);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
+nsresult
+Database::MigrateV34Up() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "DELETE FROM moz_keywords WHERE id IN ( "
+      "SELECT id FROM moz_keywords k "
+      "WHERE NOT EXISTS (SELECT 1 FROM moz_places h WHERE k.place_id = h.id) "
+    ")"
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
 void
 Database::Shutdown()
 {
   // As the last step in the shutdown path, finalize the database handle.
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!mClosed);
 
   // Break cycles with the shutdown blockers.
--- a/toolkit/components/places/Database.h
+++ b/toolkit/components/places/Database.h
@@ -13,17 +13,17 @@
 #include "mozilla/storage.h"
 #include "mozilla/storage/StatementCache.h"
 #include "mozilla/Attributes.h"
 #include "nsIEventTarget.h"
 #include "Shutdown.h"
 
 // This is the schema version. Update it at any schema change and add a
 // corresponding migrateVxx method below.
-#define DATABASE_SCHEMA_VERSION 33
+#define DATABASE_SCHEMA_VERSION 34
 
 // Fired after Places inited.
 #define TOPIC_PLACES_INIT_COMPLETE "places-init-complete"
 // Fired when initialization fails due to a locked database.
 #define TOPIC_DATABASE_LOCKED "places-database-locked"
 // This topic is received when the profile is about to be lost.  Places does
 // initial shutdown work and notifies TOPIC_PLACES_SHUTDOWN to all listeners.
 // Any shutdown work that requires the Places APIs should happen here.
@@ -264,16 +264,17 @@ protected:
   nsresult MigrateV25Up();
   nsresult MigrateV26Up();
   nsresult MigrateV27Up();
   nsresult MigrateV28Up();
   nsresult MigrateV30Up();
   nsresult MigrateV31Up();
   nsresult MigrateV32Up();
   nsresult MigrateV33Up();
+  nsresult MigrateV34Up();
 
   nsresult UpdateBookmarkRootTitles();
 
   friend class ConnectionShutdownBlocker;
 
 private:
   ~Database();
 
--- a/toolkit/components/places/PlacesTransactions.jsm
+++ b/toolkit/components/places/PlacesTransactions.jsm
@@ -880,17 +880,17 @@ function (aInput, aRequiredProps = [], a
 // Update the documentation at the top of this module if you add or
 // remove properties.
 DefineTransaction.defineInputProps(["url", "feedUrl", "siteUrl"],
                                    DefineTransaction.urlValidate, null);
 DefineTransaction.defineInputProps(["guid", "parentGuid", "newParentGuid"],
                                    DefineTransaction.guidValidate);
 DefineTransaction.defineInputProps(["title"],
                                    DefineTransaction.strOrNullValidate, null);
-DefineTransaction.defineInputProps(["keyword", "postData", "tag",
+DefineTransaction.defineInputProps(["keyword", "oldKeyword", "postData", "tag",
                                     "excludingAnnotation"],
                                    DefineTransaction.strValidate, "");
 DefineTransaction.defineInputProps(["index", "newIndex"],
                                    DefineTransaction.indexValidate,
                                    PlacesUtils.bookmarks.DEFAULT_INDEX);
 DefineTransaction.defineInputProps(["annotation"],
                                    DefineTransaction.annotationObjectValidate);
 DefineTransaction.defineArrayInputProp("guids", "guid");
@@ -995,18 +995,22 @@ function* createItemsFromBookmarksTree(a
     let guid = aRestoring ? aItem.guid : undefined;
     let parentId = yield PlacesUtils.promiseItemId(aParentGuid);
     let annos = aItem.annos ? [...aItem.annos] : [];
     switch (aItem.type) {
       case PlacesUtils.TYPE_X_MOZ_PLACE: {
         let uri = NetUtil.newURI(aItem.uri);
         itemId = PlacesUtils.bookmarks.insertBookmark(
           parentId, uri, aIndex, aItem.title, guid);
-        if ("keyword" in aItem)
-          PlacesUtils.bookmarks.setKeywordForBookmark(itemId, aItem.keyword);
+        if ("keyword" in aItem) {
+          yield PlacesUtils.keywords.insert({
+            keyword: aItem.keyword,
+            url: uri.spec
+          });
+        }
         if ("tags" in aItem) {
           PlacesUtils.tagging.tagURI(uri, aItem.tags.split(","));
         }
         break;
       }
       case PlacesUtils.TYPE_X_MOZ_PLACE_CONTAINER: {
         // Either a folder or a livemark
         let [feedURI, siteURI] = extractLivemarkDetails(annos);
@@ -1079,36 +1083,42 @@ var PT = PlacesTransactions;
  */
 PT.NewBookmark = DefineTransaction(["parentGuid", "url"],
                                    ["index", "title", "keyword", "postData",
                                     "annotations", "tags"]);
 PT.NewBookmark.prototype = Object.seal({
   execute: function (aParentGuid, aURI, aIndex, aTitle,
                      aKeyword, aPostData, aAnnos, aTags) {
     return ExecuteCreateItem(this, aParentGuid,
-      function (parentId, guidToRestore = "") {
+      function* (parentId, guidToRestore = "") {
         let itemId = PlacesUtils.bookmarks.insertBookmark(
           parentId, aURI, aIndex, aTitle, guidToRestore);
-        if (aKeyword)
-          PlacesUtils.bookmarks.setKeywordForBookmark(itemId, aKeyword);
-        if (aPostData)
-          PlacesUtils.setPostDataForBookmark(itemId, aPostData);
-        if (aAnnos.length)
+
+        if (aKeyword) {
+          yield PlacesUtils.keywords.insert({
+            url: aURI.spec,
+            keyword: aKeyword,
+            postData: aPostData
+          });
+        }
+        if (aAnnos.length) {
           PlacesUtils.setAnnotationsForItem(itemId, aAnnos);
+        }
         if (aTags.length > 0) {
           let currentTags = PlacesUtils.tagging.getTagsForURI(aURI);
           aTags = aTags.filter(t => !currentTags.includes(t));
           PlacesUtils.tagging.tagURI(aURI, aTags);
         }
 
         return itemId;
       },
       function _additionalOnUndo() {
-        if (aTags.length > 0)
+        if (aTags.length > 0) {
           PlacesUtils.tagging.untagURI(aURI, aTags);
+        }
       });
   }
 });
 
 /**
  * Transaction for creating a folder.
  *
  * Required Input Properties: title, parentGuid.
@@ -1116,17 +1126,17 @@ PT.NewBookmark.prototype = Object.seal({
  *
  * When this transaction is executed, it's resolved to the new folder's GUID.
  */
 PT.NewFolder = DefineTransaction(["parentGuid", "title"],
                                  ["index", "annotations"]);
 PT.NewFolder.prototype = Object.seal({
   execute: function (aParentGuid, aTitle, aIndex, aAnnos) {
     return ExecuteCreateItem(this,  aParentGuid,
-      function(parentId, guidToRestore = "") {
+      function* (parentId, guidToRestore = "") {
         let itemId = PlacesUtils.bookmarks.createFolder(
           parentId, aTitle, aIndex, guidToRestore);
         if (aAnnos.length > 0)
           PlacesUtils.setAnnotationsForItem(itemId, aAnnos);
         return itemId;
       });
   }
 });
@@ -1139,17 +1149,17 @@ PT.NewFolder.prototype = Object.seal({
  *
  * When this transaction is executed, it's resolved to the new separator's
  * GUID.
  */
 PT.NewSeparator = DefineTransaction(["parentGuid"], ["index"]);
 PT.NewSeparator.prototype = Object.seal({
   execute: function (aParentGuid, aIndex) {
     return ExecuteCreateItem(this, aParentGuid,
-      function (parentId, guidToRestore = "") {
+      function* (parentId, guidToRestore = "") {
         let itemId = PlacesUtils.bookmarks.insertSeparator(
           parentId, aIndex, guidToRestore);
         return itemId;
       });
   }
 });
 
 /**
@@ -1331,24 +1341,46 @@ PT.Annotate.prototype = {
   }
 };
 
 /**
  * Transaction for setting the keyword for a bookmark.
  *
  * Required Input Properties: guid, keyword.
  */
-PT.EditKeyword = DefineTransaction(["guid", "keyword"]);
+PT.EditKeyword = DefineTransaction(["guid", "keyword"],
+                                   ["postData", "oldKeyword"]);
 PT.EditKeyword.prototype = Object.seal({
-  execute: function* (aGuid, aKeyword) {
-    let itemId = yield PlacesUtils.promiseItemId(aGuid),
-        oldKeyword = PlacesUtils.bookmarks.getKeywordForBookmark(itemId);
-    PlacesUtils.bookmarks.setKeywordForBookmark(itemId, aKeyword);
-    this.undo = () => {
-      PlacesUtils.bookmarks.setKeywordForBookmark(itemId, oldKeyword);
+  execute: function* (aGuid, aKeyword, aPostData, aOldKeyword) {
+    let url;
+    let oldKeywordEntry;
+    if (aOldKeyword) {
+      oldKeywordEntry = yield PlacesUtils.keywords.fetch(aOldKeyword);
+      url = oldKeywordEntry.url;
+      yield PlacesUtils.keywords.remove(aOldKeyword);
+    }
+
+    if (aKeyword) {
+      if (!url) {
+        url = (yield PlacesUtils.bookmarks.fetch(aGuid)).url;
+      }
+      yield PlacesUtils.keywords.insert({
+        url: url,
+        keyword: aKeyword,
+        postData: aPostData || (oldKeywordEntry ? oldKeywordEntry.postData : "")
+      });
+    }
+
+    this.undo = function* () {
+      if (aKeyword) {
+        yield PlacesUtils.keywords.remove(aKeyword);
+      }
+      if (oldKeywordEntry) {
+        yield PlacesUtils.keywords.insert(oldKeywordEntry);
+      }
     };
   }
 });
 
 /**
  * Transaction for sorting a folder by name.
  *
  * Required Input Properties: guid.
--- a/toolkit/components/places/PlacesUtils.jsm
+++ b/toolkit/components/places/PlacesUtils.jsm
@@ -1660,17 +1660,18 @@ this.PlacesUtils = {
         default:
           Cu.reportError("Unexpected bookmark type");
           break;
       }
       return item;
     }.bind(this);
 
     const QUERY_STR =
-      `WITH RECURSIVE
+      `/* do not warn (bug no): cannot use an index */
+       WITH RECURSIVE
        descendants(fk, level, type, id, guid, parent, parentGuid, position,
                    title, dateAdded, lastModified) AS (
          SELECT b1.fk, 0, b1.type, b1.id, b1.guid, b1.parent,
                 (SELECT guid FROM moz_bookmarks WHERE id = b1.parent),
                 b1.position, b1.title, b1.dateAdded, b1.lastModified
          FROM moz_bookmarks b1 WHERE b1.guid=:item_guid
          UNION ALL
          SELECT b2.fk, level + 1, b2.type, b2.id, b2.guid, b2.parent,
@@ -2181,39 +2182,64 @@ XPCOMUtils.defineLazyGetter(this, "gKeyw
             if (!bookmark) {
               for (let keyword of keywords) {
                 yield PlacesUtils.keywords.remove(keyword);
               }
             }
           }).catch(Cu.reportError);
         },
 
-        onItemChanged(id, prop, isAnno, val, lastMod, itemType, parentId, guid) {
-          if (gIgnoreKeywordNotifications ||
-              prop != "keyword")
+        onItemChanged(id, prop, isAnno, val, lastMod, itemType, parentId, guid,
+                      parentGuid, oldVal) {
+          if (gIgnoreKeywordNotifications) {
+            return;
+          }
+
+          if (prop == "keyword") {
+            this._onKeywordChanged(guid, val).catch(Cu.reportError);
+          } else if (prop == "uri") {
+            this._onUrlChanged(guid, val, oldVal).catch(Cu.reportError);
+          }
+        },
+
+        _onKeywordChanged: Task.async(function* (guid, keyword) {
+          let bookmark = yield PlacesUtils.bookmarks.fetch(guid);
+          // Due to mixed sync/async operations, by this time the bookmark could
+          // have disappeared and we already handle removals in onItemRemoved.
+          if (!bookmark) {
             return;
-
-          Task.spawn(function* () {
-            let bookmark = yield PlacesUtils.bookmarks.fetch(guid);
-            // By this time the bookmark could have gone, there's nothing we can do.
-            if (!bookmark)
-              return;
-
-            if (val.length == 0) {
-              // We are removing a keyword.
-              let keywords = keywordsForHref(bookmark.url.href)
-              for (let keyword of keywords) {
-                cache.delete(keyword);
-              }
-            } else {
-              // We are adding a new keyword.
-              cache.set(val, { keyword: val, url: bookmark.url });
+          }
+
+          if (keyword.length == 0) {
+            // We are removing a keyword.
+            let keywords = keywordsForHref(bookmark.url.href)
+            for (let kw of keywords) {
+              cache.delete(kw);
             }
-          }).catch(Cu.reportError);
-        }
+          } else {
+            // We are adding a new keyword.
+            cache.set(keyword, { keyword, url: bookmark.url });
+          }
+        }),
+
+        _onUrlChanged: Task.async(function* (guid, url, oldUrl) {
+          // Check if the old url is associated with keywords.
+          let entries = [];
+          yield PlacesUtils.keywords.fetch({ url: oldUrl }, e => entries.push(e));
+          if (entries.length == 0) {
+            return;
+          }
+
+          // Move the keywords to the new url.
+          for (let entry of entries) {
+            yield PlacesUtils.keywords.remove(entry.keyword);
+            entry.url = new URL(url);
+            yield PlacesUtils.keywords.insert(entry);
+          }
+        }),
       };
 
       PlacesUtils.bookmarks.addObserver(observer, false);
       PlacesUtils.registerShutdownFunction(() => {
         PlacesUtils.bookmarks.removeObserver(observer);
       });
       return cache;
     })
@@ -3248,50 +3274,87 @@ PlacesSetPageAnnotationTransaction.proto
  * Transaction for editing a bookmark's keyword.
  *
  * @param aItemId
  *        id of the bookmark to edit
  * @param aNewKeyword
  *        new keyword for the bookmark
  * @param aNewPostData [optional]
  *        new keyword's POST data, if available
+ * @param aOldKeyword [optional]
+ *        old keyword of the bookmark
  *
  * @return nsITransaction object
  */
 this.PlacesEditBookmarkKeywordTransaction =
- function PlacesEditBookmarkKeywordTransaction(aItemId, aNewKeyword, aNewPostData)
-{
+  function PlacesEditBookmarkKeywordTransaction(aItemId, aNewKeyword,
+                                                aNewPostData, aOldKeyword) {
   this.item = new TransactionItemCache();
   this.item.id = aItemId;
+  this.item.keyword = aOldKeyword;
+  this.item.href = (PlacesUtils.bookmarks.getBookmarkURI(aItemId)).spec;
   this.new = new TransactionItemCache();
   this.new.keyword = aNewKeyword;
   this.new.postData = aNewPostData
 }
 
 PlacesEditBookmarkKeywordTransaction.prototype = {
   __proto__: BaseTransaction.prototype,
 
   doTransaction: function EBKTXN_doTransaction()
   {
-    // Store the current values.
-    this.item.keyword = PlacesUtils.bookmarks.getKeywordForBookmark(this.item.id);
-    if (this.item.keyword)
-      this.item.postData = PlacesUtils.getPostDataForBookmark(this.item.id);
-
-    // Update the keyword.
-    PlacesUtils.bookmarks.setKeywordForBookmark(this.item.id, this.new.keyword);
-    if (this.new.keyword && this.new.postData)
-      PlacesUtils.setPostDataForBookmark(this.item.id, this.new.postData);
+    let done = false;
+    Task.spawn(function* () {
+      if (this.item.keyword) {
+        let oldEntry = yield PlacesUtils.keywords.fetch(this.item.keyword);
+        this.item.postData = oldEntry.postData;
+        yield PlacesUtils.keywords.remove(this.item.keyword);
+      }
+
+      if (this.new.keyword) {
+        yield PlacesUtils.keywords.insert({
+          url: this.item.href,
+          keyword: this.new.keyword,
+          postData: this.new.postData || this.item.postData
+        });
+      }
+    }.bind(this)).catch(Cu.reportError)
+                 .then(() => done = true);
+    // TODO: Until we can move to PlacesTransactions.jsm, we must spin the
+    // events loop :(
+    let thread = Services.tm.currentThread;
+    while (!done) {
+      thread.processNextEvent(true);
+    }
   },
 
   undoTransaction: function EBKTXN_undoTransaction()
   {
-    PlacesUtils.bookmarks.setKeywordForBookmark(this.item.id, this.item.keyword);
-    if (this.item.postData)
-      PlacesUtils.setPostDataForBookmark(this.item.id, this.item.postData);
+
+    let done = false;
+    Task.spawn(function* () {
+      if (this.new.keyword) {
+        yield PlacesUtils.keywords.remove(this.new.keyword);
+      }
+
+      if (this.item.keyword) {
+        yield PlacesUtils.keywords.insert({
+          url: this.item.href,
+          keyword: this.item.keyword,
+          postData: this.item.postData
+        });
+      }
+    }.bind(this)).catch(Cu.reportError)
+                 .then(() => done = true);
+    // TODO: Until we can move to PlacesTransactions.jsm, we must spin the
+    // events loop :(
+    let thread = Services.tm.currentThread;
+    while (!done) {
+      thread.processNextEvent(true);
+    }
   }
 };
 
 
 /**
  * Transaction for editing the post data associated with a bookmark.
  *
  * @param aItemId
--- a/toolkit/components/places/tests/head_common.js
+++ b/toolkit/components/places/tests/head_common.js
@@ -1,14 +1,14 @@
 /* -*- 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 = 33;
+const CURRENT_SCHEMA_VERSION = 34;
 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;
new file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..474628996f90b85655edcf9a5dface1d122b1088
GIT binary patch
literal 1146880
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
z000000000000000000000000000000008*^RZpsP_t3ffrbm>OmWIQ{LrRMlXEL4X
zBWr59ySqoWCs!ug+F~P<sYNyMjuG?c*0dy2@s{NBn(jnLbFw=<VpMHScf74B*&eSs
zwky-#m`--3n&L-qDmG$aDqAR?IxLsf9&b)`weK*iDcO;UcVu#T=}fAt<M`e((P7b3
zdi#lvsvQ}f9Z$8yn=;W%a#1|9IG!3A{mq)oqBDBOxG0qz8Eb1xtW36#%niL{VW_BX
z_~`o&+R!|`ZqD%yE0?t_s_PiG*FMi5aP5?m%Fs!n-AhYLL#3f1WyPIsv8MQuxxY4l
z^w`7F$yDa(QKJuQk1d}QPj|It(nn`IKV{7P^yJAcvu4g-G9nauZS?#T9vOagab;-Y
zcFpALkKd;HtcI4R^og@(*H2$rpQ}Fhmp6a*l%mSe{LqMO^>9J9`g=@#Y+<r1Q?u<=
z7KPTfO<FLyzIOJM6}1yr4BP87f12EQdSPX#@$YUpH}|Q;!mdnwyVeUsYfn6FT*vs+
zR?MA0ruC#@d$s&@-Pui%%24~?-Fn}8Y3fR6lI@9=+jkNPt?kN89Fb@`Io8rSdDgJK
zjwma-=*)u3P}4u$$>Mlh=XUKEgw`e|bT_p(&K}p8Zdo>LugHmaeC@1oWhjwvzw95m
zi0m3o#oD&(BD8kQwDBXB%w2I@YT3%uvORq9r$<&~H&;0LV<`Ir000000000000000
z000000000000000000000002*6MKY9LZ#v2veME}QQh#-_aC&OBA2{o7Y_>n00000
z000000000000000000000000000000004He^4wv~E*=B`00000000000000000000
z000000000000000008V_71>WXcs`W<0RR91000000000000000000000000000000
z0001h_k+E|#i2tAN<;0*m5H{t*vMpRQRoxp*^F@Tawz))00000000000000000000
z0000000000000000002*AC-|q%G#4F6K!p=k;&Aeid@n;Z-s(Kg3kwM1+}aHwE7#X
zgVhsP7p}U0)#a<sTy=Oh6951J0000000000000000000000000000000002^S9e6^
zfKWITF3X-47Y~UPgo^5h*KK%VL0>p=V%MpQ>ZVO?m@_9nreZ*-EF3O9Bwx0qU{1U#
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
zf6Xo)KL7v#00000000000000000000000000000000000>|zz!Pb4@x6kHZ8&ISMg
z000000000000000000000000000000000000Pv5ij_ei+heLx(!{OrMih?=urg%qY
zUTjgiFcK=N8(z2m-#7GyM-=3X9+EFQpkPKaojEy?PGsWEo63IXjA&oDBs?G#E(`Va
z7LH78ZjLTYCR^KMsn&EflZ<8-C(_ZDWLtAQm5Zk1@oZAOJ=&Z|cece=#G9kZj$BG~
z(&k$8lF7D(vDBu%x(D9W7gl61qjJ@0q2Q6=#-KYmF*tPf+p8a5ef8>vt7}(>R^7kq
z@@ysm000000000000000000000000000000000000Kor|BP$DQW>mE&S2iwAq%+CX
zie<UK_nzJ^p|P_q))a4!W#WmB=J@ha(d@taio%-X_WnESwxp8nebwp*{GFBh_ce02
z!o!c+FIQ&spP1h&(wNA^H}x<&S{JRWEiXL$*mo=68B4`GGJQ4bqoa;2D?EJed-c#3
zOJ~}X&54#oyt!X*^`(V}H|+Z^br*Fdnj5=15=*<{ebq({Eh!vyRDK@vGn?LW*4PqT
zmS{?L<cp4v)(t5x95iOfB^M{tnN7t;A68U2XxxsA<!7`h+0~KBma8r-9CY+fI!?u#
z;vG#ZHZ@s4GEz8b>W+)%rXt_$=G&BQdU!$MpyPI2e%mP+A01U4-swQPQf-ZkW9h|x
zMa#1*wKVuyD0nOQbMQ*=hv0X?lff^t2><{9000000000000000000000000000000
z00000@K3HN5)PM?=8i>0xnp5r?ih*Wjs*pgNLg87Bor>m9g54d<x7L^Q1E8(TJU6W
zfAF>7+Tat}1ONa400000000000000000000000000000000000_`h$T$cXTwRB~jj
ztu3)K**>znyL)8mjuMM@lvuc<#K?{k3-*qTDBG^h$nN2hCHZ4<d3G?R!Q-LeufglV
zE5QrFbHUTW#%uxr00000000000000000000000000000000000008_eD2$YaOA8~V
z;gZ~;ICm(@9SU=YNbXP&iIkR=XN#5wKMn<N1%D1+3Vt6v9sDYIB%1&L0000000000
z00000000000000000000000000095AiX#Q#(AuKjps+WH^ace*k%F>pUL+h|SXvk<
z4VUB&#pT&rrNKj?;IF~!!7ITF!E?dW!NzO?000000000000000000000000000000
z000000002|GaC>o4u^{BhL67gpbe#kkx;lKcPP#sigJg-+#!-X6htDSvhr+|aPUef
z`vU*~000000000000000000000000000000000000PiCeh2i3|(oj*|@X_}lw4pqk
z5)S?v%KiWV000000000000000000000000000000000000KofFBvM*do(;pnYoY89
z000000000000000000000000000000000000002Iuk02nE(;aa4Ih2~K^w}m@ycLb
zD0nk?HTXmDOt3L{G<Yz$FZgco&EWRn*5Jl$CIA2c0000000000000000000000000
z0000000000>|(`*;j(Z^MLsAVkPnJ>%Lj$!`5;o34+=_)3d^!ZiVH*GaHKLH6qNJ^
zMZG~`ZxHDX3W~BpSwVTWkILYhQ1Djpr{Kllx!|eb7s129{lUG#w}P()w*@z5GXVeq
z00000000000000000000000000000000000VAm=s42Q!dk==U3g7V_Ra9OydEE|-D
zOG@*xNO3+E8IUhiP*9RjEvU?=7E}}$mW9KSqI^(LSX5Y+t&u%uvkD7KOUuf$om2+n
zLcuG+Z-bu)KM1}NtPidUE(y*J(m``DKR7;{2><{90000000000000000000000000
z0000000000J62g3E)JK3it2{ft$+T(ihQ&<AH8hK;sN<+Q9io-@h5l7M+<wSSDjU!
zk4Ac<3*IQpM+@@N?q@fYRuq;MhkIk!Pb;n{3~h>Scws^1R<VKs*;rX$Y)jUv_PZln
zV$1JbSF$CxZ0x|I&9PC}-?y%?JbN*v!S$iwPr>uSlffgweZjYbuVfPd0000000000
z0000000000000000000000000007|sHv=NY;ZW$c(eqDuWOzwmWb7|*{%mo1q$oUW
zuh0Bxa$`~NY0FR7on6>_dPG^#MUmdqeV#wy+S0N}QQ5G)B47OJk-dqL6Yuz1L3y_M
z(qKg>cq#aG@Z;cH!Iy%of{U^V000000000000000000000000000000000000002+
z|H2-TA>ppf#1V<6lVdHNlV?S832l=WOs=n;J!M7h#1%!kgv5mIruN3!;~LW~%L;M{
z&C~1V9N(~VS<9ljj?!GhDP!iRCr@sfHFNfo5hb~VSq&{s=@VzouAjcLzBrd~;%VbL
z#-Fxg?))*WCl&4<8B#W8+V~Mm=B_v{wQS{S<=LTB278Bs7lVz#1Hm_gTY@WtwZV#D
zad1j-d@v?BG@A(k000000000000000000000000000000000000Kogv9+4s8?%5}&
zCnXb!*{zFD7?4Zo>S#%{#hV**igF2=bj!Sk+S=CEla{wu<P(y~wuP}&zC<LS5L=XP
z+@vs<ke)Dk(d@a&C8^rB3B|idhLoj}$xL5~T!Hp@M^|6GAeV4jX5Q#|i^nf%TfVrx
zB$sgVq~^@Tg)>uA;xk%y%Oy;l*mdfnx@l7z=FEv#<`O0}#p0)&vh?_dIpe03<r2nC
zORQ)+ZA5a(yt)bHxrDmTx&<?rw2ocb+`O=~Ja@%wcJYh@00000000000000000000
z000000000000000006))R-QYo*~NnZ00000000000000000000000000000000000
z004kptUUXP1iudjZw9Yq0{{R300000000000000000000000000000000000_!n1F
W7!HRk3L^P%KtVxKVYsX;^1lH_jT}M%
--- a/toolkit/components/places/tests/migration/xpcshell.ini
+++ b/toolkit/components/places/tests/migration/xpcshell.ini
@@ -15,16 +15,17 @@ support-files =
   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
 
 [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]
--- a/toolkit/components/places/tests/unit/test_async_transactions.js
+++ b/toolkit/components/places/tests/unit/test_async_transactions.js
@@ -676,21 +676,22 @@ add_task(function* test_remove_folder() 
   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")
-      , TAG_1 = "TestTag1", TAG_2 = "TestTag2"
-      , KEYWORD = "test_keyword"
-      , POST_DATA = "post_data"
-      , ANNO = { name: "TestAnno", value: "TestAnnoValue" };
+  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] };
@@ -744,28 +745,37 @@ add_task(function* test_add_and_remove_b
   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(...b2_post_creation_changes);
+  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();
@@ -1016,38 +1026,108 @@ add_task(function* test_edit_keyword() {
     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 }).transact();
+  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");
 
--- a/toolkit/components/places/tests/unit/test_keywords.js
+++ b/toolkit/components/places/tests/unit/test_keywords.js
@@ -508,11 +508,29 @@ add_task(function* test_oldKeywordsAPI()
   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();
 });
 
-function run_test() {
-  run_next_test();
-}
+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
+});
--- a/toolkit/components/places/tests/unit/test_placesTxn.js
+++ b/toolkit/components/places/tests/unit/test_placesTxn.js
@@ -550,16 +550,50 @@ add_task(function* test_edit_keyword() {
 
   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,