Merge lp:~ted/url-dispatcher/url-overlay into lp:url-dispatcher/15.10

[Ted Gould]

Support URL Overlays of content in a trusted session without a desktop file

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:126
http://jenkins.qa.ubuntu.com/job/url-dispatcher-ci/166/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-armhf-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-i386-ci/2/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/url-dispatcher-ci/166/rebuild

review: Needs Fixing (continuous-integration)

[lp:~ted/url-dispatcher/url-overlay]

127. By Ted Gould on 2015-05-20

Grab the exec tool too

128. By Ted Gould on 2015-05-20

Ensure Mir has pthread

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:128
http://jenkins.qa.ubuntu.com/job/url-dispatcher-ci/167/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-armhf-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-i386-ci/3/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/url-dispatcher-ci/167/rebuild

review: Needs Fixing (continuous-integration)

[lp:~ted/url-dispatcher/url-overlay]

129. By Ted Gould on 2015-06-05

Adding in directory support for the new UAL

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:129
http://jenkins.qa.ubuntu.com/job/url-dispatcher-ci/168/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-armhf-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-i386-ci/4/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/url-dispatcher-ci/168/rebuild

review: Needs Fixing (continuous-integration)

[lp:~ted/url-dispatcher/url-overlay]

130. By Ted Gould on 2015-06-05

Add the libclick dev package

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:130
http://jenkins.qa.ubuntu.com/job/url-dispatcher-ci/169/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-armhf-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/url-dispatcher-wily-i386-ci/5/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/url-dispatcher-ci/169/rebuild

review: Needs Fixing (continuous-integration)

[lp:~ted/url-dispatcher/url-overlay]

131. By Ted Gould on 2015-06-08

Grab Upstart dep

132. By Ted Gould on 2015-06-08

Make the exec-tool test work with the directory feature (and test it)

133. By Ted Gould on 2015-06-08

Fixing the dispatcher test to match the fixes in the exec tool test

134. By Ted Gould on 2015-06-08

Allow dir to be NULL

135. By Ted Gould on 2015-06-11

Switch linking option to not include the pthread library, but instead ask for it directly

136. By Ted Gould on 2015-06-11

Remove (void) as a function prototype

137. By Ted Gould on 2015-06-11

Making internal functions private

138. By Ted Gould on 2015-06-12

Clean up a couple of warnings

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-10-28 12:46:32 +0000
+++ CMakeLists.txt	2015-06-08 15:28:16 +0000
@@ -52,7 +52,7 @@
   set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
 endif() 
 
-pkg_check_modules(UBUNTU_APP_LAUNCH REQUIRED ubuntu-app-launch-2)
+pkg_check_modules(UBUNTU_APP_LAUNCH REQUIRED ubuntu-app-launch-2>=0.5)
 include_directories(${UBUNTU_APP_LAUNCH_INCLUDE_DIRS})
 
 pkg_check_modules(GLIB2 REQUIRED glib-2.0)
@@ -76,6 +76,9 @@
 pkg_check_modules(SQLITE REQUIRED sqlite3)
 include_directories(${SQLITE_INCLUDE_DIRS})
 
+pkg_check_modules(CLICK REQUIRED click-0.4)
+include_directories(${CLICK_INCLUDE_DIRS})
+
 if(${LOCAL_INSTALL})
   set(DBUSSERVICEDIR "${CMAKE_INSTALL_DATADIR}/dbus-1/services/")
 else()

=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2014-08-20 18:58:49 +0000
+++ data/CMakeLists.txt	2015-06-08 15:28:16 +0000
@@ -92,8 +92,13 @@
 # Click Hook
 ###########################
 
-configure_file("url-dispatcher.click-hook.in"
-	"${CMAKE_SOURCE_DIR}/debian/url-dispatcher.click-hook"
+configure_file("url-dispatcher.urls.click-hook.in"
+	"${CMAKE_SOURCE_DIR}/debian/url-dispatcher.urls.click-hook"
+	@ONLY
+)
+
+configure_file("url-dispatcher.url-overlay.click-hook.in"
+	"${CMAKE_SOURCE_DIR}/debian/url-dispatcher.url-overlay.click-hook"
 	@ONLY
 )
 

=== added file 'data/url-dispatcher.url-overlay.click-hook.in'
--- data/url-dispatcher.url-overlay.click-hook.in	1970-01-01 00:00:00 +0000
+++ data/url-dispatcher.url-overlay.click-hook.in	2015-06-08 15:28:16 +0000
@@ -0,0 +1,3 @@
+Pattern: ${home}/.cache/url-dispatcher/url-overlays/${id}.desktop
+User-Level: yes
+Hook-Name: url-overlay

=== renamed file 'data/url-dispatcher.click-hook.in' => 'data/url-dispatcher.urls.click-hook.in'
=== modified file 'debian/control'
--- debian/control	2014-08-20 18:41:41 +0000
+++ debian/control	2015-06-08 15:28:16 +0000
@@ -9,19 +9,21 @@
                dh-autoreconf,
                gtester2xunit,
                intltool,
+               libclick-0.4-dev,
                libdbus-1-dev,
                libdbustest1-dev (>= 14.04.0),
                libglib2.0-dev,
                libjson-glib-dev,
                libgtest-dev,
                libsqlite3-dev,
-               libubuntu-app-launch2-dev (>= 0.3),
+               libubuntu-app-launch2-dev (>= 0.5),
                python3,
                python3-dbusmock,
                python3-fixtures,
                python3-nose,
                python3-testtools,
                sqlite3,
+               upstart,
 Standards-Version: 3.9.4
 Homepage: http://launchpad.net/url-dispatcher
 # If you aren't a member of ~indicator-applet-developers but need to upload

=== modified file 'debian/rules'
--- debian/rules	2014-07-20 11:45:00 +0000
+++ debian/rules	2015-06-08 15:28:16 +0000
@@ -2,6 +2,7 @@
 
 export DPKG_GENSYMBOLS_CHECK_LEVEL = 4
 export G_MESSAGES_DEBUG=all
+export URL_DISPATCHER_DISABLE_RECOVERABLE_ERROR=1
 
 %:
 	dh $@ --fail-missing --with click
@@ -12,3 +13,7 @@
 	mkdir -p debian/url-dispatcher/etc/apport/crashdb.conf.d/
 	install -m 644 debian/url-dispatcher-crashdb.conf debian/url-dispatcher/etc/apport/crashdb.conf.d/
 	dh_install --fail-missing
+
+override_dh_click:
+	dh_click --name urls
+	dh_click --name url-overlay

=== modified file 'debian/url-dispatcher.install'
--- debian/url-dispatcher.install	2013-06-28 16:35:12 +0000
+++ debian/url-dispatcher.install	2015-06-08 15:28:16 +0000
@@ -1,3 +1,4 @@
 usr/lib/*/url-dispatcher
+usr/lib/*/ubuntu-app-launch/url-overlay/exec-tool
 usr/share/dbus-1
 usr/share/upstart/sessions

=== modified file 'service/CMakeLists.txt'
--- service/CMakeLists.txt	2014-05-26 12:56:47 +0000
+++ service/CMakeLists.txt	2015-06-08 15:28:16 +0000
@@ -2,6 +2,8 @@
 include(UseConstantBuilder)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
+add_definitions( -DOVERLAY_SYSTEM_DIRECTORY="${CMAKE_INSTALL_FULL_DATADIR}/url-dispatcher/url-overlays" )
+
 ###########################
 # Generated Lib
 ###########################
@@ -38,15 +40,24 @@
 
 add_library(dispatcher-lib STATIC
 	dispatcher.h
-	dispatcher.c)
+	dispatcher.c
+	glib-thread.h
+	glib-thread.cpp
+	overlay-tracker.h
+	overlay-tracker.cpp
+	overlay-tracker-iface.h
+	overlay-tracker-mir.h
+	overlay-tracker-mir.cpp)
 
 target_link_libraries(dispatcher-lib
 	url-db-lib
 	service-generated
+	-lpthread
 	${GLIB2_LIBRARIES}
 	${GOBJECT2_LIBRARIES}
 	${GIO2_LIBRARIES}
 	${SQLITE_LIBRARIES}
+	${UBUNTU_APP_LAUNCH_LIBRARIES}
 )
 
 ###########################
@@ -84,7 +95,7 @@
 
 set_target_properties(service-exec PROPERTIES OUTPUT_NAME "url-dispatcher")
 
-target_link_libraries(service-exec dispatcher-lib ${UBUNTU_APP_LAUNCH_LIBRARIES})
+target_link_libraries(service-exec dispatcher-lib)
 
 ###########################
 # Update Directory
@@ -95,6 +106,14 @@
 target_link_libraries(update-directory ${GIO2_LIBRARIES} ${JSONGLIB_LIBRARIES} url-db-lib)
 
 ###########################
+# URL Overlay Exec Tool
+###########################
+
+add_executable(url-overlay-exec-tool url-overlay.c recoverable-problem.c)
+set_target_properties(url-overlay-exec-tool PROPERTIES OUTPUT_NAME "exec-tool")
+target_link_libraries(url-overlay-exec-tool ${GIO2_LIBRARIES} ${UBUNTU_APP_LAUNCH_LIBRARIES} ${CLICK_LIBRARIES})
+
+###########################
 # Installation
 ###########################
 
@@ -103,3 +122,8 @@
   RUNTIME DESTINATION "${CMAKE_INSTALL_FULL_LIBEXECDIR}/url-dispatcher"
 )
 
+install(
+  TARGETS url-overlay-exec-tool
+  RUNTIME DESTINATION "${CMAKE_INSTALL_FULL_LIBEXECDIR}/ubuntu-app-launch/url-overlay"
+)
+

=== modified file 'service/dispatcher.c'
--- service/dispatcher.c	2015-01-23 14:34:30 +0000
+++ service/dispatcher.c	2015-06-08 15:28:16 +0000
@@ -26,6 +26,7 @@
 #include "url-db.h"
 
 /* Globals */
+static OverlayTracker * tracker = NULL;
 static GCancellable * cancellable = NULL;
 static ServiceIfaceComCanonicalURLDispatcher * skel = NULL;
 static GRegex * applicationre = NULL;
@@ -78,11 +79,7 @@
 		NULL
 	};
 
-	/* Allow disabling for testing, we don't want to report bugs on
-	   our tests ;-) */
-	if (g_getenv("URL_DISPATCHER_DISABLE_RECOVERABLE_ERROR") == NULL) {
-		report_recoverable_problem("url-dispatcher-bad-url", pid, FALSE, additional);
-	}
+	report_recoverable_problem("url-dispatcher-bad-url", pid, FALSE, additional);
 
 	g_free(badurl);
 
@@ -111,7 +108,7 @@
 bad_url (GDBusMethodInvocation * invocation, const gchar * url)
 {
 	const gchar * sender = g_dbus_method_invocation_get_sender(invocation);
-	GDBusConnection * conn = g_dbus_method_invocation_get_connection(invocation);
+	GDBusConnection * conn = g_dbus_method_invocation_get_connection(invocation); /* transfer: none */
 
 	g_dbus_connection_call(conn,
 		"org.freedesktop.DBus",
@@ -213,6 +210,73 @@
 	return TRUE;
 }
 
+/* Handles setting up the overlay with the URL */
+gboolean
+dispatcher_send_to_overlay (const gchar * app_id, const gchar * url, GDBusConnection * conn, const gchar * sender)
+{
+	GError * error = NULL;
+
+	/* TODO: Detect if a scope is what we need to overlay on */
+	GVariant * callret = g_dbus_connection_call_sync(conn,
+		"org.freedesktop.DBus",
+		"/",
+		"org.freedesktop.DBus",
+		"GetConnectionUnixProcessID",
+		g_variant_new("(s)", sender),
+		G_VARIANT_TYPE("(u)"),
+		G_DBUS_CALL_FLAGS_NONE,
+		-1, /* timeout */
+		NULL, /* cancellable */
+		&error);
+
+	if (error != NULL) {
+		g_warning("Unable to get PID for '%s' when processing URL '%s': %s", sender, url, error->message);
+		g_error_free(error);
+		return FALSE;
+	}
+
+	unsigned int pid = 0;
+	g_variant_get_child(callret, 0, "u", &pid);
+	g_variant_unref(callret);
+
+	return overlay_tracker_add(tracker, app_id, pid, url);
+}
+
+/* Check to see if this is an overlay AppID */
+gboolean
+dispatcher_is_overlay (const gchar * appid)
+{
+	const gchar * systemdir = NULL;
+	gboolean found = FALSE;
+	gchar * desktopname = g_strdup_printf("%s.desktop", appid);
+
+	/* First time, check the environment */
+	if (G_UNLIKELY(systemdir == NULL)) {
+		systemdir = g_getenv("URL_DISPATCHER_OVERLAY_DIR");
+		if (systemdir == NULL) {
+			systemdir = OVERLAY_SYSTEM_DIRECTORY;
+		}
+	}
+
+	/* Check system dir */
+	if (!found) {
+		gchar * sysdir = g_build_filename(systemdir, desktopname, NULL);
+		found = g_file_test(sysdir, G_FILE_TEST_EXISTS);
+		g_free(sysdir);
+	}
+
+	/* Check user dir (clicks) */
+	if (!found) {
+		gchar * usrdir = g_build_filename(g_get_user_cache_dir(), "url-dispatcher", "url-overlays", desktopname, NULL);
+		found = g_file_test(usrdir, G_FILE_TEST_EXISTS);
+		g_free(usrdir);
+	}
+
+	g_free(desktopname);
+
+	return found;
+}
+
 /* Whether we should restrict this appid based on the package name */
 gboolean
 dispatcher_appid_restrict (const gchar * appid, const gchar * package)
@@ -277,12 +341,25 @@
 	}
 
 	/* We're cleared to continue */
-	dispatcher_send_to_app(appid, outurl);
+	gboolean sent = FALSE;
+	if (!dispatcher_is_overlay(appid)) {
+		sent = dispatcher_send_to_app(appid, outurl);
+	} else {
+		sent = dispatcher_send_to_overlay(
+			appid,
+			outurl,
+			g_dbus_method_invocation_get_connection(invocation),
+			g_dbus_method_invocation_get_sender(invocation));
+	}
 	g_free(appid);
 
-	g_dbus_method_invocation_return_value(invocation, NULL);
+	if (sent) {
+		g_dbus_method_invocation_return_value(invocation, NULL);
+	} else {
+		bad_url(invocation, url);
+	}
 
-	return TRUE;
+	return sent;
 }
 
 /* Test a URL to find it's AppID */
@@ -347,6 +424,9 @@
 gboolean
 dispatcher_url_to_appid (const gchar * url, gchar ** out_appid, const gchar ** out_url)
 {
+	g_return_val_if_fail(url != NULL, FALSE);
+	g_return_val_if_fail(out_appid != NULL, FALSE);
+
 	/* Special case the app id */
 	GMatchInfo * appidmatch = NULL;
 	if (g_regex_match(appidre, url, 0, &appidmatch)) {
@@ -398,7 +478,9 @@
 
 		if (*out_appid != NULL) {
 			found = TRUE;
-			*out_url = url;
+			if (out_url != NULL) {
+				*out_url = url;
+			}
 		}
 
 		g_free(protocol);
@@ -465,8 +547,9 @@
 
 /* Initialize all the globals */
 gboolean
-dispatcher_init (GMainLoop * mainloop)
+dispatcher_init (GMainLoop * mainloop, OverlayTracker * intracker)
 {
+	tracker = intracker;
 	cancellable = g_cancellable_new();
 
 	urldb = url_db_create_database();

=== modified file 'service/dispatcher.h'
--- service/dispatcher.h	2014-10-24 18:55:11 +0000
+++ service/dispatcher.h	2015-06-08 15:28:16 +0000
@@ -20,15 +20,18 @@
 #ifndef DISPATCHER_H
 #define DISPATCHER_H 1
 
-#include <glib.h>
+#include <gio/gio.h>
+#include "overlay-tracker.h"
 
 G_BEGIN_DECLS
 
-gboolean dispatcher_init (GMainLoop * mainloop);
+gboolean dispatcher_init (GMainLoop * mainloop, OverlayTracker * tracker);
 gboolean dispatcher_shutdown (void);
 gboolean dispatcher_url_to_appid (const gchar * url, gchar ** out_appid, const gchar ** out_url);
 gboolean dispatcher_appid_restrict (const gchar * appid, const gchar * package);
+gboolean dispatcher_is_overlay (const gchar * appid);
 gboolean dispatcher_send_to_app (const gchar * appid, const gchar * url);
+gboolean dispatcher_send_to_overlay (const gchar * app_id, const gchar * url, GDBusConnection * conn, const gchar * sender);
 
 G_END_DECLS
 

=== added file 'service/glib-thread.cpp'
--- service/glib-thread.cpp	1970-01-01 00:00:00 +0000
+++ service/glib-thread.cpp	2015-06-08 15:28:16 +0000
@@ -0,0 +1,179 @@
+/*
+ * Copyright © 2015 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/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#include "glib-thread.h"
+
+namespace GLib
+{
+
+
+ContextThread::ContextThread (std::function<void(void)> beforeLoop, std::function<void(void)> afterLoop)
+    : _context(nullptr)
+    , _loop(nullptr)
+{
+    _cancel = std::shared_ptr<GCancellable>(g_cancellable_new(), [](GCancellable * cancel)
+    {
+        if (cancel != nullptr)
+        {
+            g_cancellable_cancel(cancel);
+            g_object_unref(cancel);
+        }
+    });
+    std::promise<std::pair<std::shared_ptr<GMainContext>, std::shared_ptr<GMainLoop>>> context_promise;
+
+    /* NOTE: We copy afterLoop but reference beforeLoop. We're blocking so we
+       know that beforeLoop will stay valid long enough, but we can't say the
+       same for afterLoop */
+    _thread = std::thread([&context_promise, &beforeLoop, afterLoop, this](void) -> void
+    {
+        /* Build up the context and loop for the async events and a place
+           for GDBus to send its events back to */
+        auto context = std::shared_ptr<GMainContext>(g_main_context_new(), [](GMainContext * context)
+        {
+            g_clear_pointer(&context, g_main_context_unref);
+        });
+        auto loop = std::shared_ptr<GMainLoop>(g_main_loop_new(context.get(), FALSE), [](GMainLoop * loop)
+        {
+            g_clear_pointer(&loop, g_main_loop_unref);
+        });
+
+        g_main_context_push_thread_default(context.get());
+
+        beforeLoop();
+
+        /* Free's the constructor to continue */
+        auto pair = std::pair<std::shared_ptr<GMainContext>, std::shared_ptr<GMainLoop>>(context, loop);
+        context_promise.set_value(pair);
+
+        if (!g_cancellable_is_cancelled(_cancel.get()))
+        {
+            g_main_loop_run(loop.get());
+        }
+
+        afterLoop();
+    });
+
+    /* We need to have the context and the mainloop ready before
+       other functions on this object can work properly. So we wait
+       for them and set them on this thread. */
+    auto context_future = context_promise.get_future();
+    context_future.wait();
+    auto context_value = context_future.get();
+
+    _context = context_value.first;
+    _loop = context_value.second;
+
+    if (_context == nullptr || _loop == nullptr)
+    {
+        throw std::runtime_error("Unable to create GLib Thread");
+    }
+}
+
+ContextThread::~ContextThread (void)
+{
+    quit();
+}
+
+void ContextThread::quit (void)
+{
+    g_cancellable_cancel(_cancel.get()); /* Force the cancellation on ongoing tasks */
+    if (_loop != nullptr)
+    {
+        g_main_loop_quit(_loop.get());    /* Quit the loop */
+    }
+
+    /* Joining here because we want to ensure that the final afterLoop()
+       function is run before returning */
+    if (std::this_thread::get_id() != _thread.get_id())
+    {
+        if (_thread.joinable())
+        {
+            _thread.join();
+        }
+    }
+}
+
+bool ContextThread::isCancelled (void)
+{
+    return g_cancellable_is_cancelled(_cancel.get()) == TRUE;
+}
+
+std::shared_ptr<GCancellable> ContextThread::getCancellable (void)
+{
+    return _cancel;
+}
+
+void ContextThread::simpleSource (std::function<GSource * (void)> srcBuilder, std::function<void(void)> work)
+{
+    if (isCancelled())
+    {
+        throw std::runtime_error("Trying to execute work on a GLib thread that is shutting down.");
+    }
+
+    /* Copy the work so that we can reuse it */
+    /* Lifecycle is handled with the source pointer when we attach
+       it to the context. */
+    auto heapWork = new std::function<void(void)>(work);
+
+    auto source = std::shared_ptr<GSource>(srcBuilder(),
+                                           [](GSource * src)
+    {
+        g_clear_pointer(&src, g_source_unref);
+    }
+                                          );
+    g_source_set_callback(source.get(),
+                          [](gpointer data) -> gboolean
+    {
+        std::function<void(void)>* heapWork = reinterpret_cast<std::function<void(void)> *>(data);
+        (*heapWork)();
+        return G_SOURCE_REMOVE;
+    }, heapWork,
+    [](gpointer data)
+    {
+        std::function<void(void)>* heapWork = reinterpret_cast<std::function<void(void)> *>(data);
+        delete heapWork;
+    });
+
+    g_source_attach(source.get(), _context.get());
+}
+
+void ContextThread::executeOnThread (std::function<void(void)> work)
+{
+    simpleSource(g_idle_source_new, work);
+}
+
+void ContextThread::timeout (const std::chrono::milliseconds& length,
+                             std::function<void(void)> work)
+{
+    simpleSource([length]()
+    {
+        return g_timeout_source_new(length.count());
+    }, work);
+}
+
+void ContextThread::timeoutSeconds (const std::chrono::seconds& length,
+                                    std::function<void(void)> work)
+{
+    simpleSource([length]()
+    {
+        return g_timeout_source_new_seconds(length.count());
+    }, work);
+}
+
+} // ns GLib

=== added file 'service/glib-thread.h'
--- service/glib-thread.h	1970-01-01 00:00:00 +0000
+++ service/glib-thread.h	2015-06-08 15:28:16 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright © 2015 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/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#include <thread>
+#include <future>
+
+#include <gio/gio.h>
+
+namespace GLib
+{
+
+class ContextThread
+{
+    std::thread _thread;
+    std::shared_ptr<GMainContext> _context;
+    std::shared_ptr<GMainLoop> _loop;
+    std::shared_ptr<GCancellable> _cancel;
+
+public:
+    ContextThread (std::function<void(void)> beforeLoop = [] {}, std::function<void(void)> afterLoop = [] {});
+    ~ContextThread (void);
+
+    void quit (void);
+    bool isCancelled (void);
+    std::shared_ptr<GCancellable> getCancellable (void);
+
+    void executeOnThread (std::function<void(void)> work);
+    template<typename T> auto executeOnThread (std::function<T(void)> work) -> T
+    {
+        if (std::this_thread::get_id() == _thread.get_id())
+        {
+            /* Don't block if we're on the same thread */
+            return work();
+        }
+
+        std::promise<T> promise;
+        std::function<void(void)> magicFunc = [&promise, &work] (void) -> void {
+            promise.set_value(work());
+        };
+
+        executeOnThread(magicFunc);
+
+        auto future = promise.get_future();
+        future.wait();
+        return future.get();
+    }
+
+    void timeout (const std::chrono::milliseconds& length, std::function<void(void)> work);
+    template<class Rep, class Period> void timeout (const std::chrono::duration<Rep, Period>& length,
+                                                    std::function<void(void)> work)
+    {
+        return timeout(std::chrono::duration_cast<std::chrono::milliseconds>(length), work);
+    }
+
+    void timeoutSeconds (const std::chrono::seconds& length, std::function<void(void)> work);
+    template<class Rep, class Period> void timeoutSeconds (const std::chrono::duration<Rep, Period>& length,
+                                                           std::function<void(void)> work)
+    {
+        return timeoutSeconds(std::chrono::duration_cast<std::chrono::seconds>(length), work);
+    }
+
+private:
+    void simpleSource (std::function<GSource * (void)> srcBuilder, std::function<void(void)> work);
+};
+}

=== added file 'service/overlay-tracker-iface.h'
--- service/overlay-tracker-iface.h	1970-01-01 00:00:00 +0000
+++ service/overlay-tracker-iface.h	2015-06-08 15:28:16 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2015 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/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#pragma once
+
+class OverlayTrackerIface {
+public:
+	virtual ~OverlayTrackerIface() = default;
+	virtual bool addOverlay (const char * appid, unsigned long pid, const char * url) = 0;
+};

=== added file 'service/overlay-tracker-mir.cpp'
--- service/overlay-tracker-mir.cpp	1970-01-01 00:00:00 +0000
+++ service/overlay-tracker-mir.cpp	2015-06-08 15:28:16 +0000
@@ -0,0 +1,153 @@
+/*
+ * Copyright © 2015 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/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#include "overlay-tracker-mir.h"
+#include <ubuntu-app-launch.h>
+
+static const char * HELPER_TYPE = "url-overlay";
+
+OverlayTrackerMir::OverlayTrackerMir (void) 
+	: thread([this] {
+		/* Setup Helper Observer */
+		ubuntu_app_launch_observer_add_helper_stop(untrustedHelperStoppedStatic, HELPER_TYPE, this);
+		},
+		[this] {
+		/* Remove Helper Observer */
+		ubuntu_app_launch_observer_delete_helper_stop(untrustedHelperStoppedStatic, HELPER_TYPE, this);
+		})
+{
+	mir = std::shared_ptr<MirConnection>([] {
+			gchar * path = g_build_filename(g_get_user_runtime_dir(), "mir_socket_trusted", NULL);
+			MirConnection * con = mir_connect_sync(path, "url-dispatcher");
+			g_free(path);
+			return con;
+		}(),
+		[] (MirConnection * connection) {
+			if (connection != nullptr)
+				mir_connection_release(connection);
+		});
+
+	if (!mir) {
+		throw std::runtime_error("Unable to connect to Mir");
+	}
+}
+
+/* Enforce a shutdown order, sessions before connection */
+OverlayTrackerMir::~OverlayTrackerMir (void) 
+{
+	thread.executeOnThread<bool>([this] {
+		while (!ongoingSessions.empty()) {
+			removeSession(std::get<2>(*ongoingSessions.begin()).get());
+		}
+
+		return true;
+	});
+
+	mir.reset();
+}
+
+bool
+OverlayTrackerMir::addOverlay (const char * appid, unsigned long pid, const char * url)
+{
+	std::string sappid(appid);
+	std::string surl(url);
+
+	return thread.executeOnThread<bool>([this, sappid, pid, surl] {
+		g_debug("Setting up over lay for PID %d with '%s'", pid, sappid.c_str());
+
+		auto session = std::shared_ptr<MirPromptSession>(
+			mir_connection_create_prompt_session_sync(mir.get(), pid, sessionStateChangedStatic, this),
+			[] (MirPromptSession * session) { if (session) mir_prompt_session_release_sync(session); });
+		if (!session) {
+			g_critical("Unable to create trusted prompt session for %d with appid '%s'", pid, sappid.c_str());
+			return false;
+		}
+		
+		std::array<const char *, 2> urls { surl.c_str(), nullptr };
+		auto instance = ubuntu_app_launch_start_session_helper(HELPER_TYPE, session.get(), sappid.c_str(), urls.data());
+		if (instance == nullptr) {
+			g_critical("Unable to start helper for %d with appid '%s'", pid, sappid.c_str());
+			return false;
+		}
+
+		ongoingSessions.emplace(std::make_tuple(sappid, std::string(instance), session));
+		g_free(instance);
+		return true;
+	});
+}
+
+void
+OverlayTrackerMir::sessionStateChangedStatic (MirPromptSession * session, MirPromptSessionState state, void * user_data)
+{
+	reinterpret_cast<OverlayTrackerMir *>(user_data)->sessionStateChanged(session, state);
+}
+
+void
+OverlayTrackerMir::removeSession (MirPromptSession * session)
+{
+	for (auto it = ongoingSessions.begin(); it != ongoingSessions.end(); it++) {
+		if (std::get<2>(*it).get() == session) {
+			ubuntu_app_launch_stop_multiple_helper(HELPER_TYPE, std::get<0>(*it).c_str(), std::get<1>(*it).c_str());
+			ongoingSessions.erase(it);
+			break;
+		}
+	}
+}
+
+void
+OverlayTrackerMir::sessionStateChanged (MirPromptSession * session, MirPromptSessionState state)
+{
+	if (state != mir_prompt_session_state_stopped) {
+		/* We only care about the stopped state */
+		return;
+	}
+
+	/* Executing on the Mir thread, which is nice and all, but we
+	   want to get back on our thread */
+	thread.executeOnThread([this, session]() {
+		removeSession(session);
+	});
+}
+
+void
+OverlayTrackerMir::untrustedHelperStoppedStatic (const gchar * appid, const gchar * instanceid, const gchar * helpertype, gpointer user_data)
+{
+	reinterpret_cast<OverlayTrackerMir *>(user_data)->untrustedHelperStopped(appid, instanceid, helpertype);
+}
+
+void 
+OverlayTrackerMir::untrustedHelperStopped(const gchar * appid, const gchar * instanceid, const gchar * helpertype)
+{
+	/* This callback will happen on our thread already, we don't need
+	   to proxy it on */
+	if (g_strcmp0(helpertype, HELPER_TYPE) != 0) {
+		return;
+	}
+
+	/* Making the code in the loop easier to read by using std::string outside */
+	std::string sappid(appid);
+	std::string sinstanceid(instanceid);
+
+	for (auto it = ongoingSessions.begin(); it != ongoingSessions.end(); it++) {
+		if (std::get<0>(*it) == sappid && std::get<1>(*it) == sinstanceid) {
+			ongoingSessions.erase(it);
+			break;
+		}
+	}
+}

=== added file 'service/overlay-tracker-mir.h'
--- service/overlay-tracker-mir.h	1970-01-01 00:00:00 +0000
+++ service/overlay-tracker-mir.h	2015-06-08 15:28:16 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2015 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/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#pragma once
+
+#include <set>
+
+#include <mir_toolkit/mir_connection.h>
+#include <mir_toolkit/mir_prompt_session.h>
+
+#include "glib-thread.h"
+#include "overlay-tracker-iface.h"
+
+class OverlayTrackerMir : public OverlayTrackerIface {
+private:
+	GLib::ContextThread thread;
+	std::shared_ptr<MirConnection> mir;
+	std::set<std::tuple<std::string, std::string, std::shared_ptr<MirPromptSession>>> ongoingSessions;
+
+public:
+	OverlayTrackerMir (void); 
+	~OverlayTrackerMir (void); 
+	bool addOverlay (const char * appid, unsigned long pid, const char * url) override;
+
+	void removeSession (MirPromptSession * session);
+
+	static void sessionStateChangedStatic (MirPromptSession * session, MirPromptSessionState state, void * user_data);
+	void sessionStateChanged (MirPromptSession * session, MirPromptSessionState state);
+
+	static void untrustedHelperStoppedStatic (const gchar * appid, const gchar * instanceid, const gchar * helpertype, gpointer user_data);
+	void untrustedHelperStopped(const gchar * appid, const gchar * instanceid, const gchar * helpertype);
+};

=== added file 'service/overlay-tracker.cpp'
--- service/overlay-tracker.cpp	1970-01-01 00:00:00 +0000
+++ service/overlay-tracker.cpp	2015-06-08 15:28:16 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2015 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/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+extern "C" {
+#include "overlay-tracker.h"
+}
+
+#include "overlay-tracker-iface.h"
+#include "overlay-tracker-mir.h"
+
+OverlayTracker *
+overlay_tracker_new (void) {
+	try {
+		OverlayTrackerMir * cpptracker = new OverlayTrackerMir();
+		return reinterpret_cast<OverlayTracker *>(cpptracker);
+	} catch (...) {
+		return nullptr;
+	}
+}
+
+void
+overlay_tracker_delete (OverlayTracker * tracker) {
+	g_return_if_fail(tracker != nullptr);
+
+	auto cpptracker = reinterpret_cast<OverlayTrackerMir *>(tracker);
+	delete cpptracker;
+	return;
+}
+
+gboolean
+overlay_tracker_add (OverlayTracker * tracker, const char * appid, unsigned long pid, const gchar * url) {
+	g_return_val_if_fail(tracker != nullptr, FALSE);
+	g_return_val_if_fail(appid != nullptr, FALSE);
+	g_return_val_if_fail(pid != 0, FALSE);
+	g_return_val_if_fail(url != nullptr, FALSE);
+
+	return reinterpret_cast<OverlayTrackerIface *>(tracker)->addOverlay(appid, pid, url) ? TRUE : FALSE;
+}

=== added file 'service/overlay-tracker.h'
--- service/overlay-tracker.h	1970-01-01 00:00:00 +0000
+++ service/overlay-tracker.h	2015-06-08 15:28:16 +0000
@@ -0,0 +1,28 @@
+/*
+ * Copyright © 2015 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/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#pragma once
+#include <glib.h>
+
+typedef struct _OverlayTracker OverlayTracker;
+
+OverlayTracker * overlay_tracker_new (void);
+void overlay_tracker_delete (OverlayTracker * tracker);
+gboolean overlay_tracker_add (OverlayTracker * tracker, const char * appid, unsigned long pid, const char * url);
+

=== modified file 'service/recoverable-problem.c'
--- service/recoverable-problem.c	2014-05-27 16:51:53 +0000
+++ service/recoverable-problem.c	2015-06-08 15:28:16 +0000
@@ -63,6 +63,12 @@
 void
 report_recoverable_problem (const gchar * signature, GPid report_pid, gboolean wait, const gchar * additional_properties[])
 {
+	/* Allow disabling for testing, we don't want to report bugs on
+	   our tests ;-) */
+	if (G_UNLIKELY(g_getenv("URL_DISPATCHER_DISABLE_RECOVERABLE_ERROR") != NULL)) {
+		return;
+	}
+
 	GError * error = NULL;
 	gint error_stdin = 0;
 	GPid pid = 0;

=== modified file 'service/service.c'
--- service/service.c	2014-03-14 19:50:37 +0000
+++ service/service.c	2015-06-08 15:28:16 +0000
@@ -39,13 +39,15 @@
 
 	guint term_source = g_unix_signal_add(SIGTERM, sig_term, mainloop);
 
-	dispatcher_init(mainloop);
+	OverlayTracker * tracker = overlay_tracker_new();
+	dispatcher_init(mainloop, tracker);
 
 	/* Run Main */
 	g_main_loop_run(mainloop);
 
 	/* Clean up globals */
 	dispatcher_shutdown();
+	overlay_tracker_delete(tracker);
 	g_source_remove(term_source);
 	g_main_loop_unref(mainloop);
 

=== added file 'service/url-overlay.c'
--- service/url-overlay.c	1970-01-01 00:00:00 +0000
+++ service/url-overlay.c	2015-06-08 15:28:16 +0000
@@ -0,0 +1,183 @@
+/*
+ * Copyright © 2014 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/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#include <glib.h>
+#include <click.h>
+#include <ubuntu-app-launch.h>
+
+#include "recoverable-problem.h"
+
+gchar *
+build_exec (const gchar * appid, const gchar * directory)
+{
+	gchar * appid_desktop = g_strdup_printf("%s.desktop", appid);
+	gchar * desktopfilepath = g_build_filename(directory, appid_desktop, NULL);
+	g_free(appid_desktop);
+
+	if (!g_file_test(desktopfilepath, G_FILE_TEST_EXISTS)) {
+		g_free(desktopfilepath);
+		return NULL;
+	}
+
+	GError * error = NULL;
+	GKeyFile * keyfile = g_key_file_new();
+	g_key_file_load_from_file(keyfile, desktopfilepath, G_KEY_FILE_NONE, &error);
+
+	if (error != NULL) {
+		g_error("Unable to read url-overlay desktop file '%s': %s", desktopfilepath, error->message);
+		g_free(desktopfilepath);
+		g_key_file_free(keyfile);
+		g_error_free(error);
+		return NULL;
+	}
+
+	g_free(desktopfilepath);
+
+	if (!g_key_file_has_key(keyfile, "Desktop Entry", "Exec", NULL)) {
+		g_error("Desktop file for '%s' in '%s' does not have 'Exec' key", appid, directory);
+		g_key_file_free(keyfile);
+		return NULL;
+	}
+
+	gchar * exec = g_key_file_get_string(keyfile, "Desktop Entry", "Exec", NULL);
+	g_key_file_free(keyfile);
+
+	return exec;
+}
+
+gchar *
+build_dir (const gchar * appid)
+{
+	GError * error = NULL;
+	gchar * package = NULL;
+
+	/* 'Parse' the App ID */
+	if (!ubuntu_app_launch_app_id_parse(appid, &package, NULL, NULL)) {
+		g_warning("Unable to parse App ID: '%s'", appid);
+		return NULL;
+	}
+
+	/* Check click to find out where the files are */
+	ClickDB * db = click_db_new();
+
+	/* If TEST_CLICK_DB is unset, this reads the system database. */
+	click_db_read(db, g_getenv("TEST_CLICK_DB"), &error);
+	if (error != NULL) {
+		g_warning("Unable to read Click database: %s", error->message);
+		g_error_free(error);
+		g_free(package);
+		return NULL;
+	}
+
+	/* If TEST_CLICK_USER is unset, this uses the current user name. */
+	ClickUser * user = click_user_new_for_user(db, g_getenv("TEST_CLICK_USER"), &error);
+	if (error != NULL) {
+		g_warning("Unable to read Click database: %s", error->message);
+		g_error_free(error);
+		g_free(package);
+		g_object_unref(db);
+		return NULL;
+	}
+
+	gchar * pkgdir = click_user_get_path(user, package, &error);
+
+	g_object_unref(user);
+	g_object_unref(db);
+	g_free(package);
+
+	if (error != NULL) {
+		g_warning("Unable to get the Click package directory for %s: %s", package, error->message);
+		g_error_free(error);
+		return NULL;
+	}
+
+	return pkgdir;
+}
+
+int
+main (int argc, char * argv[])
+{
+	/* Build up our exec */
+	const gchar * appid = g_getenv("APP_ID");
+	if (appid == NULL) {
+		report_recoverable_problem("url-dispatcher-url-overlay-no-appid", 0, TRUE, NULL);
+		return -1;
+	}
+
+	gchar * exec = NULL;
+
+	/* Allow for environment override */
+	const gchar * envdir = g_getenv("URL_DISPATCHER_OVERLAY_DIR");
+	if (G_UNLIKELY(envdir != NULL)) { /* Mostly for testing */
+		exec = build_exec(appid, envdir);
+	}
+
+	/* Try the system directory */
+	if (exec == NULL) {
+		exec = build_exec(appid, OVERLAY_SYSTEM_DIRECTORY);
+	}
+
+	/* If not there look to the user directory (click) */
+	if (exec == NULL) {
+		gchar * userdir = g_build_filename(g_get_user_cache_dir(), "url-dispatcher", "url-overlays", NULL);
+		exec = build_exec(appid, userdir);
+		g_free(userdir);
+	}
+
+	if (exec == NULL) {
+		const gchar * props[3] = {
+			"AppID",
+			appid,
+			NULL
+		};
+
+		report_recoverable_problem("url-dispatcher-url-overlay-bad-appid", 0, TRUE, props);
+		return -1;
+	}
+
+	gchar * dir = build_dir(appid);
+	if (dir == NULL) {
+		const gchar * props[3] = {
+			"AppID",
+			appid,
+			NULL
+		};
+
+		report_recoverable_problem("url-dispatcher-url-overlay-bad-appid", 0, TRUE, props);
+		return -1;
+	}
+
+	GDBusConnection * bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	g_return_val_if_fail(bus != NULL, -1);
+
+	gboolean sended = ubuntu_app_launch_helper_set_exec(exec, dir);
+	g_free(exec);
+	g_free(dir);
+
+	/* Ensuring the messages get on the bus before we quit */
+	g_dbus_connection_flush_sync(bus, NULL, NULL);
+	g_clear_object(&bus);
+
+	if (sended) {
+		return 0;
+	} else {
+		g_critical("Unable to send exec to Upstart");
+		return -1;
+	}
+}

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-01-09 16:11:45 +0000
+++ tests/CMakeLists.txt	2015-06-08 15:28:16 +0000
@@ -34,6 +34,23 @@
 )
 
 ###########################
+# Mir Mock Lib
+###########################
+
+add_library(mir-mock-lib SHARED
+	mir-mock.h
+	mir-mock.cpp)
+
+target_link_libraries(mir-mock-lib
+	-lpthread
+	${GLIB2_LIBRARIES}
+)
+
+set_target_properties(mir-mock-lib PROPERTIES
+	OUTPUT_NAME "mir-mock"
+)
+
+###########################
 # Dispatcher test
 ###########################
 
@@ -55,7 +72,7 @@
 
 include_directories("${CMAKE_BINARY_DIR}/service")
 
-add_executable (app-id-test app-id-test.cc "${CMAKE_SOURCE_DIR}/service/dispatcher.c")
+add_executable (app-id-test app-id-test.cc)
 target_link_libraries (app-id-test
 	dispatcher-lib
 	mock-lib
@@ -128,3 +145,32 @@
 
 add_test (url-db-test url-db-test)
 add_subdirectory(url_dispatcher_testability)
+
+###########################
+# exec tool test
+###########################
+
+add_executable (exec-tool-test exec-tool-test.cc)
+target_link_libraries (exec-tool-test
+	gtest
+	${GTEST_LIBS}
+	${GIO2_LIBRARIES}
+	${DBUSTEST_LIBRARIES})
+
+add_test (exec-tool-test exec-tool-test)
+
+###########################
+# overlay tracker test
+###########################
+
+add_executable (overlay-tracker-test overlay-tracker-test.cpp)
+target_link_libraries (overlay-tracker-test
+	dispatcher-lib
+	mir-mock-lib
+	mock-lib
+	gtest
+	${GTEST_LIBS}
+	${GIO2_LIBRARIES}
+	${DBUSTEST_LIBRARIES})
+
+add_test (overlay-tracker-test overlay-tracker-test)

=== modified file 'tests/app-id-test.cc'
--- tests/app-id-test.cc	2014-10-28 09:49:29 +0000
+++ tests/app-id-test.cc	2015-06-08 15:28:16 +0000
@@ -21,6 +21,7 @@
 #include <gtest/gtest.h>
 #include "dispatcher.h"
 #include "ubuntu-app-launch-mock.h"
+#include "overlay-tracker-mock.h"
 
 class AppIdTest : public ::testing::Test
 {
@@ -28,6 +29,7 @@
 		GTestDBus * testbus = nullptr;
 		GMainLoop * mainloop = nullptr;
 		gchar * cachedir = nullptr;
+		OverlayTrackerMock tracker;
 
 	protected:
 		virtual void SetUp() {
@@ -41,7 +43,7 @@
 			g_test_dbus_up(testbus);
 
 			mainloop = g_main_loop_new(nullptr, FALSE);
-			dispatcher_init(mainloop);
+			dispatcher_init(mainloop, reinterpret_cast<OverlayTracker *>(&tracker));
 
 			return;
 		}

=== modified file 'tests/dispatcher-test.cc'
--- tests/dispatcher-test.cc	2015-01-09 16:11:45 +0000
+++ tests/dispatcher-test.cc	2015-06-08 15:28:16 +0000
@@ -21,6 +21,7 @@
 #include <gtest/gtest.h>
 #include "dispatcher.h"
 #include "ubuntu-app-launch-mock.h"
+#include "overlay-tracker-mock.h"
 #include "url-db.h"
 
 class DispatcherTest : public ::testing::Test
@@ -31,9 +32,13 @@
 		gchar * cachedir = nullptr;
 
 	protected:
+		OverlayTrackerMock tracker;
+		GDBusConnection * session = nullptr;
+
 		virtual void SetUp() {
 			g_setenv("TEST_CLICK_DB", "click-db", TRUE);
 			g_setenv("TEST_CLICK_USER", "test-user", TRUE);
+			g_setenv("URL_DISPATCHER_OVERLAY_DIR", OVERLAY_TEST_DIR, TRUE);
 
 			cachedir = g_build_filename(CMAKE_BINARY_DIR, "dispatcher-test-cache", nullptr);
 			g_setenv("URL_DISPATCHER_CACHE_DIR", cachedir, TRUE);
@@ -66,8 +71,10 @@
 			testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
 			g_test_dbus_up(testbus);
 
+			session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+
 			mainloop = g_main_loop_new(nullptr, FALSE);
-			dispatcher_init(mainloop);
+			dispatcher_init(mainloop, reinterpret_cast<OverlayTracker *>(&tracker));
 
 			return;
 		}
@@ -87,6 +94,8 @@
 			/* let other threads settle */
 			g_usleep(500000);
 
+			g_clear_object(&session);
+
 			g_test_dbus_down(testbus);
 			g_object_unref(testbus);
 
@@ -250,3 +259,18 @@
 
 	return;
 }
+
+TEST_F(DispatcherTest, OverlayTest)
+{
+	EXPECT_TRUE(dispatcher_is_overlay("mock-overlay"));
+	EXPECT_FALSE(dispatcher_is_overlay("not-overlay"));
+
+	EXPECT_TRUE(dispatcher_send_to_overlay ("mock-overlay", "overlay://ubuntu.com", session, g_dbus_connection_get_unique_name(session)));
+
+	ASSERT_EQ(1, tracker.addedOverlays.size());
+	EXPECT_EQ("mock-overlay", std::get<0>(tracker.addedOverlays[0]));
+	EXPECT_EQ(getpid(), std::get<1>(tracker.addedOverlays[0]));
+	EXPECT_EQ("overlay://ubuntu.com", std::get<2>(tracker.addedOverlays[0]));
+
+	return;
+}

=== added file 'tests/exec-tool-test.cc'
--- tests/exec-tool-test.cc	1970-01-01 00:00:00 +0000
+++ tests/exec-tool-test.cc	2015-06-08 15:28:16 +0000
@@ -0,0 +1,111 @@
+/**
+ * Copyright © 2013-2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "test-config.h"
+
+#include <gio/gio.h>
+#include <gtest/gtest.h>
+#include <libdbustest/dbus-test.h>
+
+class ExecToolTest : public ::testing::Test
+{
+	protected:
+		DbusTestService * service = nullptr;
+		DbusTestDbusMock * mock = nullptr;
+		DbusTestDbusMockObject * obj = nullptr;
+		GDBusConnection * bus = nullptr;
+
+		virtual void SetUp() {
+			g_setenv("URL_DISPATCHER_DISABLE_RECOVERABLE_ERROR", "1", TRUE);
+			g_setenv("URL_DISPATCHER_OVERLAY_DIR", OVERLAY_TEST_DIR, TRUE);
+
+			service = dbus_test_service_new(nullptr);
+
+			/* Upstart Mock */
+			mock = dbus_test_dbus_mock_new("com.ubuntu.Upstart");
+			obj = dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", nullptr);
+
+			dbus_test_dbus_mock_object_add_method(mock, obj,
+				"SetEnv",
+				G_VARIANT_TYPE("(assb)"),
+				NULL,
+				"",
+				NULL);
+
+			dbus_test_task_set_name(DBUS_TEST_TASK(mock), "Upstart");
+			dbus_test_service_add_task(service, DBUS_TEST_TASK(mock));
+
+			/* Start your engines! */
+			dbus_test_service_start_tasks(service);
+
+			bus = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, nullptr);
+			g_dbus_connection_set_exit_on_close(bus, FALSE);
+			g_object_add_weak_pointer(G_OBJECT(bus), (gpointer *)&bus);
+			return;
+		}
+
+		virtual void TearDown() {
+			/* dbustest should probably do this, not sure */
+
+			g_clear_object(&mock);
+			g_clear_object(&service);
+
+			g_object_unref(bus);
+
+			unsigned int cleartry = 0;
+			while (bus != nullptr && cleartry < 100) {
+				pause(100);
+				cleartry++;
+			}
+
+			return;
+		}
+		
+		static gboolean quit_loop (gpointer ploop) {
+			g_main_loop_quit((GMainLoop *)ploop);
+			return FALSE;
+		}
+
+		void pause (int time) {
+			GMainLoop * loop = g_main_loop_new(nullptr, FALSE);
+			g_timeout_add(time, quit_loop, loop);
+			g_main_loop_run(loop);
+			g_main_loop_unref(loop);
+		}
+};
+
+TEST_F(ExecToolTest, SetOverlay)
+{
+	g_unsetenv("APP_ID");
+	gint retval = 0;
+	EXPECT_TRUE(g_spawn_command_line_sync(EXEC_TOOL, nullptr, nullptr, &retval, nullptr));
+	EXPECT_NE(0, retval);
+
+	g_setenv("APP_ID", "mock-overlay", TRUE);
+	g_setenv("UPSTART_JOB", "fubar", TRUE);
+	EXPECT_TRUE(g_spawn_command_line_sync(EXEC_TOOL, nullptr, nullptr, &retval, nullptr));
+	EXPECT_EQ(0, retval);
+
+	guint len = 0;
+	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "SetEnv", &len, NULL);
+	ASSERT_NE(nullptr, calls);
+	ASSERT_EQ(1, len);
+
+	GVariant * appexecenv = g_variant_get_child_value(calls[0].params, 1);
+	EXPECT_STREQ("APP_EXEC=foobar", g_variant_get_string(appexecenv, nullptr));
+	g_variant_unref(appexecenv);
+}

=== added file 'tests/mir-mock.cpp'
--- tests/mir-mock.cpp	1970-01-01 00:00:00 +0000
+++ tests/mir-mock.cpp	2015-06-08 15:28:16 +0000
@@ -0,0 +1,124 @@
+/**
+ * Copyright © 2015 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/>.
+ *
+ */
+
+#include "mir-mock.h"
+
+#include <iostream>
+#include <thread>
+
+MirPromptSession * mir_mock_valid_trust_session = (MirPromptSession *)"In the circle of trust";
+static bool valid_trust_connection = true;
+static int trusted_fd = 1234;
+MirPromptSession * mir_mock_last_released_session = NULL;
+pid_t mir_mock_last_trust_pid = 0;
+void (*mir_mock_last_trust_func)(MirPromptSession *, MirPromptSessionState, void*data) = NULL;
+void * mir_mock_last_trust_data = NULL;
+
+MirPromptSession *
+mir_connection_create_prompt_session_sync(MirConnection * connection, pid_t pid, void (*func)(MirPromptSession *, MirPromptSessionState, void*data), void * context) {
+	mir_mock_last_trust_pid = pid;
+	mir_mock_last_trust_func = func;
+	mir_mock_last_trust_data = context;
+
+	if (valid_trust_connection) {
+		return mir_mock_valid_trust_session;
+	} else {
+		return nullptr;
+	}
+}
+
+void
+mir_prompt_session_release_sync (MirPromptSession * session)
+{
+	mir_mock_last_released_session = session;
+	if (session != mir_mock_valid_trust_session) {
+		std::cerr << "Releasing a Mir Trusted Prompt that isn't valid" << std::endl;
+		exit(1);
+	}
+}
+
+MirWaitHandle *
+mir_prompt_session_new_fds_for_prompt_providers (MirPromptSession * session, unsigned int numfds, mir_client_fd_callback cb, void * data) {
+	if (session != mir_mock_valid_trust_session) {
+		std::cerr << "Releasing a Mir Trusted Prompt that isn't valid" << std::endl;
+		exit(1);
+	}
+
+	/* TODO: Put in another thread to be more mir like */
+	std::thread * thread = new std::thread([session, numfds, cb, data]() {
+		int fdlist[numfds];
+
+		for (unsigned int i = 0; i < numfds; i++) 
+			fdlist[i] = trusted_fd;
+
+		cb(session, numfds, fdlist, data);
+	});
+
+	return reinterpret_cast<MirWaitHandle *>(thread);
+}
+
+void
+mir_wait_for (MirWaitHandle * wait)
+{
+	auto thread = reinterpret_cast<std::thread *>(wait);
+
+	if (thread->joinable())
+		thread->join();
+
+	delete thread;
+}
+
+static const char * valid_connection_str = "Valid Mir Connection";
+static std::pair<std::string, std::string> last_connection;
+static bool valid_connection = true;
+
+void
+mir_mock_connect_return_valid (bool valid)
+{
+	valid_connection = valid;
+}
+
+std::pair<std::string, std::string>
+mir_mock_connect_last_connect (void)
+{
+	return last_connection;
+}
+
+MirConnection *
+mir_connect_sync (char const * server, char const * appname)
+{
+	last_connection = std::pair<std::string, std::string>(server, appname);
+
+	if (valid_connection) {
+		return (MirConnection *)(valid_connection_str);
+	} else {
+		return nullptr;
+	}
+}
+
+void
+mir_connection_release (MirConnection * con)
+{
+	if (reinterpret_cast<char *>(con) != valid_connection_str) {
+		std::cerr << "Releasing a Mir Connection that isn't valid" << std::endl;
+		exit(1);
+	}
+}
+
+void mir_mock_set_trusted_fd (int fd)
+{
+	trusted_fd = fd;
+}

=== added file 'tests/mir-mock.h'
--- tests/mir-mock.h	1970-01-01 00:00:00 +0000
+++ tests/mir-mock.h	2015-06-08 15:28:16 +0000
@@ -0,0 +1,36 @@
+/**
+ * Copyright © 2015 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/>.
+ *
+ */
+
+#ifndef MIR_MOCK_H
+#define MIR_MOCK_H 1
+
+#include <string>
+#include <utility>
+
+#include <mir_toolkit/mir_connection.h>
+#include <mir_toolkit/mir_prompt_session.h>
+
+void mir_mock_connect_return_valid (bool valid);
+std::pair<std::string, std::string> mir_mock_connect_last_connect (void);
+void mir_mock_set_trusted_fd (int fd);
+
+extern MirPromptSession * mir_mock_valid_trust_session;
+extern MirPromptSession * mir_mock_last_released_session;
+extern pid_t mir_mock_last_trust_pid;
+extern void (*mir_mock_last_trust_func)(MirPromptSession *, MirPromptSessionState, void*data);
+extern void * mir_mock_last_trust_data;
+
+#endif // MIR_MOCK_H

=== added directory 'tests/overlay-dir'
=== added file 'tests/overlay-dir/mock-overlay.desktop'
--- tests/overlay-dir/mock-overlay.desktop	1970-01-01 00:00:00 +0000
+++ tests/overlay-dir/mock-overlay.desktop	2015-06-08 15:28:16 +0000
@@ -0,0 +1,2 @@
+[Desktop Entry]
+Exec=foobar

=== added file 'tests/overlay-tracker-mock.h'
--- tests/overlay-tracker-mock.h	1970-01-01 00:00:00 +0000
+++ tests/overlay-tracker-mock.h	2015-06-08 15:28:16 +0000
@@ -0,0 +1,30 @@
+/**
+ * Copyright © 2015 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/>.
+ *
+ */
+
+#pragma once
+#include "overlay-tracker-iface.h"
+#include <utility>
+
+class OverlayTrackerMock : public OverlayTrackerIface
+{
+	public:
+		std::vector<std::tuple<std::string, unsigned long, std::string>> addedOverlays;
+
+		bool addOverlay (const char * appid, unsigned long pid, const char * url) {
+			addedOverlays.push_back(std::make_tuple(std::string(appid), pid, std::string(url)));
+			return true;
+		}
+};

=== added file 'tests/overlay-tracker-test.cpp'
--- tests/overlay-tracker-test.cpp	1970-01-01 00:00:00 +0000
+++ tests/overlay-tracker-test.cpp	2015-06-08 15:28:16 +0000
@@ -0,0 +1,127 @@
+/**
+ * Copyright © 2015 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/>.
+ *
+ */
+
+#include <random>
+
+#include "test-config.h"
+
+#include <gio/gio.h>
+#include <gtest/gtest.h>
+#include <libdbustest/dbus-test.h>
+
+#include "overlay-tracker-mir.h"
+#include "ubuntu-app-launch-mock.h"
+#include "mir-mock.h"
+
+class OverlayTrackerTest : public ::testing::Test
+{
+	protected:
+		virtual void SetUp() {
+			g_setenv("URL_DISPATCHER_DISABLE_RECOVERABLE_ERROR", "1", TRUE);
+
+			return;
+		}
+
+		virtual void TearDown() {
+			return;
+		}
+
+		static gboolean quit_loop (gpointer ploop) {
+			g_main_loop_quit((GMainLoop *)ploop);
+			return FALSE;
+		}
+
+		void pause (int time) {
+			GMainLoop * loop = g_main_loop_new(nullptr, FALSE);
+			g_timeout_add(time, quit_loop, loop);
+			g_main_loop_run(loop);
+			g_main_loop_unref(loop);
+		}
+};
+
+TEST_F(OverlayTrackerTest, BasicCreation) {
+	auto tracker = new OverlayTrackerMir();
+	delete tracker;
+}
+
+TEST_F(OverlayTrackerTest, AddOverlay) {
+	auto tracker = new OverlayTrackerMir();
+
+	auto mirconn = mir_mock_connect_last_connect();
+	EXPECT_EQ("mir_socket_trusted", mirconn.first.substr(mirconn.first.size() - 18));
+	EXPECT_EQ("url-dispatcher", mirconn.second);
+
+	EXPECT_TRUE(tracker->addOverlay("app-id", 5, "http://no-name-yet.com"));
+
+	EXPECT_EQ(5, mir_mock_last_trust_pid);
+
+	EXPECT_STREQ("url-overlay", ubuntu_app_launch_mock_last_start_session_helper);
+	EXPECT_STREQ("app-id", ubuntu_app_launch_mock_last_start_session_appid);
+	EXPECT_STREQ("http://no-name-yet.com", ubuntu_app_launch_mock_last_start_session_uris[0]);
+
+	delete tracker;
+
+	EXPECT_STREQ("url-overlay", ubuntu_app_launch_mock_last_stop_helper);
+	EXPECT_STREQ("app-id", ubuntu_app_launch_mock_last_stop_appid);
+	EXPECT_STREQ("instance", ubuntu_app_launch_mock_last_stop_instance);
+}
+
+TEST_F(OverlayTrackerTest, OverlayABunch) {
+	OverlayTrackerMir tracker;
+	std::uniform_int_distribution<> randpid(1, 32000);
+	std::mt19937 rand;
+
+	/* Testing adding a bunch of overlays, we're using pretty standard
+	   data structures, but let's make sure we didn't break 'em */
+	for (auto name : std::vector<std::string>{"warty", "hoary", "breezy", "dapper", "edgy", "feisty", "gutsy", "hardy", "intrepid", "jaunty", "karmic", "lucid", "maverick", "natty", "oneiric", "precise", "quantal", "raring", "saucy", "trusty", "utopic", "vivid", "wily"}) {
+		int pid = randpid(rand);
+		tracker.addOverlay(name.c_str(), pid, "http://ubuntu.com/releases");
+
+		EXPECT_EQ(pid, mir_mock_last_trust_pid);
+		EXPECT_EQ(name, ubuntu_app_launch_mock_last_start_session_appid);
+	}
+}
+
+TEST_F(OverlayTrackerTest, UALSignalStop) {
+	OverlayTrackerMir tracker;
+
+	/* Call with the overlay before it is set */
+	ubuntu_app_launch_mock_observer_helper_stop_func("app-id", "instance", "url-overlay", ubuntu_app_launch_mock_observer_helper_stop_user_data);
+
+	EXPECT_TRUE(tracker.addOverlay("app-id", 5, "http://no-name-yet.com"));
+
+	mir_mock_last_released_session = nullptr;
+	ubuntu_app_launch_mock_observer_helper_stop_func("app-id", "instance", "url-overlay", ubuntu_app_launch_mock_observer_helper_stop_user_data);
+	EXPECT_NE(nullptr, mir_mock_last_released_session);
+}
+
+TEST_F(OverlayTrackerTest, MirSignalStop) {
+	OverlayTrackerMir tracker;
+
+	EXPECT_TRUE(tracker.addOverlay("app-id", 5, "http://no-name-yet.com"));
+
+	/* Try a badie */
+	mir_mock_last_trust_func((MirPromptSession *)1337, mir_prompt_session_state_stopped, mir_mock_last_trust_data);
+
+	EXPECT_NE(nullptr, mir_mock_last_trust_func);
+	mir_mock_last_trust_func(mir_mock_valid_trust_session, mir_prompt_session_state_stopped, mir_mock_last_trust_data);
+
+	pause(100);
+
+	EXPECT_STREQ("url-overlay", ubuntu_app_launch_mock_last_stop_helper);
+	EXPECT_STREQ("app-id", ubuntu_app_launch_mock_last_stop_appid);
+	EXPECT_STREQ("instance", ubuntu_app_launch_mock_last_stop_instance);
+}

=== modified file 'tests/service-test.cc'
--- tests/service-test.cc	2014-10-28 12:46:32 +0000
+++ tests/service-test.cc	2015-06-08 15:28:16 +0000
@@ -39,6 +39,7 @@
 			g_setenv("UBUNTU_APP_LAUNCH_USE_SESSION", "1", TRUE);
 			g_setenv("URL_DISPATCHER_DISABLE_RECOVERABLE_ERROR", "1", TRUE);
 			g_setenv("XDG_DATA_DIRS", XDG_DATA_DIRS, TRUE);
+			g_setenv("LD_PRELOAD", MIR_MOCK_PATH, TRUE);
 
 			SetUpDb();
 
@@ -94,10 +95,6 @@
 		}
 
 		virtual void TearDown() {
-			/* dbustest should probably do this, not sure */
-			kill(dbus_test_process_get_pid(dispatcher), SIGTERM);
-			g_usleep(50000);
-
 			g_clear_object(&dispatcher);
 			g_clear_object(&mock);
 			g_clear_object(&dashmock);
@@ -107,9 +104,7 @@
 
 			unsigned int cleartry = 0;
 			while (bus != nullptr && cleartry < 100) {
-				g_usleep(100000);
-				while (g_main_pending())
-					g_main_iteration(TRUE);
+				pause(100);
 				cleartry++;
 			}
 
@@ -249,7 +244,7 @@
 }
 
 void
-focus_signal_cb (GDBusConnection */*connection*/, const gchar */*sender_name*/, const gchar */*object_path*/, const gchar */*interface_name*/, const gchar */*signal_name*/, GVariant */*parameters*/, gpointer user_data)
+focus_signal_cb (GDBusConnection * /*connection*/, const gchar * /*sender_name*/, const gchar * /*object_path*/, const gchar * /*interface_name*/, const gchar * /*signal_name*/, GVariant * /*parameters*/, gpointer user_data)
 {
 	guint * focus_count = (guint *)user_data;
 	*focus_count = *focus_count + 1;

=== modified file 'tests/test-config.h.in'
--- tests/test-config.h.in	2015-01-09 16:11:45 +0000
+++ tests/test-config.h.in	2015-06-08 15:28:16 +0000
@@ -10,3 +10,6 @@
 #define UPDATE_DIRECTORY_URLS "@CMAKE_CURRENT_SOURCE_DIR@/test-urls-simple"
 #define UPDATE_DIRECTORY_VARIED "@CMAKE_CURRENT_SOURCE_DIR@/test-urls-varied"
 #define UPDATE_DIRECTORY_INTENT "@CMAKE_CURRENT_SOURCE_DIR@/test-urls-intent"
+#define OVERLAY_TEST_DIR "@CMAKE_CURRENT_SOURCE_DIR@/overlay-dir"
+#define EXEC_TOOL "@CMAKE_BINARY_DIR@/service/exec-tool"
+#define MIR_MOCK_PATH "@CMAKE_CURRENT_BINARY_DIR@/libmir-mock.so"

=== modified file 'tests/ubuntu-app-launch-mock.c'
--- tests/ubuntu-app-launch-mock.c	2014-05-26 12:56:47 +0000
+++ tests/ubuntu-app-launch-mock.c	2015-06-08 15:28:16 +0000
@@ -41,3 +41,68 @@
 {
 	return last_appid;
 }
+
+UbuntuAppLaunchHelperObserver ubuntu_app_launch_mock_observer_helper_stop_func = NULL;
+gchar * ubuntu_app_launch_mock_observer_helper_stop_type = NULL;
+void * ubuntu_app_launch_mock_observer_helper_stop_user_data = NULL;
+
+gboolean
+ubuntu_app_launch_observer_add_helper_stop (UbuntuAppLaunchHelperObserver func, const gchar * type, gpointer user_data)
+{
+	ubuntu_app_launch_mock_observer_helper_stop_func = func;
+	ubuntu_app_launch_mock_observer_helper_stop_type = g_strdup(type);
+	ubuntu_app_launch_mock_observer_helper_stop_user_data = user_data;
+
+	return TRUE;
+}
+
+gboolean
+ubuntu_app_launch_observer_delete_helper_stop (UbuntuAppLaunchHelperObserver func, const gchar * type, gpointer user_data)
+{
+	gboolean same = ubuntu_app_launch_mock_observer_helper_stop_func == func &&
+		g_strcmp0(ubuntu_app_launch_mock_observer_helper_stop_type, type) == 0 &&
+		ubuntu_app_launch_mock_observer_helper_stop_user_data == user_data;
+	
+	ubuntu_app_launch_mock_observer_helper_stop_func = NULL;
+	g_clear_pointer(&ubuntu_app_launch_mock_observer_helper_stop_type, g_free);
+	ubuntu_app_launch_mock_observer_helper_stop_user_data = NULL;
+
+	return same;
+}
+
+gchar * ubuntu_app_launch_mock_last_start_session_helper = NULL;
+MirPromptSession * ubuntu_app_launch_mock_last_start_session_session = NULL;
+gchar * ubuntu_app_launch_mock_last_start_session_appid = NULL;
+gchar ** ubuntu_app_launch_mock_last_start_session_uris = NULL;
+
+gchar *
+ubuntu_app_launch_start_session_helper (const gchar * type, MirPromptSession * session, const gchar * appid, const gchar * const * uris)
+{
+	g_clear_pointer(&ubuntu_app_launch_mock_last_start_session_helper, g_free);
+	g_clear_pointer(&ubuntu_app_launch_mock_last_start_session_appid, g_free);
+	g_clear_pointer(&ubuntu_app_launch_mock_last_start_session_uris, g_strfreev);
+
+	ubuntu_app_launch_mock_last_start_session_helper = g_strdup(type);
+	ubuntu_app_launch_mock_last_start_session_session = session;
+	ubuntu_app_launch_mock_last_start_session_appid = g_strdup(appid);
+	ubuntu_app_launch_mock_last_start_session_uris = g_strdupv((gchar **)uris);
+
+	return g_strdup("instance");
+}
+
+gchar * ubuntu_app_launch_mock_last_stop_helper = NULL;
+gchar * ubuntu_app_launch_mock_last_stop_appid = NULL;
+gchar * ubuntu_app_launch_mock_last_stop_instance = NULL;
+
+gboolean
+ubuntu_app_launch_stop_multiple_helper (const gchar * helper_type, const gchar * appid, const gchar * instance) {
+	g_clear_pointer(&ubuntu_app_launch_mock_last_stop_helper, g_free);
+	g_clear_pointer(&ubuntu_app_launch_mock_last_stop_appid, g_free);
+	g_clear_pointer(&ubuntu_app_launch_mock_last_stop_instance, g_free);
+
+	ubuntu_app_launch_mock_last_stop_helper = g_strdup(helper_type);
+	ubuntu_app_launch_mock_last_stop_appid = g_strdup(appid);
+	ubuntu_app_launch_mock_last_stop_instance = g_strdup(instance);
+
+	return TRUE;
+}

=== modified file 'tests/ubuntu-app-launch-mock.h'
--- tests/ubuntu-app-launch-mock.h	2014-10-24 18:55:11 +0000
+++ tests/ubuntu-app-launch-mock.h	2015-06-08 15:28:16 +0000
@@ -19,12 +19,24 @@
 #define UPSTART_APP_LAUNCH_MOCK 1
 
 #include <glib.h>
+#include <ubuntu-app-launch.h>
 
 G_BEGIN_DECLS
 
 void ubuntu_app_launch_mock_clear_last_app_id (void);
 gchar * ubuntu_app_launch_mock_get_last_app_id (void);
 
+extern UbuntuAppLaunchHelperObserver ubuntu_app_launch_mock_observer_helper_stop_func;
+extern gchar * ubuntu_app_launch_mock_observer_helper_stop_type;
+extern void * ubuntu_app_launch_mock_observer_helper_stop_user_data;
+extern gchar * ubuntu_app_launch_mock_last_start_session_helper;
+extern MirPromptSession * ubuntu_app_launch_mock_last_start_session_session;
+extern gchar * ubuntu_app_launch_mock_last_start_session_appid;
+extern gchar ** ubuntu_app_launch_mock_last_start_session_uris;
+extern gchar * ubuntu_app_launch_mock_last_stop_helper;
+extern gchar * ubuntu_app_launch_mock_last_stop_appid;
+extern gchar * ubuntu_app_launch_mock_last_stop_instance;
+
 G_END_DECLS
 
 #endif /* UPSTART_APP_LAUNCH_MOCK */