Merge lp:~jamesh/bindwood/recording-observer into lp:bindwood

[James Henstridge]

Add a bookmark observer implementation that just records the GUIDs of changed items.

This is part of the refactoring work on Bindwood. Rather than directly updating CouchDB as bookmarks change, I want to delay those updates so they can be done together with the main synchronisation process.

This branch includes a new bookmarks observer implementation that simply records the GUIDs of changed items as the bookmarks change. Unlike the existing Bindwood schema, I want to store parent GUID references with bookmarks, so reparenting a bookmark should imply that the bookmark has changed, rather than just its parent.

The observer depends on another object to handle the local ID -> GUID mapping, which is not included in this branch: that will come later. For now, I've just worked with a fake implementation in the tests that derives GUIDs from local IDs in a simple way.

[Eric Casteleijn (thisfred)]

review: Approve

[Zachery Bir (urbanape)]

This looks great

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The prerequisite lp:~jamesh/bindwood/refactor-desktopcouch-access has not yet been merged into lp:bindwood.

=== added file 'modules/sync.jsm'
--- modules/sync.jsm	1970-01-01 00:00:00 +0000
+++ modules/sync.jsm	2011-02-11 03:41:22 +0000
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2009-2011 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+const EXPORTED_SYMBOLS = ["BookmarksObserver"];
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+
+var bookmarksService = Cc["@mozilla.org/browser/nav-bookmarks-service;1"]
+    .getService(Ci.nsINavBookmarksService);
+var livemarkService = Cc["@mozilla.org/browser/livemark-service;2"]
+    .getService(Ci.nsILivemarkService);
+var annotationService = Cc["@mozilla.org/browser/annotation-service;1"]
+    .getService(Ci.nsIAnnotationService);
+
+
+function BookmarksObserver(sync) {
+    this.sync = sync;
+    this.changed_guids = {}
+}
+
+BookmarksObserver.prototype = {
+    QueryInterface: function(iid) {
+        if (iid.equals(Ci.nsINavBookmarkObserver) ||
+            iid.equals(Ci.nsINavBookmarkObserver_MOZILLA_1_9_1_ADDITIONS) ||
+            iid.equals(Ci.nsISupports)) {
+            return this;
+        }
+        throw Cr.NS_ERROR_NO_INTERFACE;
+    },
+
+    should_ignore: function(item_id, folder_id) {
+        if (arguments.length < 2) {
+            folder_id = bookmarksService.getFolderIdForItem(item_id);
+        }
+        // Ignore children of Livemarks, since they are automatically
+        // created.
+        if (livemarkService.isLivemark(folder_id)) {
+            return true;
+        }
+        // XXX: Should also verify that the item is a child of a
+        // folder we care about.
+        return false;
+    },
+
+    record_change: function(item_id) {
+        var guid = this.sync.guid_from_id(item_id);
+        this.changed_guids[guid] = true;
+    },
+
+    clear_changes: function() {
+        this.changed_guids = {};
+    },
+
+    onItemAdded: function(item_id, folder_id, child_index) {
+        if (this.should_ignore(item_id, folder_id))
+            return;
+
+        // The parent folder is modified, since its child list has
+        // changed.
+        this.record_change(item_id);
+        this.record_change(folder_id);
+    },
+
+    onBeforeItemRemoved: function(item_id) {
+        folder_id = bookmarksService.getFolderIdForItem(item_id);
+        if (this.should_ignore(item_id, folder_id))
+            return;
+        this.record_change(item_id);
+        this.record_change(folder_id);
+    },
+
+    onItemChanged: function(item_id, property, is_annotation, value) {
+        if (this.should_ignore(item_id))
+            return;
+
+        // XXX: We could optimise the list of property changes we
+        // respond to like Firefox Sync here.
+
+        // Ignore icon changes.
+        if (property == "favicon")
+            return;
+
+        this.record_change(item_id);
+    },
+
+    onItemMoved: function(item_id, old_parent, old_index,
+                          new_parent, new_index) {
+        if (this.should_ignore(item_id, new_parent))
+            return;
+
+        this.record_change(old_parent);
+        if (old_parent != new_parent) {
+            // The item has been moved to a different folder, rather
+            // than just to a new position within the same folder.
+            this.record_change(item_id);
+            this.record_change(new_parent);
+        }
+    },
+
+    // Currently unhandled
+    onBeginUpdateBatch: function() {},
+    onEndUpdateBatch: function() {},
+    onItemVisited: function(aBookmarkId, aVisitID, time) {},
+};

=== modified file 'mozmill/shared-modules/bookmarks.js'
--- mozmill/shared-modules/bookmarks.js	2011-02-11 03:41:22 +0000
+++ mozmill/shared-modules/bookmarks.js	2011-02-11 03:41:22 +0000
@@ -42,5 +42,6 @@
 }
 
 exports.bookmarksService = bookmarksService;
+exports.livemarkService = livemarkService;
 exports.createURI = createURI;
 exports.clearBookmarks = clearBookmarks;

=== added file 'mozmill/test-files/feed.atom'
--- mozmill/test-files/feed.atom	1970-01-01 00:00:00 +0000
+++ mozmill/test-files/feed.atom	2011-02-11 03:41:22 +0000
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <id>urn:uuid:518ac9fe-646b-42de-8e80-4d7372f15d00</id>
+  <title>Example feed</title>
+  <link href="http://www.example.com/"/>
+  <updated>2011-02-11T02:30:00Z</updated>
+  <author>
+    <name>Joe Smith</name>
+  </author>
+
+  <entry>
+    <id>urn:uuid:314128f7-542d-44b8-91cd-4f03ad5bddf1</id>
+    <title>Feed item</title>
+    <link href="test.html"/>
+    <updated>2011-02-11T02:30:00Z</updated>
+    <summary>Feed item description</summary>
+  </entry>
+</feed>

=== added file 'mozmill/tests/test_sync_observer.js'
--- mozmill/tests/test_sync_observer.js	1970-01-01 00:00:00 +0000
+++ mozmill/tests/test_sync_observer.js	2011-02-11 03:41:22 +0000
@@ -0,0 +1,150 @@
+var bm = require("../shared-modules/bookmarks");
+
+const TIMEOUT = 5000;
+
+const LOCAL_TEST_FOLDER = collector.addHttpResource('../test-files/');
+const LOCAL_TEST_PAGE = LOCAL_TEST_FOLDER + 'test.html';
+const LOCAL_TEST_FEED = LOCAL_TEST_FOLDER + 'feed.atom';
+
+var setupModule = function(module) {
+    module.controller = mozmill.getBrowserController();
+    module.jum = {}
+    module.sync = {}
+    module.fake_synchroniser = {
+        guid_from_id: function (item_id) {
+            return "guid:" + item_id;
+        }
+    }
+    module.observer = null;
+    Cu.import("resource://mozmill/modules/jum.js", module.jum);
+    Cu.import("resource://bindwood/sync.jsm", module.sync);
+};
+
+
+var setupTest = function(test) {
+    observer = new sync.BookmarksObserver(fake_synchroniser);
+    bm.bookmarksService.addObserver(observer, false);
+};
+
+var teardownTest = function(test) {
+    bm.bookmarksService.removeObserver(observer);
+    bm.clearBookmarks();
+};
+
+var testQueryInterface = function() {
+    jum.assertEquals(
+        observer.QueryInterface(Ci.nsISupports), observer);
+    jum.assertEquals(
+        observer.QueryInterface(Ci.nsINavBookmarkObserver), observer);
+    if (Ci.nsINavBookmarkObserver_MOZILLA_1_9_1_ADDITIONS) {
+        jum.assertEquals(
+            observer.QueryInterface(Ci.nsINavBookmarkObserver_MOZILLA_1_9_1_ADDITIONS), observer);
+    }
+};
+
+var assertChanged = function (item_id) {
+    var guid = fake_synchroniser.guid_from_id(item_id);
+    return observer.changed_guids[guid] != null;
+};
+
+var assertNotChanged = function (item_id) {
+    var guid = fake_synchroniser.guid_from_id(item_id);
+    return observer.changed_guids[guid] == null;
+};
+
+var testClearChanges = function() {
+    var dummy_id = 42;
+    observer.record_change(dummy_id);
+    assertChanged(dummy_id);
+    observer.clear_changes(dummy_id);
+    assertNotChanged(dummy_id);
+};
+
+var testAddBookmark = function() {
+    var bookmark_id = bm.bookmarksService.insertBookmark(
+        bm.bookmarksService.toolbarFolder,
+        bm.createURI(LOCAL_TEST_PAGE),
+        bm.bookmarksService.DEFAULT_INDEX,
+        "Bookmark title");
+    assertChanged(bookmark_id);
+    assertChanged(bm.bookmarksService.toolbarFolder);
+};
+
+var testRemoveBookmark = function() {
+    var bookmark_id = bm.bookmarksService.insertBookmark(
+        bm.bookmarksService.toolbarFolder,
+        bm.createURI(LOCAL_TEST_PAGE),
+        bm.bookmarksService.DEFAULT_INDEX,
+        "Bookmark title");
+    observer.clear_changes();
+
+    bm.bookmarksService.removeItem(bookmark_id);
+    assertChanged(bookmark_id);
+    assertChanged(bm.bookmarksService.toolbarFolder);
+};
+
+var testMoveBookmarkSameFolder = function() {
+    var folder_id = bm.bookmarksService.createFolder(
+        bm.bookmarksService.toolbarFolder,
+        "Folder", bm.bookmarksService.DEFAULT_INDEX);
+    var bookmark1_id = bm.bookmarksService.insertBookmark(
+        folder_id, bm.createURI(LOCAL_TEST_PAGE + "#one"),
+        bm.bookmarksService.DEFAULT_INDEX, "Bookmark 1");
+    var bookmark2_id = bm.bookmarksService.insertBookmark(
+        folder_id, bm.createURI(LOCAL_TEST_PAGE + "#two"),
+        bm.bookmarksService.DEFAULT_INDEX, "Bookmark 2");
+    observer.clear_changes();
+
+    // If we move a bookmark within the same folder (i.e. no parent
+    // change), then only the parent folder has changed.
+    bm.bookmarksService.moveItem(bookmark2_id, folder_id, 0);
+    assertChanged(folder_id);
+    assertNotChanged(bookmark2_id);
+};
+
+var testMoveBookmarkDifferentFolder = function() {
+    var folder1_id = bm.bookmarksService.createFolder(
+        bm.bookmarksService.toolbarFolder,
+        "Folder 1", bm.bookmarksService.DEFAULT_INDEX);
+    var folder2_id = bm.bookmarksService.createFolder(
+        bm.bookmarksService.toolbarFolder,
+        "Folder 2", bm.bookmarksService.DEFAULT_INDEX);
+    var bookmark_id = bm.bookmarksService.insertBookmark(
+        folder1_id, bm.createURI(LOCAL_TEST_PAGE),
+        bm.bookmarksService.DEFAULT_INDEX, "Bookmark");
+    observer.clear_changes();
+
+    bm.bookmarksService.moveItem(
+        bookmark_id, folder2_id, bm.bookmarksService.DEFAULT_INDEX);
+    // The item is changed because it has a new parent.  The two
+    // folders have changed because their child lists have changed.
+    assertChanged(bookmark_id);
+    assertChanged(folder1_id);
+    assertChanged(folder2_id);
+};
+
+var testLivemarkChildrenIgnored = function() {
+    var livemark_id = bm.livemarkService.createLivemark(
+        bm.bookmarksService.toolbarFolder,
+        "Test Feed",
+        bm.createURI("http://www.example.com/"),
+        bm.createURI(LOCAL_TEST_FEED),
+        bm.bookmarksService.DEFAULT_INDEX);
+
+    // Wait for the livemark to load, then check that it has been
+    // loaded correctly.
+    var livemark_child_id;
+    controller.waitFor(function() {
+            livemark_child_id = bm.bookmarksService.getIdForItemAt(
+                livemark_id, 0);
+            return livemark_child_id >= 0;
+        }, TIMEOUT);
+    var livemark_child_uri = bm.bookmarksService.getBookmarkURI(
+        livemark_child_id);
+    jum.assertEquals(livemark_child_uri.spec, LOCAL_TEST_PAGE);
+
+    // Only the livemark itself is recorded as changed: the children
+    // are ignored.
+    assertChanged(livemark_id);
+    assertNotChanged(livemark_child_id);
+}