libtracker-miner: Add ownership tracking to Tracker indexing configsam/index-mount-points-2

The TrackerIndexingTree class keeps track of each directory or file that
has been explicitly selected for indexing and monitoring.

As a new feature, we want to allow any application to add to the list of
directories being indexed and monitored, and to later be able to remove
things from the list again. Previously, the tracker-miner-fs process was
totally in control of what went in the IndexingTree.

In order to ensure that applications can't interfere with the
existing configuration, we need to track *who* added something to the
indexing tree. This is done with a string identifier.

The tracker_miner_fs_directory_add() functions now take an 'owner'
parameter so they can keep track of who is interested in each configured
indexing root. The tracker_miner_fs_ignore() function lets a given owner
that previously expressed interest in an indexing root now say that they
are not interested. If that indexing root has no 'owners' left, it is
deleted from the TrackerIndexingTree, which cancels any running indexing
tasks and removes any monitors.

We need to make sure that nobody can claim the internal
'tracker-miner-fs' ID through the external API -- that would make it
possible to override the internal configuration.

13 files changed, 518 insertions, 240 deletions

diff --git a/examples/libtracker-miner/tracker-main.c b/examples/libtracker-miner/tracker-main.c
index a6699c7f1..07568c76e 100644
--- a/examples/libtracker-miner/tracker-main.c
+++ b/examples/libtracker-miner/tracker-main.c
@@ -183,7 +183,7 @@ add_directory_path (TrackerMinerFS *fs,
 	GFile *file;
 
 	file = g_file_new_for_path (path);
-	tracker_miner_fs_directory_add (fs, file, recurse);
+	tracker_miner_fs_directory_add (fs, file, recurse, "tracker-miner-example");
 	g_object_unref (file);
 }
 
diff --git a/src/libtracker-miner/tracker-indexing-tree.c b/src/libtracker-miner/tracker-indexing-tree.c
index 9a270f6e1..912887d76 100644
--- a/src/libtracker-miner/tracker-indexing-tree.c
+++ b/src/libtracker-miner/tracker-indexing-tree.c
@@ -33,15 +33,23 @@
 G_DEFINE_TYPE (TrackerIndexingTree, tracker_indexing_tree, G_TYPE_OBJECT)
 
 typedef struct _TrackerIndexingTreePrivate TrackerIndexingTreePrivate;
+typedef struct _NodeOwnerData NodeOwnerData;
 typedef struct _NodeData NodeData;
 typedef struct _PatternData PatternData;
 typedef struct _FindNodeData FindNodeData;
 
+struct _NodeOwnerData
+{
+	char *name;
+	guint flags;
+};
+
 struct _NodeData
 {
 	GFile *file;
 	guint flags;
 	guint shallow : 1;
+	GList *owners;
 };
 
 struct _PatternData
@@ -83,16 +91,46 @@ enum {
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
+static NodeOwnerData *
+node_owner_data_new (const char *name,
+                     guint       flags)
+{
+	NodeOwnerData *data;
+
+	data = g_slice_new (NodeOwnerData);
+	data->name = g_strdup(name);
+	data->flags = flags;
+
+	return data;
+}
+
+static void
+node_owner_data_free (NodeOwnerData *data) {
+	g_free (data->name);
+	g_slice_free (NodeOwnerData, data);
+}
+
+static gint node_owner_match (NodeOwnerData *owner_data,
+                              const gchar   *target_name)
+{
+	return g_strcmp0 (owner_data->name, target_name);
+}
+
 static NodeData *
-node_data_new (GFile *file,
-               guint  flags)
+node_data_new (GFile      *file,
+               guint       flags,
+               const char *initial_owner)
 {
 	NodeData *data;
+	NodeOwnerData *owner;
+
+	owner = node_owner_data_new(initial_owner, flags);
 
 	data = g_slice_new (NodeData);
 	data->file = g_object_ref (file);
 	data->flags = flags;
 	data->shallow = FALSE;
+	data->owners = g_list_prepend(NULL, owner);
 
 	return data;
 }
@@ -100,6 +138,7 @@ node_data_new (GFile *file,
 static void
 node_data_free (NodeData *data)
 {
+	/* Assuming owners have all already been freed. */
 	g_object_unref (data->file);
 	g_slice_free (NodeData, data);
 }
@@ -112,6 +151,53 @@ node_free (GNode    *node,
 	return FALSE;
 }
 
+static guint
+node_get_flags (NodeData *data)
+{
+	/* Return the combined flags for all owners. */
+	guint flags = 0;
+	GList *node;
+	NodeOwnerData *owner_data;
+
+	for (node = data->owners; node; node = node->next) {
+		owner_data = node->data;
+		flags |= owner_data->flags;
+	};
+
+	if (flags & TRACKER_DIRECTORY_FLAG_IGNORE) {
+		/* The IGNORE flag can only be set by the user's configuration. So this
+		 * should override anything specified by apps through the IndexFile D-Bus
+		 * method.
+		 */
+		flags &= ~TRACKER_DIRECTORY_FLAG_MONITOR;
+	}
+
+	return flags;
+}
+
+/* Update the flags for a node. Used when an owner has been added or removed. */
+static void
+node_update_flags (TrackerIndexingTree *tree,
+                   NodeData *node_data)
+{
+	guint new_flags;
+
+	new_flags = node_get_flags (node_data);
+
+	if (node_data->flags != new_flags) {
+		gchar *uri;
+
+		uri = g_file_get_uri (node_data->file);
+		g_message ("Updating flags for directory '%s'", uri);
+		g_free (uri);
+
+		node_data->flags = new_flags;
+
+		g_signal_emit (tree, signals[DIRECTORY_UPDATED], 0,
+		               node_data->file);
+	}
+}
+
 static PatternData *
 pattern_data_new (const gchar *glob_string,
                   guint        type)
@@ -206,7 +292,7 @@ tracker_indexing_tree_constructed (GObject *object)
 		priv->root = g_file_new_for_uri ("file:///");
 	}
 
-	data = node_data_new (priv->root, 0);
+	data = node_data_new (priv->root, 0, "TrackerIndexingTree");
 	data->shallow = TRUE;
 
 	priv->config_tree = g_node_new (data);
@@ -474,14 +560,20 @@ check_reparent_node (GNode    *node,
  * @tree: a #TrackerIndexingTree
  * @directory: #GFile pointing to a directory
  * @flags: Configuration flags for the directory
+ * @owner: Unique string identifying the 'owner' of this indexing root
  *
  * Adds a directory to the indexing tree with the
  * given configuration flags.
+ *
+ * If the directory is already in the indexing tree, @owner is added to the
+ * list of owners, which ensures that the directory will not be removed until
+ * tracker_indexing_tree_remove() is called with the same @owner.
  **/
 void
 tracker_indexing_tree_add (TrackerIndexingTree   *tree,
                            GFile                 *directory,
-                           TrackerDirectoryFlags  flags)
+                           TrackerDirectoryFlags  flags,
+                           const char            *owner)
 {
 	TrackerIndexingTreePrivate *priv;
 	GNode *parent, *node;
@@ -499,18 +591,13 @@ tracker_indexing_tree_add (TrackerIndexingTree   *tree,
 		data = node->data;
 		data->shallow = FALSE;
 
-		/* Overwrite flags if they are different */
-		if (data->flags != flags) {
-			gchar *uri;
+		/* Add owner. */
+		data->owners = g_list_prepend(data->owners,
+		                              node_owner_data_new(owner, flags));
 
-			uri = g_file_get_uri (directory);
-			g_message ("Overwriting flags for directory '%s'", uri);
-			g_free (uri);
+		/* Overwrite flags if they are different */
+		node_update_flags (tree, data);
 
-			data->flags = flags;
-			g_signal_emit (tree, signals[DIRECTORY_UPDATED], 0,
-			               data->file);
-		}
 		return;
 	}
 
@@ -521,7 +608,7 @@ tracker_indexing_tree_add (TrackerIndexingTree   *tree,
 	/* Create node, move children of parent that
 	 * could be children of this new node now.
 	 */
-	data = node_data_new (directory, flags);
+	data = node_data_new (directory, flags, owner);
 	node = g_node_new (data);
 
 	g_node_children_foreach (parent, G_TRAVERSE_ALL,
@@ -542,19 +629,25 @@ tracker_indexing_tree_add (TrackerIndexingTree   *tree,
  * tracker_indexing_tree_remove:
  * @tree: a #TrackerIndexingTree
  * @directory: #GFile pointing to a directory
+ * @owner: Unique string identifying the 'owner' of this indexing root
+ *
+ * Removes @owner from the list of owners of the @directory indexing root.
+ * If there are no longer any owners, @directory is removed from the indexing
+ * tree.
  *
- * Removes @directory from the indexing tree, note that
- * only directories previously added with tracker_indexing_tree_add()
- * can be effectively removed.
+ * Note that only directories previously added with
+ * tracker_indexing_tree_add() can be removed in this way.
  **/
 void
 tracker_indexing_tree_remove (TrackerIndexingTree *tree,
-                              GFile               *directory)
+                              GFile               *directory,
+                              const char          *owner)
 {
 	TrackerIndexingTreePrivate *priv;
 	GNode *node, *parent;
 	NodeData *data;
 	GFile *file;
+	GList *owner_list_item;
 
 	g_return_if_fail (TRACKER_IS_INDEXING_TREE (tree));
 	g_return_if_fail (G_IS_FILE (directory));
@@ -568,27 +661,44 @@ tracker_indexing_tree_remove (TrackerIndexingTree *tree,
 
 	data = node->data;
 
-	if (!node->parent) {
-		/* Node is the config tree
-		 * root, mark as shallow again
-		 */
-		data->shallow = TRUE;
+	owner_list_item = g_list_find_custom (data->owners, owner,
+	                                      (GCompareFunc)node_owner_match);
+
+	if (!owner_list_item) {
+		g_warning ("Unknown owner %s", owner);
 		return;
 	}
 
-	file = g_object_ref (data->file);
-	parent = node->parent;
-	g_node_unlink (node);
+	node_owner_data_free (owner_list_item->data);
+	data->owners = g_list_remove_link(data->owners, owner_list_item);
+
+	if (g_list_length(data->owners) == 0) {
+		/* No more owners: actually do the removal. */
+		if (!node->parent) {
+			/* Node is the config tree
+			* root, mark as shallow again
+			*/
+			data->shallow = TRUE;
+			return;
+		}
 
-	/* Move children to parent */
-	g_node_children_foreach (node, G_TRAVERSE_ALL,
-	                         check_reparent_node, parent);
+		file = g_object_ref (data->file);
+		parent = node->parent;
+		g_node_unlink (node);
 
-	node_data_free (node->data);
-	g_node_destroy (node);
+		/* Move children to parent */
+		g_node_children_foreach (node, G_TRAVERSE_ALL,
+		                         check_reparent_node, parent);
+
+		node_data_free (node->data);
+		g_node_destroy (node);
 
-	g_signal_emit (tree, signals[DIRECTORY_REMOVED], 0, file);
-	g_object_unref (file);
+		g_signal_emit (tree, signals[DIRECTORY_REMOVED], 0, file);
+		g_object_unref (file);
+	} else {
+		/* Update the flags. */
+		node_update_flags (tree, node->data);
+	}
 }
 
 /**
diff --git a/src/libtracker-miner/tracker-indexing-tree.h b/src/libtracker-miner/tracker-indexing-tree.h
index a5691675a..8db14a6ed 100644
--- a/src/libtracker-miner/tracker-indexing-tree.h
+++ b/src/libtracker-miner/tracker-indexing-tree.h
@@ -83,9 +83,11 @@ TrackerIndexingTree * tracker_indexing_tree_new_with_root (GFile            *roo
 
 void      tracker_indexing_tree_add                  (TrackerIndexingTree   *tree,
                                                       GFile                 *directory,
-                                                      TrackerDirectoryFlags  flags);
+                                                      TrackerDirectoryFlags  flags,
+                                                      const char            *owner);
 void      tracker_indexing_tree_remove               (TrackerIndexingTree   *tree,
-                                                      GFile                 *directory);
+                                                      GFile                 *directory,
+                                                      const char            *owner);
 
 void      tracker_indexing_tree_add_filter           (TrackerIndexingTree  *tree,
                                                       TrackerFilterType     filter,
diff --git a/src/libtracker-miner/tracker-miner-fs.c b/src/libtracker-miner/tracker-miner-fs.c
index 4732a575a..6d554c2d8 100644
--- a/src/libtracker-miner/tracker-miner-fs.c
+++ b/src/libtracker-miner/tracker-miner-fs.c
@@ -3210,6 +3210,7 @@ file_equal_or_descendant (GFile *file,
  * @fs: a #TrackerMinerFS
  * @file: #GFile for the directory to inspect
  * @recurse: whether the directory should be inspected recursively
+ * @owner: a short string identifying who 'owns' this request
  *
  * Tells the filesystem miner to inspect a directory.
  *
@@ -3218,7 +3219,8 @@ file_equal_or_descendant (GFile *file,
 void
 tracker_miner_fs_directory_add (TrackerMinerFS *fs,
                                 GFile          *file,
-                                gboolean        recurse)
+                                gboolean        recurse,
+                                const gchar    *owner)
 {
 	TrackerDirectoryFlags flags = TRACKER_DIRECTORY_FLAG_NONE;
 
@@ -3239,7 +3241,8 @@ tracker_miner_fs_directory_add (TrackerMinerFS *fs,
 
 	tracker_indexing_tree_add (fs->priv->indexing_tree,
 	                           file,
-	                           flags);
+	                           flags,
+	                           owner);
 }
 
 static void
@@ -3353,7 +3356,7 @@ tracker_miner_fs_directory_remove (TrackerMinerFS *fs,
 	}
 
 	g_debug ("Removing directory");
-	tracker_indexing_tree_remove (priv->indexing_tree, file);
+	tracker_indexing_tree_remove (priv->indexing_tree, file, "FIXME: owner");
 
 	return TRUE;
 }
@@ -3631,6 +3634,7 @@ tracker_miner_fs_check_file (TrackerMinerFS *fs,
  * @file: #GFile for the directory to check
  * @priority: the priority of the check task
  * @check_parents: whether to check parents and eligibility or not
+ * @owner: a short string identifying who 'owns' this request
  *
  * Tells the filesystem miner to check and index a directory at
  * a given priority, this file must be part of the usual crawling
@@ -3642,7 +3646,8 @@ void
 tracker_miner_fs_check_directory_with_priority (TrackerMinerFS *fs,
                                                 GFile          *file,
                                                 gint            priority,
-                                                gboolean        check_parents)
+                                                gboolean        check_parents,
+                                                const gchar    *owner)
 {
 	gboolean should_process = TRUE;
 	gchar *uri;
@@ -3679,7 +3684,7 @@ tracker_miner_fs_check_directory_with_priority (TrackerMinerFS *fs,
 			flags |= TRACKER_DIRECTORY_FLAG_PRIORITY;
 
 		tracker_indexing_tree_add (fs->priv->indexing_tree,
-		                           file, flags);
+		                           file, flags, owner);
 	}
 
 	g_free (uri);
@@ -3690,6 +3695,7 @@ tracker_miner_fs_check_directory_with_priority (TrackerMinerFS *fs,
  * @fs: a #TrackerMinerFS
  * @file: #GFile for the directory to check
  * @check_parents: whether to check parents and eligibility or not
+ * @owner: a short string identifying who 'owns' this request
  *
  * Tells the filesystem miner to check and index a directory,
  * this file must be part of the usual crawling directories
@@ -3700,11 +3706,37 @@ tracker_miner_fs_check_directory_with_priority (TrackerMinerFS *fs,
 void
 tracker_miner_fs_check_directory (TrackerMinerFS *fs,
                                   GFile          *file,
-                                  gboolean        check_parents)
+                                  gboolean        check_parents,
+                                  const gchar    *owner)
 {
 	tracker_miner_fs_check_directory_with_priority (fs, file,
 	                                                G_PRIORITY_HIGH,
-	                                                check_parents);
+	                                                check_parents,
+	                                                owner);
+}
+
+/**
+ * tracker_miner_fs_unwatch:
+ * @fs: a #TrackerMinerFS
+ * @file: #GFile for the file or directory to ignore
+ * @owner: the owner string that was given when the directory was added for indexing
+ *
+ * Tells the filesystem miner that @owner is no longer interested in @file.
+ * This can be used for files or directories added with
+ * tracker_miner_fs_check_file() or tracker_miner_fs_check_directory().
+ *
+ * The metadata for @file and its contents is *not* removed from the Tracker
+ * database. You can use tracker_miner_fs_remove() for this if you are
+ * *certain* nothing else is interested in the data.
+ *
+ * Since: 1.6
+ **/
+void
+tracker_miner_fs_unwatch (TrackerMinerFS *fs,
+                          GFile          *file,
+                          const gchar    *owner)
+{
+	tracker_indexing_tree_remove (fs->priv->indexing_tree, file, owner);
 }
 
 /**
@@ -4066,7 +4098,8 @@ tracker_miner_fs_force_mtime_checking (TrackerMinerFS *fs,
 
 	tracker_indexing_tree_add (fs->priv->indexing_tree,
 	                           directory,
-	                           flags);
+	                           flags,
+	                           "FIXME: owner");
 }
 
 /**
@@ -4188,7 +4221,8 @@ tracker_miner_fs_add_directory_without_parent (TrackerMinerFS *fs,
 
 	tracker_indexing_tree_add (fs->priv->indexing_tree,
 	                           file,
-	                           flags);
+	                           flags,
+	                           "tracker-internal-owner");
 }
 #endif
 
diff --git a/src/libtracker-miner/tracker-miner-fs.h b/src/libtracker-miner/tracker-miner-fs.h
index e9fe48bea..45f75db91 100644
--- a/src/libtracker-miner/tracker-miner-fs.h
+++ b/src/libtracker-miner/tracker-miner-fs.h
@@ -151,7 +151,8 @@ void                  tracker_miner_fs_add_directory_without_parent
 
 void                  tracker_miner_fs_directory_add         (TrackerMinerFS  *fs,
                                                               GFile           *file,
-                                                              gboolean         recurse);
+                                                              gboolean         recurse,
+                                                              const gchar     *owner);
 gboolean              tracker_miner_fs_directory_remove      (TrackerMinerFS  *fs,
                                                               GFile           *file);
 gboolean              tracker_miner_fs_directory_remove_full (TrackerMinerFS  *fs,
@@ -170,12 +171,18 @@ void                  tracker_miner_fs_check_file_with_priority
                                                               gboolean         check_parents);
 void                  tracker_miner_fs_check_directory       (TrackerMinerFS  *fs,
                                                               GFile           *file,
-                                                              gboolean         check_parents);
+                                                              gboolean         check_parents,
+                                                              const gchar     *owner);
 void                  tracker_miner_fs_check_directory_with_priority
                                                              (TrackerMinerFS  *fs,
                                                               GFile           *file,
                                                               gint             priority,
-                                                              gboolean         check_parents);
+                                                              gboolean         check_parents,
+                                                              const gchar     *owner);
+
+void                  tracker_miner_fs_unwatch               (TrackerMinerFS  *fs,
+                                                              GFile           *file,
+                                                              const gchar     *owner);
 
 void                  tracker_miner_fs_force_recheck         (TrackerMinerFS  *fs);
 void                  tracker_miner_fs_writeback_file        (TrackerMinerFS  *fs,
diff --git a/src/miners/apps/tracker-miner-applications.c b/src/miners/apps/tracker-miner-applications.c
index a01d3dd3f..b89a71714 100644
--- a/src/miners/apps/tracker-miner-applications.c
+++ b/src/miners/apps/tracker-miner-applications.c
@@ -103,9 +103,10 @@ miner_applications_basedir_add (TrackerMinerFS *fs,
 	g_message ("  Adding:'%s'", path);
 
 	tracker_indexing_tree_add (indexing_tree, file,
-				   TRACKER_DIRECTORY_FLAG_RECURSE |
-				   TRACKER_DIRECTORY_FLAG_MONITOR |
-				   TRACKER_DIRECTORY_FLAG_CHECK_MTIME);
+	                           TRACKER_DIRECTORY_FLAG_RECURSE |
+	                           TRACKER_DIRECTORY_FLAG_MONITOR |
+	                           TRACKER_DIRECTORY_FLAG_CHECK_MTIME,
+	                           "tracker-miner-applications");
 	g_object_unref (file);
 	g_free (path);
 
@@ -114,9 +115,10 @@ miner_applications_basedir_add (TrackerMinerFS *fs,
 	file = g_file_new_for_path (path);
 	g_message ("  Adding:'%s'", path);
 	tracker_indexing_tree_add (indexing_tree, file,
-				   TRACKER_DIRECTORY_FLAG_RECURSE |
-				   TRACKER_DIRECTORY_FLAG_MONITOR |
-				   TRACKER_DIRECTORY_FLAG_CHECK_MTIME);
+	                           TRACKER_DIRECTORY_FLAG_RECURSE |
+	                           TRACKER_DIRECTORY_FLAG_MONITOR |
+	                           TRACKER_DIRECTORY_FLAG_CHECK_MTIME,
+	                           "tracker-miner-applications");
 	g_object_unref (file);
 	g_free (path);
 }
@@ -156,9 +158,10 @@ miner_applications_add_directories (TrackerMinerFS *fs)
 
 	file = g_file_new_for_path (path);
 	tracker_indexing_tree_add (indexing_tree, file,
-				   TRACKER_DIRECTORY_FLAG_RECURSE |
-				   TRACKER_DIRECTORY_FLAG_MONITOR |
-				   TRACKER_DIRECTORY_FLAG_CHECK_MTIME);
+	                           TRACKER_DIRECTORY_FLAG_RECURSE |
+	                           TRACKER_DIRECTORY_FLAG_MONITOR |
+	                           TRACKER_DIRECTORY_FLAG_CHECK_MTIME,
+	                           "tracker-miner-applications");
 	g_object_unref (file);
 #endif /* HAVE_MEEGOTOUCH */
 }
diff --git a/src/miners/fs/tracker-miner-files-index.c b/src/miners/fs/tracker-miner-files-index.c
index a4270415d..a2a6dc594 100644
--- a/src/miners/fs/tracker-miner-files-index.c
+++ b/src/miners/fs/tracker-miner-files-index.c
@@ -370,27 +370,22 @@ handle_method_call_index_file (TrackerMinerFilesIndex *miner,
 	if (is_dir) {
 		TrackerIndexingTree *indexing_tree;
 		TrackerDirectoryFlags flags;
-		gboolean is_watched, needs_watch = FALSE;
-		GFile *root;
+		const char *sender_name;
 
 		indexing_tree = tracker_miner_fs_get_indexing_tree (TRACKER_MINER_FS (priv->files_miner));
-		root = tracker_indexing_tree_get_root (indexing_tree, file, &flags);
-		is_watched = tracker_miner_files_peer_listener_is_file_watched (priv->peer_listener, file);
-
-		if (!root || !(flags & TRACKER_DIRECTORY_FLAG_RECURSE)) {
-			tracker_indexing_tree_add (indexing_tree, file,
-			                           TRACKER_DIRECTORY_FLAG_RECURSE |
-			                           TRACKER_DIRECTORY_FLAG_PRIORITY |
-			                           TRACKER_DIRECTORY_FLAG_CHECK_MTIME |
-			                           TRACKER_DIRECTORY_FLAG_MONITOR);
-			needs_watch = TRUE;
-		}
 
-		if (is_watched || needs_watch) {
-			tracker_miner_files_peer_listener_add_watch (priv->peer_listener,
-			                                             g_dbus_method_invocation_get_sender (invocation),
-			                                             file);
-		}
+		sender_name = g_dbus_method_invocation_get_sender (invocation);
+
+		flags = TRACKER_DIRECTORY_FLAG_RECURSE |
+		        TRACKER_DIRECTORY_FLAG_PRIORITY |
+		        TRACKER_DIRECTORY_FLAG_CHECK_MTIME |
+		        TRACKER_DIRECTORY_FLAG_MONITOR;
+
+		tracker_indexing_tree_add (indexing_tree, file, flags, sender_name);
+
+		tracker_miner_files_peer_listener_add_watch (priv->peer_listener,
+		                                             g_dbus_method_invocation_get_sender (invocation),
+		                                             file);
 	} else {
 		tracker_miner_fs_check_file (TRACKER_MINER_FS (priv->files_miner), file, do_checks);
 	}
@@ -428,25 +423,13 @@ handle_method_call (GDBusConnection       *connection,
 static void
 peer_listener_unwatch_file (TrackerMinerFilesPeerListener *listener,
                             GFile                         *file,
+                            const gchar                   *dbus_name,
                             gpointer                       user_data)
 {
 	TrackerMinerFilesIndexPrivate *priv;
-	TrackerIndexingTree *indexing_tree;
 
 	priv = TRACKER_MINER_FILES_INDEX_GET_PRIVATE (user_data);
-	indexing_tree = tracker_miner_fs_get_indexing_tree (TRACKER_MINER_FS (priv->files_miner));
-	tracker_indexing_tree_remove (indexing_tree, file);
-}
-
-static void
-indexing_tree_directory_remove (TrackerIndexingTree *indexing_tree,
-                                GFile               *file,
-                                gpointer             user_data)
-{
-	TrackerMinerFilesIndexPrivate *priv;
-
-	priv = TRACKER_MINER_FILES_INDEX_GET_PRIVATE (user_data);
-	tracker_miner_files_peer_listener_remove_file (priv->peer_listener, file);
+	tracker_miner_fs_unwatch (TRACKER_MINER_FS(priv->files_miner), file, dbus_name);
 }
 
 static GVariant *
@@ -490,7 +473,6 @@ tracker_miner_files_index_new (TrackerMinerFiles *miner_files)
 	GVariant *reply;
 	guint32 rval;
 	GError *error = NULL;
-	TrackerIndexingTree *indexing_tree;
 	GDBusInterfaceVTable interface_vtable = {
 		handle_method_call,
 		handle_get_property,
@@ -584,9 +566,5 @@ tracker_miner_files_index_new (TrackerMinerFiles *miner_files)
 	g_signal_connect (priv->peer_listener, "unwatch-file",
 	                  G_CALLBACK (peer_listener_unwatch_file), miner);
 
-	indexing_tree = tracker_miner_fs_get_indexing_tree (TRACKER_MINER_FS (miner_files));
-	g_signal_connect (indexing_tree, "directory-removed",
-	                  G_CALLBACK (indexing_tree_directory_remove), miner);
-
 	return (TrackerMinerFilesIndex *) miner;
 }
diff --git a/src/miners/fs/tracker-miner-files-peer-listener.c b/src/miners/fs/tracker-miner-files-peer-listener.c
index 1b5c293d1..6b36fc0a7 100644
--- a/src/miners/fs/tracker-miner-files-peer-listener.c
+++ b/src/miners/fs/tracker-miner-files-peer-listener.c
@@ -239,13 +239,13 @@ tracker_miner_files_peer_listener_class_init (TrackerMinerFilesPeerListenerClass
 		              G_OBJECT_CLASS_TYPE (object_class),
 		              G_SIGNAL_RUN_LAST, 0,
 		              NULL, NULL, NULL,
-		              G_TYPE_NONE, 1, G_TYPE_FILE);
+		              G_TYPE_NONE, 2, G_TYPE_FILE, G_TYPE_STRING);
 	signals[UNWATCH_FILE] =
 		g_signal_new ("unwatch-file",
 		              G_OBJECT_CLASS_TYPE (object_class),
 		              G_SIGNAL_RUN_LAST, 0,
 		              NULL, NULL, NULL,
-		              G_TYPE_NONE, 1, G_TYPE_FILE);
+		              G_TYPE_NONE, 2, G_TYPE_FILE, G_TYPE_STRING);
 }
 
 static void
@@ -271,7 +271,8 @@ tracker_miner_files_peer_listener_new (GDBusConnection *connection)
 
 static void
 unwatch_file (TrackerMinerFilesPeerListener *listener,
-              GFile                         *file)
+              GFile                         *file,
+              const char                    *dbus_name)
 {
 	TrackerMinerFilesPeerListenerPrivate *priv;
 
@@ -279,7 +280,7 @@ unwatch_file (TrackerMinerFilesPeerListener *listener,
 
 	g_object_ref (file);
 	g_hash_table_remove (priv->file_peers, file);
-	g_signal_emit (listener, signals[UNWATCH_FILE], 0, file);
+	g_signal_emit (listener, signals[UNWATCH_FILE], 0, file, dbus_name);
 	g_object_unref (file);
 }
 
@@ -313,7 +314,7 @@ tracker_miner_files_peer_listener_add_watch (TrackerMinerFilesPeerListener *list
 		file_data = file_peers_data_new (file);
 		g_hash_table_insert (priv->file_peers,
 		                     file_data->file, file_data);
-		g_signal_emit (listener, signals[WATCH_FILE], 0, file_data->file);
+		g_signal_emit (listener, signals[WATCH_FILE], 0, file_data->file, dbus_name);
 
 		uri = g_file_get_uri (file);
 		g_debug ("Client '%s' requests watch on '%s'", dbus_name, uri);
@@ -352,7 +353,7 @@ tracker_miner_files_peer_listener_remove_watch (TrackerMinerFilesPeerListener *l
 		g_hash_table_remove (priv->peer_files, peer_data->dbus_name);
 
 	if (file_data->peers->len == 0)
-		unwatch_file (listener, file_data->file);
+		unwatch_file (listener, file_data->file, peer_data->dbus_name);
 }
 
 void
@@ -386,52 +387,12 @@ tracker_miner_files_peer_listener_remove_dbus_name (TrackerMinerFilesPeerListene
 		file_peers_data_remove_dbus_name (file_data, peer_data->dbus_name);
 
 		if (file_data->peers->len == 0)
-			unwatch_file (listener, file_data->file);
+			unwatch_file (listener, file_data->file, peer_data->dbus_name);
 	}
 
 	g_hash_table_remove (priv->peer_files, dbus_name);
 }
 
-void
-tracker_miner_files_peer_listener_remove_file (TrackerMinerFilesPeerListener *listener,
-                                               GFile                         *file)
-{
-	TrackerMinerFilesPeerListenerPrivate *priv;
-	PeerFilesData *peer_data;
-	FilePeersData *file_data;
-	const gchar *dbus_name;
-	gchar *uri;
-	gint i;
-
-	g_return_if_fail (TRACKER_IS_MINER_FILES_PEER_LISTENER (listener));
-	g_return_if_fail (G_IS_FILE (file));
-
-	priv = tracker_miner_files_peer_listener_get_instance_private (listener);
-	file_data = g_hash_table_lookup (priv->file_peers, file);
-
-	if (!file_data || file_data->peers->len == 0)
-		return;
-
-	uri = g_file_get_uri (file);
-	g_debug ("Removing client listeners for file '%s'", uri);
-	g_free (uri);
-
-	for (i = 0; i < file_data->peers->len; i++) {
-		dbus_name = g_ptr_array_index (file_data->peers, i);
-		peer_data = g_hash_table_lookup (priv->peer_files, dbus_name);
-
-		if (!peer_data)
-			continue;
-
-		peer_files_data_remove_file (peer_data, file_data->file);
-
-		if (peer_data->files->len == 0)
-			g_hash_table_remove (priv->peer_files, dbus_name);
-	}
-
-	unwatch_file (listener, file);
-}
-
 gboolean
 tracker_miner_files_peer_listener_is_file_watched (TrackerMinerFilesPeerListener *listener,
                                                    GFile                         *file)
diff --git a/src/miners/fs/tracker-miner-files-peer-listener.h b/src/miners/fs/tracker-miner-files-peer-listener.h
index 7a23d328d..ee8d83033 100644
--- a/src/miners/fs/tracker-miner-files-peer-listener.h
+++ b/src/miners/fs/tracker-miner-files-peer-listener.h
@@ -57,8 +57,6 @@ void     tracker_miner_files_peer_listener_remove_watch (TrackerMinerFilesPeerLi
 
 void     tracker_miner_files_peer_listener_remove_dbus_name (TrackerMinerFilesPeerListener *listener,
                                                              const gchar                   *dbus_name);
-void     tracker_miner_files_peer_listener_remove_file      (TrackerMinerFilesPeerListener *listener,
-                                                             GFile                         *file);
 gboolean tracker_miner_files_peer_listener_is_file_watched  (TrackerMinerFilesPeerListener *listener,
                                                              GFile                         *file);
 
diff --git a/src/miners/fs/tracker-miner-files.c b/src/miners/fs/tracker-miner-files.c
index fb7445f36..bffcfe00c 100644
--- a/src/miners/fs/tracker-miner-files.c
+++ b/src/miners/fs/tracker-miner-files.c
@@ -421,7 +421,7 @@ miner_files_initable_init (GInitable     *initable,
 			flags |= TRACKER_DIRECTORY_FLAG_CHECK_MTIME;
 		}
 
-		tracker_indexing_tree_add (indexing_tree, file, flags);
+		tracker_indexing_tree_add (indexing_tree, file, flags, "tracker-miner-fs");
 		g_object_unref (file);
 	}
 
@@ -476,7 +476,7 @@ miner_files_initable_init (GInitable     *initable,
 			flags |= TRACKER_DIRECTORY_FLAG_CHECK_MTIME;
 		}
 
-		tracker_indexing_tree_add (indexing_tree, file, flags);
+		tracker_indexing_tree_add (indexing_tree, file, flags, "tracker-miner-fs");
 		g_object_unref (file);
 	}
 
@@ -1049,8 +1049,9 @@ init_mount_points (TrackerMinerFiles *miner_files)
 					file = g_file_new_for_path (mount_point);
 					if (tracker_miner_files_is_file_eligible (miner_files, file)) {
 						tracker_indexing_tree_add (indexing_tree,
-									   file,
-									   flags);
+						                           file,
+						                           flags,
+						                           "tracker-miner-fs");
 					}
 					g_object_unref (file);
 				}
@@ -1159,7 +1160,7 @@ mount_point_removed_cb (TrackerStorage *storage,
 	/* Tell TrackerMinerFS to skip monitoring everything under the mount
 	 *  point (in case there was no pre-unmount notification) */
 	indexing_tree = tracker_miner_fs_get_indexing_tree (TRACKER_MINER_FS (miner));
-	tracker_indexing_tree_remove (indexing_tree, mount_point_file);
+	tracker_indexing_tree_remove (indexing_tree, mount_point_file, "tracker-miner-fs");
 
 	/* Set mount point status in tracker-store */
 	set_up_mount_point (miner, urn, mount_point, NULL, FALSE, NULL);
@@ -1224,8 +1225,9 @@ mount_point_added_cb (TrackerStorage *storage,
 				g_message ("  Re-check of configured path '%s' needed (recursively)",
 				           (gchar *) l->data);
 				tracker_indexing_tree_add (indexing_tree,
-							   config_file,
-							   flags);
+				                           config_file,
+				                           flags,
+				                           "tracker-miner-fs");
 			} else if (g_file_has_prefix (mount_point_file, config_file)) {
 				/* If the mount path is contained inside the config path,
 				 *  then add the mount path to re-check */
@@ -1233,8 +1235,9 @@ mount_point_added_cb (TrackerStorage *storage,
 				           mount_point,
 				           (gchar *) l->data);
 				tracker_indexing_tree_add (indexing_tree,
-							   config_file,
-							   flags);
+				                           config_file,
+				                           flags,
+				                           "tracker-miner-fs");
 			}
 			g_object_unref (config_file);
 		}
@@ -1258,8 +1261,9 @@ mount_point_added_cb (TrackerStorage *storage,
 				g_message ("  Re-check of configured path '%s' needed (non-recursively)",
 				           (gchar *) l->data);
 				tracker_indexing_tree_add (indexing_tree,
-							   config_file,
-							   flags);
+				                           config_file,
+				                           flags,
+				                           "tracker-miner-fs");
 			}
 			g_object_unref (config_file);
 		}
@@ -1434,7 +1438,7 @@ mount_pre_unmount_cb (GVolumeMonitor    *volume_monitor,
 	g_message ("Pre-unmount requested for '%s'", uri);
 
 	indexing_tree = tracker_miner_fs_get_indexing_tree (TRACKER_MINER_FS (mf));
-	tracker_indexing_tree_remove (indexing_tree, mount_root);
+	tracker_indexing_tree_remove (indexing_tree, mount_root, "tracker-miner-fs");
 	g_object_unref (mount_root);
 
 	g_free (uri);
@@ -1623,13 +1627,13 @@ update_directories_from_new_config (TrackerMinerFS *mf,
 			if ((flags & TRACKER_DIRECTORY_FLAG_PRESERVE) != 0) {
 				flags &= ~(TRACKER_DIRECTORY_FLAG_PRESERVE);
 				tracker_indexing_tree_add (indexing_tree,
-							   file, flags);
+				                           file, flags, "tracker-miner-fs");
 			}
 
 			/* Fully remove item (monitors and from store),
 			 * now that there's no preserve flag.
 			 */
-			tracker_indexing_tree_remove (indexing_tree, file);
+			tracker_indexing_tree_remove (indexing_tree, file, "tracker-miner-fs");
 			g_object_unref (file);
 		}
 	}
@@ -1661,7 +1665,7 @@ update_directories_from_new_config (TrackerMinerFS *mf,
 			g_message ("  Adding directory:'%s'", path);
 
 			file = g_file_new_for_path (path);
-			tracker_indexing_tree_add (indexing_tree, file, flags);
+			tracker_indexing_tree_add (indexing_tree, file, flags, "tracker-miner-fs");
 			g_object_unref (file);
 		}
 	}
@@ -1853,7 +1857,8 @@ index_volumes_changed_idle (gpointer user_data)
 
 			mount_point_file = g_file_new_for_path (sl->data);
 			tracker_indexing_tree_remove (indexing_tree,
-						      mount_point_file);
+			                              mount_point_file,
+			                              "tracker-miner-fs");
 			g_object_unref (mount_point_file);
 		}
 
@@ -2800,8 +2805,9 @@ miner_files_add_removable_or_optical_directory (TrackerMinerFiles *mf,
 
 	g_message ("  Adding removable/optical: '%s'", mount_path);
 	tracker_indexing_tree_add (indexing_tree,
-				   mount_point_file,
-				   flags);
+	                           mount_point_file,
+	                           flags,
+	                           "tracker-miner-fs");
 	g_object_unref (mount_point_file);
 }
 
diff --git a/src/miners/user-guides/tracker-miner-user-guides.c b/src/miners/user-guides/tracker-miner-user-guides.c
index 59dfc4067..2ea489414 100644
--- a/src/miners/user-guides/tracker-miner-user-guides.c
+++ b/src/miners/user-guides/tracker-miner-user-guides.c
@@ -114,7 +114,8 @@ miner_userguides_basedir_add_path (TrackerMinerFS *fs,
 		tracker_indexing_tree_add (indexing_tree, file,
 		                           TRACKER_DIRECTORY_FLAG_RECURSE |
 		                           TRACKER_DIRECTORY_FLAG_MONITOR |
-		                           TRACKER_DIRECTORY_FLAG_CHECK_MTIME);
+		                           TRACKER_DIRECTORY_FLAG_CHECK_MTIME,
+		                           "tracker-miner-user-guides");
 		g_object_unref (file);
 
 		return TRUE;
diff --git a/tests/libtracker-miner/tracker-file-notifier-test.c b/tests/libtracker-miner/tracker-file-notifier-test.c
index 20825f53d..4819866e3 100644
--- a/tests/libtracker-miner/tracker-file-notifier-test.c
+++ b/tests/libtracker-miner/tracker-file-notifier-test.c
@@ -238,7 +238,7 @@ test_common_context_index_dir (TestCommonContext     *fixture,
 	file = g_file_new_for_path (path);
 	g_free (path);
 
-	tracker_indexing_tree_add (fixture->indexing_tree, file, flags);
+	tracker_indexing_tree_add (fixture->indexing_tree, file, flags, "test");
 	g_object_unref (file);
 }
 
@@ -253,7 +253,7 @@ test_common_context_remove_dir (TestCommonContext     *fixture,
 	file = g_file_new_for_path (path);
 	g_free (path);
 
-	tracker_indexing_tree_remove (fixture->indexing_tree, file);
+	tracker_indexing_tree_remove (fixture->indexing_tree, file, "test");
 	g_object_unref (file);
 }
 
diff --git a/tests/libtracker-miner/tracker-indexing-tree-test.c b/tests/libtracker-miner/tracker-indexing-tree-test.c
index 78b874c1d..e19c94459 100644
--- a/tests/libtracker-miner/tracker-indexing-tree-test.c
+++ b/tests/libtracker-miner/tracker-indexing-tree-test.c
@@ -124,7 +124,8 @@ test_indexing_tree_001 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -147,7 +148,8 @@ test_indexing_tree_002 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -169,7 +171,8 @@ test_indexing_tree_003 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -191,10 +194,12 @@ test_indexing_tree_004 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -217,10 +222,12 @@ test_indexing_tree_005 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -243,10 +250,12 @@ test_indexing_tree_006 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -269,10 +278,12 @@ test_indexing_tree_007 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -295,10 +306,12 @@ test_indexing_tree_008 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -321,10 +334,12 @@ test_indexing_tree_009 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -347,10 +362,12 @@ test_indexing_tree_010 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -373,10 +390,12 @@ test_indexing_tree_011 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -398,10 +417,12 @@ test_indexing_tree_012 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -423,13 +444,16 @@ test_indexing_tree_013 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -451,13 +475,16 @@ test_indexing_tree_014 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -481,13 +508,16 @@ test_indexing_tree_015 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -510,13 +540,16 @@ test_indexing_tree_016 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -540,13 +573,16 @@ test_indexing_tree_017 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -569,13 +605,16 @@ test_indexing_tree_018 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -598,13 +637,16 @@ test_indexing_tree_019 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -628,13 +670,16 @@ test_indexing_tree_020 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -658,13 +703,16 @@ test_indexing_tree_021 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -688,13 +736,16 @@ test_indexing_tree_022 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -718,13 +769,16 @@ test_indexing_tree_023 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -748,13 +802,16 @@ test_indexing_tree_024 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -777,13 +834,16 @@ test_indexing_tree_025 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -806,13 +866,16 @@ test_indexing_tree_026 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -836,13 +899,16 @@ test_indexing_tree_027 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -865,13 +931,17 @@ test_indexing_tree_028 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
+
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -895,13 +965,16 @@ test_indexing_tree_029 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_A]);
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner");
 
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -924,13 +997,16 @@ test_indexing_tree_030 (TestCommonContext *fixture,
 {
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_A],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 	tracker_indexing_tree_add (fixture->tree,
 	                           fixture->test_dir[TEST_DIRECTORY_AA],
-	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner");
 
 	tracker_indexing_tree_remove (fixture->tree,
-	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+	                              fixture->test_dir[TEST_DIRECTORY_AA],
+	                              "test-owner");
 
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
@@ -943,6 +1019,104 @@ test_indexing_tree_030 (TestCommonContext *fixture,
 	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
 }
 
+/* Directories are indexed until the last owner removes them.
+ */
+static void
+test_indexing_tree_031 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner-1");
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner-2");
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           "test-owner-2");
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           "test-owner-1");
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+}
+
+/* One owner wants A indexed recursively, another wants A indexed
+ * non-recursively.
+ */
+static void
+test_indexing_tree_032 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner-want-recurse");
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR,
+	                           "test-owner-no-recurse");
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner-want-recurse");
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+}
+
+/* One owner wants A indexed recursively, another wants A ignored.
+ * FLAG_IGNORE overrides other flags, because it can only be set by the
+ * user in the actual Tracker configuration so we can assume it is deliberate.
+ */
+static void
+test_indexing_tree_033 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE,
+	                           "test-owner-want");
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner-ignore");
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner-ignore");
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE,
+	                           "test-owner-ignore");
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner-want");
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+}
+
+/* Removing unknown owners doesn't crash anything. */
+static void
+test_indexing_tree_034 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A],
+	                              "test-owner-2");
+}
+
 gint
 main (gint    argc,
       gchar **argv)
@@ -981,6 +1155,10 @@ main (gint    argc,
 	test_add ("/libtracker-miner/indexing-tree/028", test_indexing_tree_028);
 	test_add ("/libtracker-miner/indexing-tree/029", test_indexing_tree_029);
 	test_add ("/libtracker-miner/indexing-tree/030", test_indexing_tree_030);
+	test_add ("/libtracker-miner/indexing-tree/031", test_indexing_tree_031);
+	test_add ("/libtracker-miner/indexing-tree/032", test_indexing_tree_032);
+	test_add ("/libtracker-miner/indexing-tree/033", test_indexing_tree_033);
+	test_add ("/libtracker-miner/indexing-tree/034", test_indexing_tree_034);
 
 	return g_test_run ();
 }