Merge lp:~ted/ubuntu-app-launch/log-file into lp:ubuntu-app-launch/14.04

[Ted Gould]

Function to get the log file for the application

Small function for QA so they don't have to know what is a Click app and what is not. Abstracts all that out for them.

[lp:~ted/ubuntu-app-launch/log-file]

142. By Ted Gould on 2014-02-11

Merge future trunk

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-01-06 15:21:25 +0000
+++ CMakeLists.txt	2014-02-06 18:42:36 +0000
@@ -51,9 +51,12 @@
 pkg_check_modules(ZEITGEIST REQUIRED zeitgeist-2.0)
 include_directories(${ZEITGEIST_INCLUDE_DIRS})
 
-pkg_check_modules(LIBUPSTART REQUIRED libupstart libnih libnih-dbus dbus-1)
+pkg_check_modules(LIBUPSTART REQUIRED libupstart)
 include_directories(${LIBUPSTART_INCLUDE_DIRS})
 
+pkg_check_modules(DBUS REQUIRED dbus-1)
+include_directories(${DBUS_INCLUDE_DIRS})
+
 pkg_check_modules(DBUSTEST REQUIRED dbustest-1>=14.04.0)
 include_directories(${DBUSTEST_INCLUDE_DIRS})
 
@@ -68,7 +71,7 @@
 # Helpers
 ####################
 
-add_library(helpers STATIC helpers.c)
+add_library(helpers STATIC helpers.c helpers-keyfile.c)
 target_link_libraries(helpers ${GIO2_LIBRARIES} ${JSONGLIB_LIBRARIES})
 
 ####################
@@ -146,16 +149,6 @@
 install(TARGETS desktop-hook RUNTIME DESTINATION "${pkglibexecdir}")
 
 ####################
-# desktop-single
-####################
-
-add_lttng_gen_tp(NAME desktop-single-trace)
-add_executable(desktop-single desktop-single.c desktop-single-trace.c)
-set_target_properties(desktop-single PROPERTIES OUTPUT_NAME "desktop-single")
-target_link_libraries(desktop-single helpers ${LTTNG_LIBRARIES})
-install(TARGETS desktop-single RUNTIME DESTINATION "${pkglibexecdir}")
-
-####################
 # exec-line-exec
 ####################
 
@@ -175,18 +168,14 @@
 target_link_libraries(zg-report-app ${ZEITGEIST_LIBRARIES} ${GOBJECT2_LIBRARIES} ${GLIB2_LIBRARIES})
 install(TARGETS zg-report-app RUNTIME DESTINATION "${pkglibexecdir}")
 
-#######################
-# second-exec
-#######################
-
-add_lttng_gen_tp(NAME second-exec-trace)
-add_library(second-exec-core STATIC second-exec-core.c second-exec-trace.c)
-target_link_libraries(second-exec-core helpers upstart-launcher ${LTTNG_LIBRARIES})
-
-add_executable(second-exec second-exec.c)
-set_target_properties(second-exec PROPERTIES OUTPUT_NAME "second-exec")
-target_link_libraries(second-exec second-exec-core)
-install(TARGETS second-exec RUNTIME DESTINATION "${pkglibexecdir}")
+####################
+# application-job
+####################
+
+add_executable(application-job application-job.c)
+set_target_properties(application-job PROPERTIES OUTPUT_NAME "application-job")
+target_link_libraries(application-job upstart-launcher)
+install(TARGETS application-job RUNTIME DESTINATION "${pkglibexecdir}")
 
 ####################
 # application.conf

=== added file 'application-job.c'
--- application-job.c	1970-01-01 00:00:00 +0000
+++ application-job.c	2014-02-06 18:42:36 +0000
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2013 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 <gio/gio.h>
+#include "libupstart-app-launch/upstart-app-launch.h"
+
+int retval = 0;
+const gchar * global_appid;
+
+static void
+app_started (const gchar * appid, gpointer user_data)
+{
+	if (g_strcmp0(appid, global_appid) != 0)
+		return;
+	g_debug("Application Started: %s", appid);
+	g_main_loop_quit((GMainLoop *)user_data);
+}
+
+static void
+app_focus (const gchar * appid, gpointer user_data)
+{
+	if (g_strcmp0(appid, global_appid) != 0)
+		return;
+	g_debug("Application Focused");
+	g_main_loop_quit((GMainLoop *)user_data);
+}
+
+static void
+app_failed (const gchar * appid, upstart_app_launch_app_failed_t failure_type, gpointer user_data)
+{
+	if (g_strcmp0(appid, global_appid) != 0)
+		return;
+	g_warning("Application Startup Failed");
+	retval = 1;
+	g_main_loop_quit((GMainLoop *)user_data);
+}
+
+int
+main (int argc, char * argv[])
+{
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	g_return_val_if_fail(con != NULL, 1);
+
+	global_appid = g_getenv("APP_ID");
+	g_return_val_if_fail(global_appid != NULL, 1);
+
+	const gchar * uris_str = g_getenv("APP_URIS");
+	gchar ** uris = NULL;
+	if (uris_str != NULL) {
+		GError * error = NULL;
+		gint uri_count = 0;
+		g_shell_parse_argv(uris_str, &uri_count, &uris, &error);
+
+		if (error != NULL) {
+			g_warning("Unable to parse uris '%s': %s", uris_str, error->message);
+			g_error_free(error);
+		} else {
+			g_debug("Got %d URIs", uri_count);
+		}
+	}
+
+	GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
+
+	upstart_app_launch_observer_add_app_started(app_started, mainloop);
+	upstart_app_launch_observer_add_app_focus(app_focus, mainloop);
+	upstart_app_launch_observer_add_app_failed(app_failed, mainloop);
+
+	g_debug("Start Application: %s", global_appid);
+	g_return_val_if_fail(upstart_app_launch_start_application(global_appid, (const gchar * const *)uris), -1);
+	g_strfreev(uris);
+
+	g_debug("Wait for results");
+	g_main_loop_run(mainloop);
+
+	upstart_app_launch_observer_delete_app_started(app_started, mainloop);
+	upstart_app_launch_observer_delete_app_focus(app_focus, mainloop);
+	upstart_app_launch_observer_delete_app_failed(app_failed, mainloop);
+
+	g_main_loop_unref(mainloop);
+	g_object_unref(con);
+
+	return retval;
+}

=== modified file 'application.conf.in'
--- application.conf.in	2014-01-22 22:48:58 +0000
+++ application.conf.in	2014-02-06 18:42:36 +0000
@@ -14,24 +14,4 @@
 env APP_URIS
 export APP_URIS
 
-script
-	CLICK_PKG=`echo "${APP_ID}" | cut -d _ -f 1`
-
-	if [ ! -z $CLICK_PKG ] ; then
-		CLICK_DIR=`click pkgdir "${CLICK_PKG}" 2> /dev/null || true`
-	fi
-
-	if [ ! -z $CLICK_DIR ] && [ -d $CLICK_DIR ] ; then
-		if ! start application-click APP_ID="${APP_ID}" APP_URIS="${APP_URIS}"; then
-			@pkglibexecdir@/second-exec
-		fi
-	else
-		if @pkglibexecdir@/desktop-single $APP_ID ; then
-			if ! start application-legacy APP_ID="${APP_ID}" INSTANCE_ID="" APP_URIS="${APP_URIS}" ; then
-				@pkglibexecdir@/second-exec
-			fi
-		else
-			start application-legacy APP_ID="${APP_ID}" INSTANCE_ID=`date -u +%s` APP_URIS="${APP_URIS}"
-		fi
-	fi
-end script
+exec @pkglibexecdir@/application-job

=== modified file 'debian/libupstart-app-launch2.symbols'
--- debian/libupstart-app-launch2.symbols	2014-01-29 20:08:07 +0000
+++ debian/libupstart-app-launch2.symbols	2014-02-06 18:42:36 +0000
@@ -1,4 +1,5 @@
 libupstart-app-launch.so.2 libupstart-app-launch2 #MINVER#
+ upstart_app_launch_application_log_path@Base 0replaceme
  upstart_app_launch_get_primary_pid@Base 0.2
  upstart_app_launch_list_running_apps@Base 0.2
  upstart_app_launch_observer_add_app_failed@Base 0.2

=== removed file 'desktop-single-trace.tp'
--- desktop-single-trace.tp	2013-12-04 17:10:57 +0000
+++ desktop-single-trace.tp	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-
-TRACEPOINT_EVENT(upstart_app_launch, desktop_single_start, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, desktop_single_found, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, desktop_single_finished, TP_ARGS(0), TP_FIELDS())
-

=== removed file 'desktop-single.c'
--- desktop-single.c	2013-12-05 17:08:13 +0000
+++ desktop-single.c	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-/*
- * Copyright 2013 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 "helpers.h"
-#include "desktop-single-trace.h"
-
-int
-main (int argc, char * argv[])
-{
-	/* Nothing is single instance yet */
-	if (argc != 2) {
-		g_error("Should be called as: %s <app_id>", argv[0]);
-		return 1;
-	}
-
-	g_setenv("LTTNG_UST_REGISTER_TIMEOUT", "0", FALSE); /* Set to zero if not set */
-	tracepoint(upstart_app_launch, desktop_single_start);
-
-	GKeyFile * keyfile = keyfile_for_appid(argv[1], NULL);
-
-	if (keyfile == NULL) {
-		g_error("Unable to find keyfile for application '%s'", argv[0]);
-		return 1;
-	}
-
-	tracepoint(upstart_app_launch, desktop_single_found);
-
-	gboolean singleinstance = FALSE;
-
-	if (g_key_file_has_key(keyfile, "Desktop Entry", "X-Ubuntu-Single-Instance", NULL)) {
-		GError * error = NULL;
-
-		singleinstance = g_key_file_get_boolean(keyfile, "Desktop Entry", "X-Ubuntu-Single-Instance", &error);
-
-		if (error != NULL) {
-			g_warning("Unable to get single instance key for app '%s': %s", argv[1], error->message);
-			g_error_free(error);
-			/* Ensure that if we got an error, we assume standard case */
-			singleinstance = FALSE;
-		}
-	}
-	
-	g_key_file_free(keyfile);
-
-	tracepoint(upstart_app_launch, desktop_single_finished);
-
-	if (singleinstance) {
-		return 0;
-	} else {
-		return 1;
-	}
-}

=== added file 'helpers-keyfile.c'
--- helpers-keyfile.c	1970-01-01 00:00:00 +0000
+++ helpers-keyfile.c	2014-02-06 18:42:36 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2013 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 "helpers.h"
+
+/* Check to make sure we have the sections and keys we want */
+static gboolean
+verify_keyfile (GKeyFile * inkeyfile, const gchar * desktop)
+{
+	if (inkeyfile == NULL) return FALSE;
+
+	if (!g_key_file_has_group(inkeyfile, "Desktop Entry")) {
+		g_warning("Desktop file '%s' is missing the 'Desktop Entry' group", desktop);
+		return FALSE;
+	}
+
+	if (!g_key_file_has_key(inkeyfile, "Desktop Entry", "Exec", NULL)) {
+		g_warning("Desktop file '%s' is missing the 'Exec' key", desktop);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/* Try to find a desktop file in a particular data directory */
+static GKeyFile *
+try_dir (const char * dir, const gchar * desktop)
+{
+	gchar * fullpath = g_build_filename(dir, "applications", desktop, NULL);
+	GKeyFile * keyfile = g_key_file_new();
+
+	/* NOTE: Leaving off the error here as we'll get a bunch of them,
+	   so individuals aren't really useful */
+	gboolean loaded = g_key_file_load_from_file(keyfile, fullpath, G_KEY_FILE_NONE, NULL);
+
+	g_free(fullpath);
+
+	if (!loaded) {
+		g_key_file_free(keyfile);
+		return NULL;
+	}
+
+	if (!verify_keyfile(keyfile, desktop)) {
+		g_key_file_free(keyfile);
+		return NULL;
+	}
+
+	return keyfile;
+}
+
+/* Find the keyfile that we need for a particular AppID and return it.
+   Or NULL if we can't find it. */
+GKeyFile *
+keyfile_for_appid (const gchar * appid, gchar ** desktopfile)
+{
+	gchar * desktop = g_strdup_printf("%s.desktop", appid);
+
+	const char * const * data_dirs = g_get_system_data_dirs();
+	GKeyFile * keyfile = NULL;
+	int i;
+
+	keyfile = try_dir(g_get_user_data_dir(), desktop);
+	if (keyfile != NULL && desktopfile != NULL && *desktopfile == NULL) {
+		*desktopfile = g_build_filename(g_get_user_data_dir(), "applications", desktop, NULL);
+	}
+
+	for (i = 0; data_dirs[i] != NULL && keyfile == NULL; i++) {
+		keyfile = try_dir(data_dirs[i], desktop);
+
+		if (keyfile != NULL && desktopfile != NULL && *desktopfile == NULL) {
+			*desktopfile = g_build_filename(data_dirs[i], "applications", desktop, NULL);
+		}
+	}
+
+	g_free(desktop);
+
+	return keyfile;
+}
+

=== modified file 'helpers.c'
--- helpers.c	2013-12-12 16:57:37 +0000
+++ helpers.c	2014-02-06 18:42:36 +0000
@@ -468,80 +468,6 @@
 	return newargv;
 }
 
-/* Check to make sure we have the sections and keys we want */
-static gboolean
-verify_keyfile (GKeyFile * inkeyfile, const gchar * desktop)
-{
-	if (inkeyfile == NULL) return FALSE;
-
-	if (!g_key_file_has_group(inkeyfile, "Desktop Entry")) {
-		g_warning("Desktop file '%s' is missing the 'Desktop Entry' group", desktop);
-		return FALSE;
-	}
-
-	if (!g_key_file_has_key(inkeyfile, "Desktop Entry", "Exec", NULL)) {
-		g_warning("Desktop file '%s' is missing the 'Exec' key", desktop);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-/* Try to find a desktop file in a particular data directory */
-static GKeyFile *
-try_dir (const char * dir, const gchar * desktop)
-{
-	gchar * fullpath = g_build_filename(dir, "applications", desktop, NULL);
-	GKeyFile * keyfile = g_key_file_new();
-
-	/* NOTE: Leaving off the error here as we'll get a bunch of them,
-	   so individuals aren't really useful */
-	gboolean loaded = g_key_file_load_from_file(keyfile, fullpath, G_KEY_FILE_NONE, NULL);
-
-	g_free(fullpath);
-
-	if (!loaded) {
-		g_key_file_free(keyfile);
-		return NULL;
-	}
-
-	if (!verify_keyfile(keyfile, desktop)) {
-		g_key_file_free(keyfile);
-		return NULL;
-	}
-
-	return keyfile;
-}
-
-/* Find the keyfile that we need for a particular AppID and return it.
-   Or NULL if we can't find it. */
-GKeyFile *
-keyfile_for_appid (const gchar * appid, gchar ** desktopfile)
-{
-	gchar * desktop = g_strdup_printf("%s.desktop", appid);
-
-	const char * const * data_dirs = g_get_system_data_dirs();
-	GKeyFile * keyfile = NULL;
-	int i;
-
-	keyfile = try_dir(g_get_user_data_dir(), desktop);
-	if (keyfile != NULL && desktopfile != NULL && *desktopfile == NULL) {
-		*desktopfile = g_build_filename(g_get_user_data_dir(), "applications", desktop, NULL);
-	}
-
-	for (i = 0; data_dirs[i] != NULL && keyfile == NULL; i++) {
-		keyfile = try_dir(data_dirs[i], desktop);
-
-		if (keyfile != NULL && desktopfile != NULL && *desktopfile == NULL) {
-			*desktopfile = g_build_filename(data_dirs[i], "applications", desktop, NULL);
-		}
-	}
-
-	g_free(desktop);
-
-	return keyfile;
-}
-
 /* Set environment various variables to make apps work under
  * confinement according to:
  * https://wiki.ubuntu.com/SecurityTeam/Specifications/ApplicationConfinement

=== modified file 'libupstart-app-launch/CMakeLists.txt'
--- libupstart-app-launch/CMakeLists.txt	2014-01-13 15:16:24 +0000
+++ libupstart-app-launch/CMakeLists.txt	2014-02-06 18:42:36 +0000
@@ -1,4 +1,7 @@
 
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
 ##########################
 # Version Info
 ##########################
@@ -11,6 +14,8 @@
 # Library
 ##########################
 
+add_lttng_gen_tp(NAME upstart-app-launch-trace)
+
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
 
 set(LAUNCHER_HEADERS
@@ -19,6 +24,9 @@
 
 set(LAUNCHER_SOURCES
 upstart-app-launch.c
+second-exec-core.c
+upstart-app-launch-trace.c
+"${CMAKE_SOURCE_DIR}/helpers-keyfile.c"
 )
 
 add_library(upstart-launcher SHARED ${LAUNCHER_SOURCES})
@@ -34,6 +42,7 @@
 	${GOBJECT2_LIBRARIES}
 	${LIBUPSTART_LIBRARIES}
 	${GIO2_LIBRARIES}
+	${LTTNG_LIBRARIES}
 	${JSONGLIB_LIBRARIES}
 	-Wl,--no-undefined
 )

=== renamed file 'second-exec-core.c' => 'libupstart-app-launch/second-exec-core.c'
--- second-exec-core.c	2013-12-06 10:38:35 +0000
+++ libupstart-app-launch/second-exec-core.c	2014-02-06 18:42:36 +0000
@@ -23,18 +23,21 @@
 #include "libupstart-app-launch/upstart-app-launch.h"
 #include "helpers.h"
 #include "second-exec-core.h"
-#include "second-exec-trace.h"
-
-/* Globals */
-GPid app_pid = 0;
-GMainLoop * mainloop = NULL;
-guint connections_open = 0;
-const gchar * appid = NULL;
-const gchar * input_uris = NULL;
-GVariant * app_data = NULL;
-gchar * dbus_path = NULL;
-guint64 unity_starttime = 0;
-guint timer = 0;
+#include "upstart-app-launch-trace.h"
+
+typedef struct {
+	GDBusConnection * bus;
+	gchar * appid;
+	gchar * input_uris;
+	GPid app_pid;
+	guint connections_open;
+	GVariant * app_data;
+	gchar * dbus_path;
+	guint64 unity_starttime;
+	guint timer;
+} second_exec_t;
+
+static void second_exec_complete (second_exec_t * data);
 
 /* Unity didn't respond in time, continue on */
 static gboolean
@@ -42,27 +45,27 @@
 {
 	tracepoint(upstart_app_launch, second_exec_resume_timeout);
 	g_warning("Unity didn't respond in 500ms to resume the app");
-	g_main_loop_quit(mainloop);
+	second_exec_complete(user_data);
 	return G_SOURCE_REMOVE;
 }
 
 /* Lower the connection count and process if it gets to zero */
 static void
-connection_count_dec (void)
+connection_count_dec (second_exec_t * data)
 {
 	tracepoint(upstart_app_launch, second_exec_connection_complete);
-	connections_open--;
-	if (connections_open == 0) {
+	data->connections_open--;
+	if (data->connections_open == 0) {
 		g_debug("Finished finding connections");
 		/* Check time here, either we've already heard from
 		   Unity and we should send the data to the app (quit) or
 		   we should wait some more */
-		guint64 timespent = g_get_monotonic_time() - unity_starttime;
+		guint64 timespent = g_get_monotonic_time() - data->unity_starttime;
 		if (timespent > 500 /* ms */ * 1000 /* ms to us */) {
-			g_main_loop_quit(mainloop);
+			second_exec_complete(data);
 		} else {
 			g_debug("Timer Set");
-			timer = g_timeout_add(500 - (timespent / 1000), timer_cb, NULL);
+			data->timer = g_timeout_add(500 - (timespent / 1000), timer_cb, data);
 		}
 	}
 	return;
@@ -73,18 +76,20 @@
 static void
 unity_resume_cb (GDBusConnection * connection, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
 {
+	second_exec_t * data = (second_exec_t *)user_data;
 	g_debug("Unity Completed Resume");
 	tracepoint(upstart_app_launch, second_exec_resume_complete);
 
-	if (timer != 0) {
-		g_source_remove(timer);
+	if (data->timer != 0) {
+		g_source_remove(data->timer);
+		data->timer = 0;
 	}
 
-	if (connections_open == 0) {
-		g_main_loop_quit(mainloop);
+	if (data->connections_open == 0) {
+		second_exec_complete(data);
 	} else {
 		/* Make it look like we started *forever* ago */
-		unity_starttime = 0;
+		data->unity_starttime = 0;
 	}
 
 	return;
@@ -92,9 +97,9 @@
 
 /* Turn the input string into something we can send to apps */
 static void
-parse_uris (void)
+parse_uris (second_exec_t * data)
 {
-	if (app_data != NULL) {
+	if (data->app_data != NULL) {
 		/* Already done */
 		return;
 	}
@@ -103,11 +108,11 @@
 	gchar ** uri_split = NULL;
 	GError * error = NULL;
 
-	g_shell_parse_argv(input_uris, NULL, &uri_split, &error);
+	g_shell_parse_argv(data->input_uris, NULL, &uri_split, &error);
 
 	if (uri_split == NULL || uri_split[0] == NULL || error != NULL) {
 		if (error != NULL) {
-			g_warning("Unable to parse URLs '%s': %s", input_uris, error->message);
+			g_warning("Unable to parse URLs '%s': %s", data->input_uris, error->message);
 			g_error_free(error);
 		}
 
@@ -136,8 +141,8 @@
 	g_variant_builder_add_value(&tuple, uris);
 	g_variant_builder_add_value(&tuple, platform);
 
-	app_data = g_variant_builder_end(&tuple);
-	g_variant_ref_sink(app_data);
+	data->app_data = g_variant_builder_end(&tuple);
+	g_variant_ref_sink(data->app_data);
 
 	return;
 }
@@ -149,14 +154,29 @@
    http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#dbus   
 */
 static void
-app_id_to_dbus_path (void)
+app_id_to_dbus_path (second_exec_t * data)
 {
-	if (dbus_path != NULL) {
+	if (data->dbus_path != NULL) {
 		return;
 	}
 
-	dbus_path = nih_dbus_path(NULL, "", appid, NULL);
-	g_debug("DBus Path: %s", dbus_path);
+	GString * str = g_string_sized_new(strlen(data->appid) + 2); /* base case, we just need a / and a null */
+	g_string_append_c(str, '/');
+
+	int i;
+	for (i = 0; data->appid[i] != '\0'; i++) {
+		if ((data->appid[i] >= 'a' && data->appid[i] <= 'z') ||
+			(data->appid[i] >= 'A' && data->appid[i] <= 'Z') ||
+			(data->appid[i] >= '0' && data->appid[i] <= '9' && i != 0)) {
+			g_string_append_c(str, data->appid[i]);
+			continue;
+		}
+
+		g_string_append_printf(str, "_%2x", data->appid[i]);
+	}
+
+	data->dbus_path = g_string_free(str, FALSE);
+	g_debug("DBus Path: %s", data->dbus_path);
 
 	return;
 }
@@ -178,43 +198,48 @@
 		g_error_free(error);
 	}
 
-	connection_count_dec();
+	connection_count_dec(user_data);
 	return;
 }
 
 /* Sends the Open message to the connection with the URIs we were given */
 static void
-contact_app (GDBusConnection * bus, const gchar * dbus_name)
+contact_app (GDBusConnection * bus, const gchar * dbus_name, second_exec_t * data)
 {
 	tracepoint(upstart_app_launch, second_exec_contact_app);
 
-	parse_uris();
-	app_id_to_dbus_path();
+	parse_uris(data);
+	app_id_to_dbus_path(data);
 
 	/* Using the FD.o Application interface */
 	g_dbus_connection_call(bus,
 		dbus_name,
-		dbus_path,
+		data->dbus_path,
 		"org.freedesktop.Application",
 		"Open",
-		app_data,
+		data->app_data,
 		NULL,
 		G_DBUS_CALL_FLAGS_NONE,
 		-1,
 		NULL,
-		send_open_cb, NULL);
+		send_open_cb, data);
 
 	g_debug("Sending Open request to: %s", dbus_name);
 
 	return;
 }
 
+typedef struct {
+	gchar * name;
+	second_exec_t * data;
+} get_pid_t;
+
 /* Gets the PID for a connection, and if it matches the one we're looking
    for then it tries to send a message to that connection */
 static void
 get_pid_cb (GObject * object, GAsyncResult * res, gpointer user_data)
 {
-	gchar * dbus_name = (gchar *)user_data;
+	get_pid_t * data = (get_pid_t *)user_data;
 	GError * error = NULL;
 	GVariant * vpid = NULL;
 
@@ -223,12 +248,15 @@
 	vpid = g_dbus_connection_call_finish(G_DBUS_CONNECTION(object), res, &error);
 
 	if (error != NULL) {
-		g_warning("Unable to query PID for dbus name '%s': %s", dbus_name, error->message);
+		g_warning("Unable to query PID for dbus name '%s': %s", data->name, error->message);
 		g_error_free(error);
-		g_free(dbus_name);
 
 		/* Lowering the connection count, this one is terminal, even if in error */
-		connection_count_dec();
+		connection_count_dec(data->data);
+
+		g_free(data->name);
+		g_free(data);
+
 		return;
 	}
 
@@ -236,22 +264,23 @@
 	g_variant_get(vpid, "(u)", &pid);
 	g_variant_unref(vpid);
 
-	if (pid == app_pid) {
+	if (pid == data->data->app_pid) {
 		/* Trying to send a message to the connection */
-		contact_app(G_DBUS_CONNECTION(object), dbus_name);
+		contact_app(G_DBUS_CONNECTION(object), data->name, data->data);
 	} else {
 		/* See if we can quit now */
-		connection_count_dec();
+		connection_count_dec(data->data);
 	}
 
-	g_free(dbus_name);
+	g_free(data->name);
+	g_free(data);
 
 	return;
 }
 
 /* Starts to look for the PID and the connections for that PID */
 void
-find_appid_pid (GDBusConnection * session)
+find_appid_pid (GDBusConnection * session, second_exec_t * data)
 {
 	GError * error = NULL;
 
@@ -276,18 +305,20 @@
 		return;
 	}
 
+	g_debug("Got bus names");
 	tracepoint(upstart_app_launch, second_exec_got_dbus_names);
 
 	/* Next figure out what we're looking for (and if there is something to look for) */
 	/* NOTE: We're getting the PID *after* the list of connections so
 	   that some new process can't come in, be the same PID as it's
 	   connection will not be in teh list we just got. */
-	app_pid = upstart_app_launch_get_primary_pid(appid);
-	if (app_pid == 0) {
-		g_warning("Unable to find pid for app id '%s'", appid);
+	data->app_pid = upstart_app_launch_get_primary_pid(data->appid);
+	if (data->app_pid == 0) {
+		g_warning("Unable to find pid for app id '%s'", data->appid);
 		return;
 	}
 
+	g_debug("Primary PID: %d", data->app_pid);
 	tracepoint(upstart_app_launch, second_exec_got_primary_pid);
 
 	/* Get the names */
@@ -301,6 +332,10 @@
 		if (!g_dbus_is_unique_name(name)) {
 			continue;
 		}
+		
+		get_pid_t * pid_data = g_new0(get_pid_t, 1);
+		pid_data->data = data;
+		pid_data->name = g_strdup(name);
 
 		tracepoint(upstart_app_launch, second_exec_request_pid);
 
@@ -315,9 +350,9 @@
 			G_DBUS_CALL_FLAGS_NONE,
 			-1,
 			NULL,
-			get_pid_cb, g_strdup(name));
+			get_pid_cb, pid_data);
 
-		connections_open++;
+		data->connections_open++;
 	}
 
 	g_variant_unref(names);
@@ -329,9 +364,6 @@
 gboolean
 second_exec (const gchar * app_id, const gchar * appuris)
 {
-	appid = app_id;
-	input_uris = appuris;
-
 	tracepoint(upstart_app_launch, second_exec_start);
 
 	/* DBus tell us! */
@@ -343,8 +375,11 @@
 		return FALSE;
 	}
 
-	/* Allocate main loop */
-	mainloop = g_main_loop_new(NULL, FALSE);
+	/* Setup our continuation data */
+	second_exec_t * data = g_new0(second_exec_t, 1);
+	data->appid = g_strdup(app_id);
+	data->input_uris = g_strdup(appuris);
+	data->bus = session;
 
 	/* Set up listening for the unfrozen signal from Unity */
 	g_dbus_connection_signal_subscribe(session,
@@ -352,11 +387,12 @@
 		"com.canonical.UpstartAppLaunch", /* interface */
 		"UnityResumeResponse", /* signal */
 		"/", /* path */
-		appid, /* arg0 */
+		app_id, /* arg0 */
 		G_DBUS_SIGNAL_FLAGS_NONE,
-		unity_resume_cb, mainloop,
+		unity_resume_cb, data,
 		NULL); /* user data destroy */
 
+	g_debug("Sending resume request");
 	tracepoint(upstart_app_launch, second_exec_emit_resume);
 
 	/* Send unfreeze to to Unity */
@@ -365,43 +401,49 @@
 		"/", /* path */
 		"com.canonical.UpstartAppLaunch", /* interface */
 		"UnityResumeRequest", /* signal */
-		g_variant_new("(s)", appid),
+		g_variant_new("(s)", app_id),
 		&error);
 
 	/* Now we start a race, we try to get to the point of knowing who
 	   to send things to, and Unity is unfrezing it.  When both are
 	   done we can send something to the app */
-	unity_starttime = g_get_monotonic_time();
+	data->unity_starttime = g_get_monotonic_time();
 
 	if (error != NULL) {
 		/* On error let's not wait for Unity */
 		g_warning("Unable to signal Unity: %s", error->message);
 		g_error_free(error);
 		error = NULL;
-		unity_starttime = 0;
+		data->unity_starttime = 0;
 	}
 
 	/* If we've got something to give out, start looking for how */
-	if (input_uris != NULL) {
-		find_appid_pid(session);
+	if (data->input_uris != NULL) {
+		find_appid_pid(session, data);
 	}
 
 	/* Loop and wait for everything to align */
-	if (connections_open > 0 || unity_starttime > 0) {
-		g_main_loop_run(mainloop);
+	if (data->connections_open == 0 && data->unity_starttime == 0) {
+		second_exec_complete(data);
 	}
-	g_debug("Finishing main loop");
-
+
+	return TRUE;
+}
+
+static void
+second_exec_complete (second_exec_t * data)
+{
+	GError * error = NULL;
 	tracepoint(upstart_app_launch, second_exec_emit_focus);
 
 	/* Now that we're done sending the info to the app, we can ask
 	   Unity to focus the application. */
-	g_dbus_connection_emit_signal(session,
+	g_dbus_connection_emit_signal(data->bus,
 		NULL, /* destination */
 		"/", /* path */
 		"com.canonical.UpstartAppLaunch", /* interface */
 		"UnityFocusRequest", /* signal */
-		g_variant_new("(s)", appid),
+		g_variant_new("(s)", data->appid),
 		&error);
 
 	if (error != NULL) {
@@ -411,23 +453,23 @@
 	}
 
 	/* Make sure the signal hits the bus */
-	g_dbus_connection_flush_sync(session, NULL, NULL);
+	g_dbus_connection_flush_sync(data->bus, NULL, &error);
+	if (error != NULL) {
+		g_warning("Unable to flush session bus: %s", error->message);
+		g_error_free(error);
+		error = NULL;
+	}
 
 	/* Clean up */
-	if (app_data != NULL) {
-		g_variant_unref(app_data);
-		app_data = NULL;
-	}
-
-	g_main_loop_unref(mainloop);
-	g_object_unref(session);
-
-	if (dbus_path != NULL) {
-		nih_free(dbus_path);
-		dbus_path = NULL;
-	}
+	g_object_unref(data->bus);
+	if (data->app_data != NULL)
+		g_variant_unref(data->app_data);
+	g_free(data->appid);
+	g_free(data->input_uris);
+	g_free(data->dbus_path);
+	g_free(data);
 
 	tracepoint(upstart_app_launch, second_exec_finish);
 
-	return TRUE;
+	return;
 }

=== renamed file 'second-exec-core.h' => 'libupstart-app-launch/second-exec-core.h'
=== added file 'libupstart-app-launch/upstart-app-launch-trace.tp'
--- libupstart-app-launch/upstart-app-launch-trace.tp	1970-01-01 00:00:00 +0000
+++ libupstart-app-launch/upstart-app-launch-trace.tp	2014-02-06 18:42:36 +0000
@@ -0,0 +1,20 @@
+
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_start, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_emit_resume, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_resume_complete, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_resume_timeout, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_emit_focus, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_finish, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_got_dbus_names, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_got_primary_pid, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_request_pid, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_got_pid, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_contact_app, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_app_contacted, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_app_error, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, second_exec_connection_complete, TP_ARGS(0), TP_FIELDS())
+
+TRACEPOINT_EVENT(upstart_app_launch, desktop_single_start, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, desktop_single_found, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(upstart_app_launch, desktop_single_finished, TP_ARGS(0), TP_FIELDS())
+

=== modified file 'libupstart-app-launch/upstart-app-launch.c'
--- libupstart-app-launch/upstart-app-launch.c	2014-01-29 02:19:27 +0000
+++ libupstart-app-launch/upstart-app-launch.c	2014-02-06 18:42:36 +0000
@@ -20,53 +20,16 @@
 #include "upstart-app-launch.h"
 #include <json-glib/json-glib.h>
 #include <upstart.h>
-#include <nih/alloc.h>
-#include <nih/error.h>
 #include <gio/gio.h>
 #include <string.h>
 
-static void apps_for_job (NihDBusProxy * upstart, const gchar * name, GArray * apps, gboolean truncate_legacy);
+#include "upstart-app-launch-trace.h"
+#include "second-exec-core.h"
+#include "../helpers.h"
+
+static void apps_for_job (GDBusConnection * con, const gchar * name, GArray * apps, gboolean truncate_legacy);
 static void free_helper (gpointer value);
 
-static NihDBusProxy *
-nih_proxy_create (void)
-{
-	NihDBusProxy *   upstart;
-	DBusConnection * conn;
-	DBusError        error;
-	const gchar *    bus_name = NULL;
-
-	dbus_error_init(&error);
-
-	conn = dbus_bus_get(DBUS_BUS_SESSION, &error);
-	bus_name = "com.ubuntu.Upstart";
-
-	if (conn == NULL) {
-		g_warning("Unable to connect to the Upstart Session: %s", error.message);
-		dbus_error_free(&error);
-		return NULL;
-	}
-
-	dbus_error_free(&error);
-
-	upstart = nih_dbus_proxy_new(NULL, conn,
-		bus_name,
-		DBUS_PATH_UPSTART,
-		NULL, NULL);
-
-	if (upstart == NULL) {
-		g_warning("Unable to build proxy to Upstart");
-		dbus_connection_unref(conn);
-		return NULL;
-	}
-
-	dbus_connection_unref(conn);
-
-	upstart->auto_start = FALSE;
-
-	return upstart;
-}
-
 /* Function to take the urls and escape them so that they can be
    parsed on the other side correctly. */
 static gchar *
@@ -87,83 +50,260 @@
 	return urisjoin;
 }
 
+typedef struct {
+	gchar * appid;
+	gchar * uris;
+} app_start_t;
+
+static void
+application_start_cb (GObject * obj, GAsyncResult * res, gpointer user_data)
+{
+	app_start_t * data = (app_start_t *)user_data;
+	GError * error = NULL;
+	GVariant * result = NULL;
+
+	g_debug("Started Message Callback: %s", data->appid);
+
+	result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(obj), res, &error);
+
+	if (result != NULL)
+		g_variant_unref(result);
+	
+	if (error != NULL) {
+		if (g_dbus_error_is_remote_error(error)) {
+			gchar * remote_error = g_dbus_error_get_remote_error(error);
+			g_debug("Remote error: %s", remote_error);
+			if (g_strcmp0(remote_error, "com.ubuntu.Upstart0_6.Error.AlreadyStarted") == 0) {
+				second_exec(data->appid, data->uris);
+			}
+
+			g_free(remote_error);
+		} else {
+			g_warning("Unable to emit event to start application: %s", error->message);
+		}
+		g_error_free(error);
+	}
+
+	g_free(data->appid);
+	g_free(data->uris);
+	g_free(data);
+}
+
+/* Get the path of the job from Upstart, if we've got it already, we'll just
+   use the cache of the value */
+static const gchar *
+get_jobpath (GDBusConnection * con, const gchar * jobname)
+{
+	gchar * cachepath = g_strdup_printf("upstart-app-lauch-job-path-cache-%s", jobname);
+	gpointer cachedata = g_object_get_data(G_OBJECT(con), cachepath);
+
+	if (cachedata != NULL) {
+		g_free(cachepath);
+		return cachedata;
+	}
+
+	GError * error = NULL;
+	GVariant * job_path_variant = g_dbus_connection_call_sync(con,
+		DBUS_SERVICE_UPSTART,
+		DBUS_PATH_UPSTART,
+		DBUS_INTERFACE_UPSTART,
+		"GetJobByName",
+		g_variant_new("(s)", jobname),
+		G_VARIANT_TYPE("(o)"),
+		G_DBUS_CALL_FLAGS_NONE,
+		-1, /* timeout: default */
+		NULL, /* cancelable */
+		&error);
+
+	if (error != NULL) {	
+		g_warning("Unable to find job '%s': %s", jobname, error->message);
+		g_error_free(error);
+		g_free(cachepath);
+		return NULL;
+	}
+
+	gchar * job_path = NULL;
+	g_variant_get(job_path_variant, "(o)", &job_path);
+	g_variant_unref(job_path_variant);
+
+	g_object_set_data_full(G_OBJECT(con), cachepath, job_path, g_free);
+	g_free(cachepath);
+
+	return job_path;
+}
+
+/* Check to see if a legacy app wants us to manage whether they're
+   single instance or not */
+static gboolean
+legacy_single_instance (const gchar * appid)
+{
+	tracepoint(upstart_app_launch, desktop_single_start);
+
+	GKeyFile * keyfile = keyfile_for_appid(appid, NULL);
+
+	if (keyfile == NULL) {
+		g_warning("Unable to find keyfile for application '%s'", appid);
+		return FALSE;
+	}
+
+	tracepoint(upstart_app_launch, desktop_single_found);
+
+	gboolean singleinstance = FALSE;
+
+	if (g_key_file_has_key(keyfile, "Desktop Entry", "X-Ubuntu-Single-Instance", NULL)) {
+		GError * error = NULL;
+
+		singleinstance = g_key_file_get_boolean(keyfile, "Desktop Entry", "X-Ubuntu-Single-Instance", &error);
+
+		if (error != NULL) {
+			g_warning("Unable to get single instance key for app '%s': %s", appid, error->message);
+			g_error_free(error);
+			/* Ensure that if we got an error, we assume standard case */
+			singleinstance = FALSE;
+		}
+	}
+	
+	g_key_file_free(keyfile);
+
+	tracepoint(upstart_app_launch, desktop_single_finished);
+
+	return singleinstance;
+}
+
+/* Determine whether it's a click package by looking for the symlink
+   that is created by the desktop hook */
+static gboolean
+is_click (const gchar * appid)
+{
+	gchar * appiddesktop = g_strdup_printf("%s.desktop", appid);
+	gchar * click_link = NULL;
+	const gchar * link_farm_dir = g_getenv("UPSTART_APP_LAUNCH_LINK_FARM");
+	if (G_LIKELY(link_farm_dir == NULL)) {
+		click_link = g_build_filename(g_get_home_dir(), ".cache", "upstart-app-launch", "desktop", appiddesktop, NULL);
+	} else {
+		click_link = g_build_filename(link_farm_dir, appiddesktop, NULL);
+	}
+	g_free(appiddesktop);
+	gboolean click = g_file_test(click_link, G_FILE_TEST_EXISTS);
+	g_free(click_link);
+
+	return click;
+}
+
 gboolean
 upstart_app_launch_start_application (const gchar * appid, const gchar * const * uris)
 {
-	NihDBusProxy * proxy = NULL;
-
-	proxy = nih_proxy_create();
-	if (proxy == NULL) {
+	g_return_val_if_fail(appid != NULL, FALSE);
+
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	g_return_val_if_fail(con != NULL, FALSE);
+
+	gboolean click = is_click(appid);
+
+	/* Figure out the DBus path for the job */
+	const gchar * jobpath = NULL;
+	if (click) {
+		jobpath = get_jobpath(con, "application-click");
+	} else {
+		jobpath = get_jobpath(con, "application-legacy");
+	}
+
+	if (jobpath == NULL)
 		return FALSE;
-	}
-
-	gchar * env_appid = g_strdup_printf("APP_ID=%s", appid);
-	gchar * env_uris = NULL;
+
+	/* Callback data */
+	app_start_t * app_start_data = g_new0(app_start_t, 1);
+	app_start_data->appid = g_strdup(appid);
+
+	/* Build up our environment */
+	GVariantBuilder builder;
+	g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+
+	g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+	g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf("APP_ID=%s", appid)));
 
 	if (uris != NULL) {
 		gchar * urisjoin = app_uris_string(uris);
-		env_uris = g_strdup_printf("APP_URIS=%s", urisjoin);
-		g_free(urisjoin);
-	}
-
-	gchar * env[3];
-	env[0] = env_appid;
-	env[1] = env_uris;
-	env[2] = NULL;
-
-	gboolean retval = TRUE;
-	if (upstart_emit_event_sync(NULL, proxy, "application-start", env, 0) != 0) {
-		g_warning("Unable to emit signal 'application-start'");
-		retval = FALSE;
-	}
-
-	g_free(env_appid);
-	g_free(env_uris);
-	nih_unref(proxy, NULL);
-
-	return retval;
+		gchar * urienv = g_strdup_printf("APP_URIS=%s", urisjoin);
+		app_start_data->uris = urisjoin;
+		g_variant_builder_add_value(&builder, g_variant_new_take_string(urienv));
+	}
+
+	if (!click) {
+		if (legacy_single_instance(appid)) {
+			g_variant_builder_add_value(&builder, g_variant_new_string("INSTANCE_ID="));
+		} else {
+			gchar * instanceid = g_strdup_printf("INSTANCE_ID=%" G_GUINT64_FORMAT, g_get_real_time());
+			g_variant_builder_add_value(&builder, g_variant_new_take_string(instanceid));
+		}
+	}
+
+	g_variant_builder_close(&builder);
+	g_variant_builder_add_value(&builder, g_variant_new_boolean(TRUE));
+	
+	/* Call the job start function */
+	g_dbus_connection_call(con,
+	                       DBUS_SERVICE_UPSTART,
+	                       jobpath,
+	                       DBUS_INTERFACE_UPSTART_JOB,
+	                       "Start",
+	                       g_variant_builder_end(&builder),
+	                       NULL,
+	                       G_DBUS_CALL_FLAGS_NONE,
+	                       -1,
+	                       NULL, /* cancelable */
+	                       application_start_cb,
+	                       app_start_data);
+
+	g_object_unref(con);
+
+	return TRUE;
 }
 
 static void
-stop_job (NihDBusProxy * upstart, const gchar * jobname, const gchar * appname, const gchar * instanceid)
+stop_job (GDBusConnection * con, const gchar * jobname, const gchar * appname, const gchar * instanceid)
 {
 	g_debug("Stopping job %s app_id %s instance_id %s", jobname, appname, instanceid);
-	nih_local char * job_path = NULL;
-	if (upstart_get_job_by_name_sync(NULL, upstart, jobname, &job_path) != 0) {
-		g_warning("Unable to find job '%s'", jobname);
-		return;
-	}
-
-	NihDBusProxy * job_proxy = nih_dbus_proxy_new(NULL, upstart->connection,
-		upstart->name,
-		job_path,
-		NULL, NULL);
-
-	if (job_proxy == NULL) {
-		g_warning("Unable to build proxy to Job '%s'", jobname);
-		return;
-	}
-
-	gchar * app = g_strdup_printf("APP_ID=%s", appname);
-	gchar * inst = NULL;
+
+	const gchar * job_path = get_jobpath(con, jobname);
+	if (job_path == NULL)
+		return;
+
+	GVariantBuilder builder;
+	g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+	g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+	g_variant_builder_add_value(&builder,
+		g_variant_new_take_string(g_strdup_printf("APP_ID=%s", appname)));
 	
 	if (instanceid != NULL) {
-		inst = g_strdup_printf("INSTANCE_ID=%s", instanceid);
-	}
-
-	gchar * env[3] = {
-		app,
-		inst,
-		NULL
-	};
-
-	if (job_class_stop_sync(NULL, job_proxy, env, 0) != 0) {
-		g_warning("Unable to stop job %s app %s instance %s", jobname, appname, instanceid);
-	}
-
-	g_free(app);
-	g_free(inst);
-	nih_unref(job_proxy, NULL);
+		g_variant_builder_add_value(&builder,
+			g_variant_new_take_string(g_strdup_printf("INSTANCE_ID=%s", instanceid)));
+	}
+
+	g_variant_builder_close(&builder);
+	g_variant_builder_add_value(&builder, g_variant_new_boolean(FALSE)); /* wait */
+
+	GError * error = NULL;
+	GVariant * stop_variant = g_dbus_connection_call_sync(con,
+		DBUS_SERVICE_UPSTART,
+		job_path,
+		DBUS_INTERFACE_UPSTART_JOB,
+		"Stop",
+		g_variant_builder_end(&builder),
+		NULL,
+		G_DBUS_CALL_FLAGS_NONE,
+		-1, /* timeout: default */
+		NULL, /* cancelable */
+		&error);
+
+	if (error != NULL) {
+		g_warning("Unable to stop job %s app_id %s instance_id %s: %s", jobname, appname, instanceid, error->message);
+		g_error_free(error);
+	}
+
+	g_variant_unref(stop_variant);
 }
 
 static void
@@ -176,25 +316,24 @@
 gboolean
 upstart_app_launch_stop_application (const gchar * appid)
 {
+	g_return_val_if_fail(appid != NULL, FALSE);
+
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	g_return_val_if_fail(con != NULL, FALSE);
+
 	gboolean found = FALSE;
 	int i;
-	NihDBusProxy * proxy = NULL;
-
-	proxy = nih_proxy_create();
-	if (proxy == NULL) {
-		return FALSE;
-	}
 
 	GArray * apps = g_array_new(TRUE, TRUE, sizeof(gchar *));
 	g_array_set_clear_func(apps, free_helper);
 
 	/* Look through the click jobs and see if any match.  There can
 	   only be one instance for each ID in the click world */
-	apps_for_job(proxy, "application-click", apps, FALSE);
+	apps_for_job(con, "application-click", apps, FALSE);
 	for (i = 0; i < apps->len; i++) {
 		const gchar * array_id = g_array_index(apps, const gchar *, i);
 		if (g_strcmp0(array_id, appid) == 0) {
-			stop_job(proxy, "application-click", appid, NULL);
+			stop_job(con, "application-click", appid, NULL);
 			found = TRUE;
 			break; /* There can be only one with click */
 		}
@@ -206,24 +345,71 @@
 	/* Look through the legacy apps.  Trickier because we know that there
 	   can be many instances of the legacy jobs out there, so we might
 	   have to kill more than one of them. */
-	apps_for_job(proxy, "application-legacy", apps, FALSE);
+	apps_for_job(con, "application-legacy", apps, FALSE);
 	gchar * appiddash = g_strdup_printf("%s-", appid); /* Probably could go RegEx here, but let's start with just a prefix lookup */
 	for (i = 0; i < apps->len; i++) {
 		const gchar * array_id = g_array_index(apps, const gchar *, i);
 		if (g_str_has_prefix(array_id, appiddash)) {
 			gchar * instanceid = g_strrstr(array_id, "-");
-			stop_job(proxy, "application-legacy", appid, &(instanceid[1]));
+			stop_job(con, "application-legacy", appid, &(instanceid[1]));
 			found = TRUE;
 		}
 	}
 	g_free(appiddash);
 
 	g_array_free(apps, TRUE);
-	nih_unref(proxy, NULL);
+	g_object_unref(con);
 
 	return found;
 }
 
+gchar *
+upstart_app_launch_application_log_path (const gchar * appid)
+{
+	gchar * path = NULL;
+	g_return_val_if_fail(appid != NULL, NULL);
+
+	if (is_click(appid)) {
+		gchar * appfile = g_strdup_printf("application-click-%s.log", appid);
+		path =  g_build_filename(g_get_user_cache_dir(), "upstart", appfile, NULL);
+		g_free(appfile);
+		return path;
+	}
+
+	if (legacy_single_instance(appid)) {
+		gchar * appfile = g_strdup_printf("application-legacy-%s-.log", appid);
+		path =  g_build_filename(g_get_user_cache_dir(), "upstart", appfile, NULL);
+		g_free(appfile);
+		return path;
+	}
+
+	/* If we're not single instance, we can't recreate the instance ID
+	   but if it's running we can grab it. */
+	unsigned int i;
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	g_return_val_if_fail(con != NULL, NULL);
+
+	GArray * apps = g_array_new(TRUE, TRUE, sizeof(gchar *));
+	g_array_set_clear_func(apps, free_helper);
+
+	apps_for_job(con, "application-legacy", apps, FALSE);
+	gchar * appiddash = g_strdup_printf("%s-", appid); /* Probably could go RegEx here, but let's start with just a prefix lookup */
+	for (i = 0; i < apps->len && path == NULL; i++) {
+		const gchar * array_id = g_array_index(apps, const gchar *, i);
+		if (g_str_has_prefix(array_id, appiddash)) {
+			gchar * appfile = g_strdup_printf("application-legacy-%s.log", array_id);
+			path =  g_build_filename(g_get_user_cache_dir(), "upstart", appfile, NULL);
+			g_free(appfile);
+		}
+	}
+	g_free(appiddash);
+
+	g_array_free(apps, TRUE);
+	g_object_unref(con);
+
+	return path;
+}
+
 static GDBusConnection *
 gdbus_upstart_ref (void) {
 	static GDBusConnection * gdbus_upstart = NULL;
@@ -523,164 +709,210 @@
 	return FALSE;
 }
 
+typedef void (*per_instance_func_t) (GDBusConnection * con, GVariant * prop_dict, gpointer user_data);
+
+static void
+foreach_job_instance (GDBusConnection * con, const gchar * jobname, per_instance_func_t func, gpointer user_data)
+{
+	const gchar * job_path = get_jobpath(con, jobname);
+	if (job_path == NULL)
+		return;
+
+	GError * error = NULL;
+	GVariant * instance_tuple = g_dbus_connection_call_sync(con,
+		DBUS_SERVICE_UPSTART,
+		job_path,
+		DBUS_INTERFACE_UPSTART_JOB,
+		"GetAllInstances",
+		NULL,
+		G_VARIANT_TYPE("(ao)"),
+		G_DBUS_CALL_FLAGS_NONE,
+		-1, /* timeout: default */
+		NULL, /* cancelable */
+		&error);
+
+	if (error != NULL) {
+		g_warning("Unable to get instances of job '%s': %s", jobname, error->message);
+		g_error_free(error);
+		return;
+	}
+
+	GVariant * instance_list = g_variant_get_child_value(instance_tuple, 0);
+	g_variant_unref(instance_tuple);
+
+	GVariantIter instance_iter;
+	g_variant_iter_init(&instance_iter, instance_list);
+	const gchar * instance_path = NULL;
+
+	while (g_variant_iter_loop(&instance_iter, "&o", &instance_path)) {
+		GVariant * props_tuple = g_dbus_connection_call_sync(con,
+			DBUS_SERVICE_UPSTART,
+			instance_path,
+			"org.freedesktop.DBus.Properties",
+			"GetAll",
+			g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE),
+			G_VARIANT_TYPE("(a{sv})"),
+			G_DBUS_CALL_FLAGS_NONE,
+			-1, /* timeout: default */
+			NULL, /* cancelable */
+			&error);
+
+		if (error != NULL) {
+			g_warning("Unable to name of instance '%s': %s", instance_path, error->message);
+			g_error_free(error);
+			error = NULL;
+			continue;
+		}
+
+		GVariant * props_dict = g_variant_get_child_value(props_tuple, 0);
+
+		func(con, props_dict, user_data);
+
+		g_variant_unref(props_dict);
+		g_variant_unref(props_tuple);
+
+	}
+
+	g_variant_unref(instance_list);
+}
+
+typedef struct {
+	GArray * apps;
+	gboolean truncate_legacy;
+	const gchar * jobname;
+} apps_for_job_t;
+
+static void
+apps_for_job_instance (GDBusConnection * con, GVariant * props_dict, gpointer user_data)
+{
+	GVariant * namev = g_variant_lookup_value(props_dict, "name", G_VARIANT_TYPE_STRING);
+	if (namev == NULL) {
+		return;
+	}
+
+	apps_for_job_t * data = (apps_for_job_t *)user_data;
+	gchar * instance_name = g_variant_dup_string(namev, NULL);
+	g_variant_unref(namev);
+
+	if (data->truncate_legacy && g_strcmp0(data->jobname, "application-legacy") == 0) {
+		gchar * last_dash = g_strrstr(instance_name, "-");
+		if (last_dash != NULL) {
+			last_dash[0] = '\0';
+		}
+	}
+
+	g_array_append_val(data->apps, instance_name);
+}
+
 /* Get all the instances for a given job name */
 static void
-apps_for_job (NihDBusProxy * upstart, const gchar * name, GArray * apps, gboolean truncate_legacy)
+apps_for_job (GDBusConnection * con, const gchar * jobname, GArray * apps, gboolean truncate_legacy)
 {
-	nih_local char * job_path = NULL;
-	if (upstart_get_job_by_name_sync(NULL, upstart, name, &job_path) != 0) {
-		g_warning("Unable to find job '%s'", name);
-		return;
-	}
-
-	nih_local NihDBusProxy * job_proxy = nih_dbus_proxy_new(NULL, upstart->connection,
-		upstart->name,
-		job_path,
-		NULL, NULL);
-
-	if (job_proxy == NULL) {
-		g_warning("Unable to build proxy to Job '%s'", name);
-		return;
-	}
-
-	nih_local char ** instances;
-	if (job_class_get_all_instances_sync(NULL, job_proxy, &instances) != 0) {
-		NihError * error = nih_error_get();
-		g_warning("Unable to get instances for job '%s': %s", name, error->message);
-		nih_free(error);
-		return;
-	}
-
-	int jobnum;
-	for (jobnum = 0; instances[jobnum] != NULL; jobnum++) {
-		NihDBusProxy * instance_proxy = nih_dbus_proxy_new(NULL, upstart->connection,
-			upstart->name,
-			instances[jobnum],
-			NULL, NULL);
-
-		nih_local char * instance_name = NULL;
-		if (job_get_name_sync(NULL, instance_proxy, &instance_name) == 0) {
-			gchar * dup = g_strdup(instance_name);
-
-			if (truncate_legacy && g_strcmp0(name, "application-legacy") == 0) {
-				gchar * last_dash = g_strrstr(dup, "-");
-				if (last_dash != NULL) {
-					last_dash[0] = '\0';
-				}
-			}
-
-			g_array_append_val(apps, dup);
-		} else {
-			g_warning("Unable to get name for instance '%s' of job '%s'", instances[jobnum], name);
-		}
-
-		nih_unref(instance_proxy, NULL);
-	}
+	apps_for_job_t data = {
+		.jobname = jobname,
+		.apps = apps,
+		.truncate_legacy = truncate_legacy
+	};
+
+	foreach_job_instance(con, jobname, apps_for_job_instance, &data);
 }
 
 gchar **
 upstart_app_launch_list_running_apps (void)
 {
-	NihDBusProxy * proxy = NULL;
-
-	proxy = nih_proxy_create();
-	if (proxy == NULL) {
-		return g_new0(gchar *, 1);
-	}
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	g_return_val_if_fail(con != NULL, g_new0(gchar *, 1));
 
 	GArray * apps = g_array_new(TRUE, TRUE, sizeof(gchar *));
 
-	apps_for_job(proxy, "application-legacy", apps, TRUE);
-	apps_for_job(proxy, "application-click", apps, FALSE);
+	apps_for_job(con, "application-legacy", apps, TRUE);
+	apps_for_job(con, "application-click", apps, FALSE);
 
-	nih_unref(proxy, NULL);
+	g_object_unref(con);
 
 	return (gchar **)g_array_free(apps, FALSE);
 }
 
+typedef struct {
+	GPid pid;
+	const gchar * appid;
+	const gchar * jobname;
+} pid_for_job_t;
+
+static void
+pid_for_job_instance (GDBusConnection * con, GVariant * props_dict, gpointer user_data)
+{
+	GVariant * namev = g_variant_lookup_value(props_dict, "name", G_VARIANT_TYPE_STRING);
+	if (namev == NULL) {
+		return;
+	}
+
+	pid_for_job_t * data = (pid_for_job_t *)user_data;
+	gchar * instance_name = g_variant_dup_string(namev, NULL);
+	g_variant_unref(namev);
+
+	if (g_strcmp0(data->jobname, "application-legacy") == 0) {
+		gchar * last_dash = g_strrstr(instance_name, "-");
+		if (last_dash != NULL) {
+			last_dash[0] = '\0';
+		}
+	}
+
+	if (g_strcmp0(instance_name, data->appid) == 0) {
+		GVariant * processv = g_variant_lookup_value(props_dict, "processes", G_VARIANT_TYPE("a(si)"));
+
+		if (processv != NULL) {
+			if (g_variant_n_children(processv) > 0) {
+				GVariant * first_entry = g_variant_get_child_value(processv, 0);
+				GVariant * pidv = g_variant_get_child_value(first_entry, 1);
+
+				data->pid = g_variant_get_int32(pidv);
+
+				g_variant_unref(pidv);
+				g_variant_unref(first_entry);
+			}
+
+			g_variant_unref(processv);
+		}
+	}
+
+	g_free(instance_name);
+}
+
 /* Look for the app for a job */
 static GPid
-pid_for_job (NihDBusProxy * upstart, const gchar * job, const gchar * appid)
+pid_for_job (GDBusConnection * con, const gchar * jobname, const gchar * appid)
 {
-	nih_local char * job_path = NULL;
-	if (upstart_get_job_by_name_sync(NULL, upstart, job, &job_path) != 0) {
-		g_warning("Unable to find job '%s'", job);
-		return 0;
-	}
-
-	NihDBusProxy * job_proxy = nih_dbus_proxy_new(NULL, upstart->connection,
-		upstart->name,
-		job_path,
-		NULL, NULL);
-
-	if (job_proxy == NULL) {
-		g_warning("Unable to build proxy to Job '%s'", job);
-		return 0;
-	}
-
-	nih_local char ** instances;
-	if (job_class_get_all_instances_sync(NULL, job_proxy, &instances) != 0) {
-		g_warning("Unable to get instances for job '%s'", job);
-		nih_unref(job_proxy, NULL);
-		return 0;
-	}
-
-	GPid pid = 0;
-	int jobnum;
-	for (jobnum = 0; instances[jobnum] != NULL && pid == 0; jobnum++) {
-		NihDBusProxy * instance_proxy = nih_dbus_proxy_new(NULL, upstart->connection,
-			upstart->name,
-			instances[jobnum],
-			NULL, NULL);
-
-		nih_local char * instance_name = NULL;
-		if (job_get_name_sync(NULL, instance_proxy, &instance_name) == 0) {
-			if (g_strcmp0(job, "application-legacy") == 0) {
-				gchar * last_dash = g_strrstr(instance_name, "-");
-				if (last_dash != NULL) {
-					last_dash[0] = '\0';
-				}
-			}
-		} else {
-			g_warning("Unable to get name for instance '%s' of job '%s'", instances[jobnum], job);
-		}
-
-		if (g_strcmp0(instance_name, appid) == 0) {
-			nih_local JobProcessesElement ** elements;
-			if (job_get_processes_sync(NULL, instance_proxy, &elements) == 0) {
-				pid = elements[0]->item1;
-			}
-		}
-
-		nih_unref(instance_proxy, NULL);
-	}
-
-	nih_unref(job_proxy, NULL);
-
-	return pid;
+	pid_for_job_t data = {
+		.jobname = jobname,
+		.appid = appid,
+		.pid = 0
+	};
+
+	foreach_job_instance(con, jobname, pid_for_job_instance, &data);
+
+	return data.pid;
 }
 
 GPid
 upstart_app_launch_get_primary_pid (const gchar * appid)
 {
-	NihDBusProxy * proxy = NULL;
+	g_return_val_if_fail(appid != NULL, 0);
 
-	proxy = nih_proxy_create();
-	if (proxy == NULL) {
-		return 0;
-	}
+	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	g_return_val_if_fail(con != NULL, 0);
 
 	GPid pid = 0;
 
 	if (pid == 0) {
-		pid = pid_for_job(proxy, "application-legacy", appid);
+		pid = pid_for_job(con, "application-legacy", appid);
 	}
 
 	if (pid == 0) {
-		pid = pid_for_job(proxy, "application-click", appid);
+		pid = pid_for_job(con, "application-click", appid);
 	}
 
-	nih_unref(proxy, NULL);
+	g_object_unref(con);
 
 	return pid;
 }
@@ -688,6 +920,8 @@
 gboolean
 upstart_app_launch_pid_in_app_id (GPid pid, const gchar * appid)
 {
+	g_return_val_if_fail(appid != NULL, FALSE);
+
 	if (pid == 0) {
 		return FALSE;
 	}

=== modified file 'libupstart-app-launch/upstart-app-launch.h'
--- libupstart-app-launch/upstart-app-launch.h	2014-01-29 02:33:52 +0000
+++ libupstart-app-launch/upstart-app-launch.h	2014-02-06 18:42:36 +0000
@@ -80,6 +80,19 @@
 gboolean   upstart_app_launch_stop_application         (const gchar *                     appid);
 
 /**
+ * upstart_app_launch_application_log_path:
+ * @appid: ID of the application
+ *
+ * Calculates the path for the log file that may be generated by
+ * the application.  The log file won't be created until the application
+ * prints some output.  Also, this doens't work for legacy applications
+ * that are multi-instance, only single instance ones.
+ *
+ * Return value: Path to a log file or NULL if unavailable
+ */
+gchar *    upstart_app_launch_application_log_path     (const gchar *                     appid);
+
+/**
  * upstart_app_launch_observer_add_app_starting:
  * @observer: Callback when an application is about to start
  * @user_data: (allow none): Data to pass to the observer

=== removed file 'second-exec-trace.tp'
--- second-exec-trace.tp	2013-12-04 17:32:23 +0000
+++ second-exec-trace.tp	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_start, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_emit_resume, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_resume_complete, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_resume_timeout, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_emit_focus, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_finish, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_got_dbus_names, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_got_primary_pid, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_request_pid, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_got_pid, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_contact_app, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_app_contacted, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_app_error, TP_ARGS(0), TP_FIELDS())
-TRACEPOINT_EVENT(upstart_app_launch, second_exec_connection_complete, TP_ARGS(0), TP_FIELDS())
-

=== removed file 'second-exec.c'
--- second-exec.c	2013-12-05 17:08:13 +0000
+++ second-exec.c	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright 2013 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 "second-exec-core.h"
-
-int
-main (int argc, char * argv[])
-{
-	if (argc != 1) {
-		g_error("Should be called as: %s", argv[0]);
-		return 1;
-	}
-
-	const gchar * appid = g_getenv("APP_ID");
-	const gchar * appuris = g_getenv("APP_URIS");
-
-	g_setenv("LTTNG_UST_REGISTER_TIMEOUT", "0", FALSE); /* Set to zero if not set */
-
-	if (second_exec(appid, appuris)) {
-		return 0;
-	} else {
-		return 1;
-	}
-}

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-01-13 15:16:24 +0000
+++ tests/CMakeLists.txt	2014-02-06 18:42:36 +0000
@@ -25,16 +25,6 @@
 
 add_test (helper-handshake-test helper-handshake-test)
 
-# Second Exec Test
-
-include_directories("${CMAKE_SOURCE_DIR}/libupstart-app-launch")
-
-add_executable (second-exec-test
-	second-exec-test.cc
-	upstart-app-launch-mock.c)
-target_link_libraries (second-exec-test helpers gtest ${GTEST_LIBS} ${LIBUPSTART_LIBRARIES} upstart-launcher second-exec-core)
-add_test (second-exec-test second-exec-test)
-
 # libUAL Test
 
 include_directories("${CMAKE_SOURCE_DIR}/libupstart-app-launch")
@@ -43,14 +33,7 @@
 	libual-test.cc)
 target_link_libraries (libual-test helpers gtest ${GTEST_LIBS} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} upstart-launcher)
 
-# NOTE: Tests are broken into individual runs to avoid problems with libdbus
-add_test (NAME libual-test-start COMMAND libual-test --gtest_filter=*StartApplication)
-add_test (NAME libual-test-stop COMMAND libual-test --gtest_filter=*StopApplication)
-add_test (NAME libual-test-pid COMMAND libual-test --gtest_filter=*ApplicationPid)
-add_test (NAME libual-test-app-id COMMAND libual-test --gtest_filter=*ApplicationId)
-add_test (NAME libual-test-list COMMAND libual-test --gtest_filter=*ApplicationList)
-add_test (NAME libual-test-observer COMMAND libual-test --gtest_filter=*StartStopObserver)
-add_test (NAME libual-test-starting COMMAND libual-test --gtest_filter=*StartingResponses)
+add_test (NAME libual-test COMMAND libual-test)
 
 # ZG Test
 

=== added file 'tests/applications/multiple.desktop'
--- tests/applications/multiple.desktop	1970-01-01 00:00:00 +0000
+++ tests/applications/multiple.desktop	2014-02-06 18:42:36 +0000
@@ -0,0 +1,8 @@
+[Desktop Entry]
+Name=Multiple
+Type=Application
+Exec=multiple
+NoDisplay=false
+Hidden=false
+Terminal=false
+X-Ubuntu-Single-Instance=false

=== added file 'tests/applications/single.desktop'
--- tests/applications/single.desktop	1970-01-01 00:00:00 +0000
+++ tests/applications/single.desktop	2014-02-06 18:42:36 +0000
@@ -0,0 +1,8 @@
+[Desktop Entry]
+Name=Single
+Type=Application
+Exec=single
+NoDisplay=false
+Hidden=false
+Terminal=false
+X-Ubuntu-Single-Instance=true

=== modified file 'tests/libual-test.cc'
--- tests/libual-test.cc	2014-01-29 02:24:06 +0000
+++ tests/libual-test.cc	2014-02-06 18:42:36 +0000
@@ -31,6 +31,26 @@
 		DbusTestService * service = NULL;
 		DbusTestDbusMock * mock = NULL;
 		GDBusConnection * bus = NULL;
+		std::string last_focus_appid;
+		std::string last_resume_appid;
+		guint resume_timeout = 0;
+
+	private:
+		static void focus_cb (const gchar * appid, gpointer user_data) {
+			g_debug("Focus Callback: %s", appid);
+			LibUAL * _this = static_cast<LibUAL *>(user_data);
+			_this->last_focus_appid = appid;
+		}
+
+		static void resume_cb (const gchar * appid, gpointer user_data) {
+			g_debug("Resume Callback: %s", appid);
+			LibUAL * _this = static_cast<LibUAL *>(user_data);
+			_this->last_resume_appid = appid;
+
+			if (_this->resume_timeout > 0) {
+				_this->pause(_this->resume_timeout);
+			}
+		}
 
 	protected:
 		/* Useful debugging stuff, but not on by default.  You really want to
@@ -48,8 +68,15 @@
 		}
 
 		virtual void SetUp() {
+			gchar * linkfarmpath = g_build_filename(CMAKE_SOURCE_DIR, "link-farm", NULL);
+			g_setenv("UPSTART_APP_LAUNCH_LINK_FARM", linkfarmpath, TRUE);
+			g_free(linkfarmpath);
+
+			g_setenv("XDG_DATA_DIRS", CMAKE_SOURCE_DIR, TRUE);
+			g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR, TRUE);
+
 			service = dbus_test_service_new(NULL);
-			g_setenv("XDG_DATA_DIRS", CMAKE_SOURCE_DIR, TRUE);
+
 			const gchar * oldpath = g_getenv("PATH");
 			gchar * newpath = g_strjoin(":", CMAKE_SOURCE_DIR, oldpath, NULL);
 			g_setenv("PATH", newpath, TRUE);
@@ -81,6 +108,14 @@
 			DbusTestDbusMockObject * jobobj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
 
 			dbus_test_dbus_mock_object_add_method(mock, jobobj,
+				"Start",
+				G_VARIANT_TYPE("(asb)"),
+				NULL,
+				"if args[0][0] == 'APP_ID=foo':"
+				"    raise dbus.exceptions.DBusException('Foo running', name='com.ubuntu.Upstart0_6.Error.AlreadyStarted')",
+				NULL);
+
+			dbus_test_dbus_mock_object_add_method(mock, jobobj,
 				"Stop",
 				G_VARIANT_TYPE("(asb)"),
 				NULL,
@@ -100,15 +135,24 @@
 				G_VARIANT_TYPE_STRING,
 				g_variant_new_string("foo"),
 				NULL);
+			gchar * process_var = g_strdup_printf("[('main', %d)]", getpid());
 			dbus_test_dbus_mock_object_add_property(mock, instobj,
 				"processes",
 				G_VARIANT_TYPE("a(si)"),
-				g_variant_new_parsed("[('main', 1234)]"),
+				g_variant_new_parsed(process_var),
 				NULL);
+			g_free(process_var);
 
 			DbusTestDbusMockObject * ljobobj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_legacy", "com.ubuntu.Upstart0_6.Job", NULL);
 
 			dbus_test_dbus_mock_object_add_method(mock, ljobobj,
+				"Start",
+				G_VARIANT_TYPE("(asb)"),
+				NULL,
+				"",
+				NULL);
+
+			dbus_test_dbus_mock_object_add_method(mock, ljobobj,
 				"Stop",
 				G_VARIANT_TYPE("(asb)"),
 				NULL,
@@ -140,9 +184,15 @@
 			bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
 			g_dbus_connection_set_exit_on_close(bus, FALSE);
 			g_object_add_weak_pointer(G_OBJECT(bus), (gpointer *)&bus);
+
+			ASSERT_TRUE(upstart_app_launch_observer_add_app_focus(focus_cb, this));
+			ASSERT_TRUE(upstart_app_launch_observer_add_app_resume(resume_cb, this));
 		}
 
 		virtual void TearDown() {
+			upstart_app_launch_observer_delete_app_focus(focus_cb, this);
+			upstart_app_launch_observer_delete_app_resume(resume_cb, this);
+
 			g_clear_object(&mock);
 			g_clear_object(&service);
 
@@ -150,12 +200,10 @@
 
 			unsigned int cleartry = 0;
 			while (bus != NULL && cleartry < 100) {
-				g_usleep(100000);
-				while (g_main_pending()) {
-					g_main_iteration(TRUE);
-				}
+				pause(100);
 				cleartry++;
 			}
+			ASSERT_EQ(bus, nullptr);
 		}
 
 		bool check_env (GVariant * env_array, const gchar * var, const gchar * value) {
@@ -189,18 +237,17 @@
 		}
 
 		static gboolean pause_helper (gpointer pmainloop) {
-			g_main_loop_quit((GMainLoop *)pmainloop);
+			g_main_loop_quit(static_cast<GMainLoop *>(pmainloop));
 			return G_SOURCE_REMOVE;
 		}
 
 		void pause (guint time) {
 			if (time > 0) {
 				GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
-				guint timer = g_timeout_add(time, pause_helper, mainloop);
+				g_timeout_add(time, pause_helper, mainloop);
 
 				g_main_loop_run(mainloop);
 
-				g_source_remove(timer);
 				g_main_loop_unref(mainloop);
 			}
 
@@ -212,35 +259,31 @@
 
 TEST_F(LibUAL, StartApplication)
 {
-	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", NULL);
+	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
 
 	/* Basic make sure we can send the event */
-	ASSERT_TRUE(upstart_app_launch_start_application("foo", NULL));
-	ASSERT_EQ(dbus_test_dbus_mock_object_check_method_call(mock, obj, "EmitEvent", NULL, NULL), 1);
+	ASSERT_TRUE(upstart_app_launch_start_application("foolike", NULL));
+	EXPECT_EQ(1, dbus_test_dbus_mock_object_check_method_call(mock, obj, "Start", NULL, NULL));
 
 	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
 
 	/* Now look at the details of the call */
-	ASSERT_TRUE(upstart_app_launch_start_application("foo", NULL));
+	ASSERT_TRUE(upstart_app_launch_start_application("foolike", NULL));
 
 	guint len = 0;
-	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "EmitEvent", &len, NULL);
-	ASSERT_NE(calls, nullptr);
-	ASSERT_EQ(len, 1);
-
-	ASSERT_STREQ(calls->name, "EmitEvent");
-	ASSERT_EQ(g_variant_n_children(calls->params), 3);
-
-	GVariant * name = g_variant_get_child_value(calls->params, 0);
-	ASSERT_STREQ(g_variant_get_string(name, NULL), "application-start");
-	g_variant_unref(name);
-
-	GVariant * block = g_variant_get_child_value(calls->params, 2);
-	ASSERT_FALSE(g_variant_get_boolean(block));
+	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
+	EXPECT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	EXPECT_STREQ("Start", calls->name);
+	EXPECT_EQ(2, g_variant_n_children(calls->params));
+
+	GVariant * block = g_variant_get_child_value(calls->params, 1);
+	EXPECT_TRUE(g_variant_get_boolean(block));
 	g_variant_unref(block);
 
-	GVariant * env = g_variant_get_child_value(calls->params, 1);
-	ASSERT_TRUE(check_env(env, "APP_ID", "foo"));
+	GVariant * env = g_variant_get_child_value(calls->params, 0);
+	EXPECT_TRUE(check_env(env, "APP_ID", "foolike"));
 	g_variant_unref(env);
 
 	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
@@ -252,16 +295,16 @@
 		"file:///home/phablet/test.txt",
 		NULL
 	};
-	ASSERT_TRUE(upstart_app_launch_start_application("foo", urls));
+	ASSERT_TRUE(upstart_app_launch_start_application("foolike", urls));
 
 	len = 0;
-	calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "EmitEvent", &len, NULL);
-	ASSERT_NE(calls, nullptr);
-	ASSERT_EQ(len, 1);
+	calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
+	EXPECT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
 
-	env = g_variant_get_child_value(calls->params, 1);
-	ASSERT_TRUE(check_env(env, "APP_ID", "foo"));
-	ASSERT_TRUE(check_env(env, "APP_URIS", "'http://ubuntu.com/' 'https://ubuntu.com/' 'file:///home/phablet/test.txt'"));
+	env = g_variant_get_child_value(calls->params, 0);
+	EXPECT_TRUE(check_env(env, "APP_ID", "foolike"));
+	EXPECT_TRUE(check_env(env, "APP_URIS", "'http://ubuntu.com/' 'https://ubuntu.com/' 'file:///home/phablet/test.txt'"));
 	g_variant_unref(env);
 
 	return;
@@ -277,12 +320,27 @@
 
 }
 
+TEST_F(LibUAL, ApplicationLog)
+{
+	gchar * click_log = upstart_app_launch_application_log_path("foo");
+	EXPECT_STREQ(CMAKE_SOURCE_DIR "/upstart/application-click-foo.log", click_log);
+	g_free(click_log);
+
+	gchar * legacy_single = upstart_app_launch_application_log_path("single");
+	EXPECT_STREQ(CMAKE_SOURCE_DIR "/upstart/application-legacy-single-.log", legacy_single);
+	g_free(legacy_single);
+
+	gchar * legacy_multiple = upstart_app_launch_application_log_path("bar");
+	EXPECT_STREQ(CMAKE_SOURCE_DIR "/upstart/application-legacy-bar-2342345.log", legacy_multiple);
+	g_free(legacy_multiple);
+}
+
 TEST_F(LibUAL, ApplicationPid)
 {
-	ASSERT_EQ(upstart_app_launch_get_primary_pid("foo"), 1234);
-	ASSERT_EQ(upstart_app_launch_get_primary_pid("bar"), 5678);
-	ASSERT_TRUE(upstart_app_launch_pid_in_app_id(1234, "foo"));
-	ASSERT_FALSE(upstart_app_launch_pid_in_app_id(5678, "foo"));
+	EXPECT_EQ(upstart_app_launch_get_primary_pid("foo"), getpid());
+	EXPECT_EQ(upstart_app_launch_get_primary_pid("bar"), 5678);
+	EXPECT_TRUE(upstart_app_launch_pid_in_app_id(getpid(), "foo"));
+	EXPECT_FALSE(upstart_app_launch_pid_in_app_id(5678, "foo"));
 }
 
 TEST_F(LibUAL, ApplicationId)
@@ -527,3 +585,178 @@
 	g_dbus_connection_remove_filter(session, filter);
 	g_object_unref(session);
 }
+
+TEST_F(LibUAL, AppIdTest)
+{
+	ASSERT_TRUE(upstart_app_launch_start_application("foo", NULL));
+	pause(50); /* Ensure all the events come through */
+	EXPECT_EQ("foo", this->last_focus_appid);
+	EXPECT_EQ("foo", this->last_resume_appid);
+}
+
+GDBusMessage *
+filter_func_good (GDBusConnection * conn, GDBusMessage * message, gboolean incomming, gpointer user_data)
+{
+	if (!incomming) {
+		return message;
+	}
+
+	if (g_strcmp0(g_dbus_message_get_path(message), (gchar *)user_data) == 0) {
+		GDBusMessage * reply = g_dbus_message_new_method_reply(message);
+		g_dbus_connection_send_message(conn, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
+		g_object_unref(message);
+		return NULL;
+	}
+
+	return message;
+}
+
+TEST_F(LibUAL, UrlSendTest)
+{
+	GDBusConnection * session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	guint filter = g_dbus_connection_add_filter(session,
+		filter_func_good,
+		(gpointer)"/foo",
+		NULL);
+
+	const gchar * uris[] = {
+		"http://www.test.com",
+		NULL
+	};
+	ASSERT_TRUE(upstart_app_launch_start_application("foo", uris));
+	pause(100); /* Ensure all the events come through */
+
+	EXPECT_EQ("foo", this->last_focus_appid);
+	EXPECT_EQ("foo", this->last_resume_appid);
+
+	g_dbus_connection_remove_filter(session, filter);
+	g_object_unref(session);
+}
+
+TEST_F(LibUAL, UrlSendNoObjectTest)
+{
+	const gchar * uris[] = {
+		"http://www.test.com",
+		NULL
+	};
+
+	ASSERT_TRUE(upstart_app_launch_start_application("foo", uris));
+	pause(100); /* Ensure all the events come through */
+
+	EXPECT_EQ("foo", this->last_focus_appid);
+	EXPECT_EQ("foo", this->last_resume_appid);
+}
+
+TEST_F(LibUAL, UnityTimeoutTest)
+{
+	this->resume_timeout = 100;
+
+	ASSERT_TRUE(upstart_app_launch_start_application("foo", NULL));
+	pause(1000); /* Ensure all the events come through */
+	EXPECT_EQ("foo", this->last_focus_appid);
+	EXPECT_EQ("foo", this->last_resume_appid);
+}
+
+TEST_F(LibUAL, UnityTimeoutUriTest)
+{
+	this->resume_timeout = 200;
+
+	const gchar * uris[] = {
+		"http://www.test.com",
+		NULL
+	};
+
+	ASSERT_TRUE(upstart_app_launch_start_application("foo", uris));
+	pause(1000); /* Ensure all the events come through */
+	EXPECT_EQ("foo", this->last_focus_appid);
+	EXPECT_EQ("foo", this->last_resume_appid);
+}
+
+GDBusMessage *
+filter_respawn (GDBusConnection * conn, GDBusMessage * message, gboolean incomming, gpointer user_data)
+{
+	if (g_strcmp0(g_dbus_message_get_member(message), "UnityResumeResponse") == 0) {
+		g_object_unref(message);
+		return NULL;
+	}
+
+	return message;
+}
+
+TEST_F(LibUAL, UnityLostTest)
+{
+	GDBusConnection * session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	guint filter = g_dbus_connection_add_filter(session,
+		filter_respawn,
+		NULL,
+		NULL);
+
+	guint start = g_get_monotonic_time();
+
+	const gchar * uris[] = {
+		"http://www.test.com",
+		NULL
+	};
+
+	ASSERT_TRUE(upstart_app_launch_start_application("foo", uris));
+
+	guint end = g_get_monotonic_time();
+
+	EXPECT_LT(end - start, 600 * 1000);
+
+	pause(1000); /* Ensure all the events come through */
+
+	EXPECT_EQ("foo", this->last_focus_appid);
+	EXPECT_EQ("foo", this->last_resume_appid);
+
+	g_dbus_connection_remove_filter(session, filter);
+	g_object_unref(session);
+}
+
+
+TEST_F(LibUAL, LegacySingleInstance)
+{
+	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_legacy", "com.ubuntu.Upstart0_6.Job", NULL);
+
+	/* Check for a single-instance app */
+	ASSERT_TRUE(upstart_app_launch_start_application("single", NULL));
+
+	guint len = 0;
+	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
+	EXPECT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	EXPECT_STREQ("Start", calls->name);
+	EXPECT_EQ(2, g_variant_n_children(calls->params));
+
+	GVariant * block = g_variant_get_child_value(calls->params, 1);
+	EXPECT_TRUE(g_variant_get_boolean(block));
+	g_variant_unref(block);
+
+	GVariant * env = g_variant_get_child_value(calls->params, 0);
+	EXPECT_TRUE(check_env(env, "APP_ID", "single"));
+	EXPECT_TRUE(check_env(env, "INSTANCE_ID", ""));
+	g_variant_unref(env);
+
+	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+
+	/* Check for a multi-instance app */
+	ASSERT_TRUE(upstart_app_launch_start_application("multiple", NULL));
+
+	len = 0;
+	calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
+	EXPECT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	EXPECT_STREQ("Start", calls->name);
+	EXPECT_EQ(2, g_variant_n_children(calls->params));
+
+	block = g_variant_get_child_value(calls->params, 1);
+	EXPECT_TRUE(g_variant_get_boolean(block));
+	g_variant_unref(block);
+
+	env = g_variant_get_child_value(calls->params, 0);
+	EXPECT_TRUE(check_env(env, "APP_ID", "multiple"));
+	EXPECT_FALSE(check_env(env, "INSTANCE_ID", ""));
+	g_variant_unref(env);
+}

=== added directory 'tests/link-farm'
=== added file 'tests/link-farm/README'
--- tests/link-farm/README	1970-01-01 00:00:00 +0000
+++ tests/link-farm/README	2014-02-06 18:42:36 +0000
@@ -0,0 +1,3 @@
+This directory is setup as our testing link farm.  Anything that has a
+desktop in here will be detected as a click package, something without
+will be seen as a legacy package.

=== added file 'tests/link-farm/foo.desktop'
--- tests/link-farm/foo.desktop	1970-01-01 00:00:00 +0000
+++ tests/link-farm/foo.desktop	2014-02-06 18:42:36 +0000
@@ -0,0 +1,1 @@
+Needs to exist

=== added file 'tests/link-farm/foolike.desktop'
--- tests/link-farm/foolike.desktop	1970-01-01 00:00:00 +0000
+++ tests/link-farm/foolike.desktop	2014-02-06 18:42:36 +0000
@@ -0,0 +1,1 @@
+Needs to exist

=== removed file 'tests/second-exec-test.cc'
--- tests/second-exec-test.cc	2013-12-06 11:44:25 +0000
+++ tests/second-exec-test.cc	1970-01-01 00:00:00 +0000
@@ -1,205 +0,0 @@
-/*
- * Copyright 2013 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 <gtest/gtest.h>
-#include <gio/gio.h>
-
-extern "C" {
-#include "../second-exec-core.h"
-#include "upstart-app-launch.h"
-#include "upstart-app-launch-mock.h"
-}
-
-class SecondExecTest : public ::testing::Test
-{
-	private:
-		GTestDBus * testbus = NULL;
-
-	protected:
-		std::string last_focus_appid;
-		std::string last_resume_appid;
-		guint resume_timeout = 0;
-
-	private:
-		static void focus_cb (const gchar * appid, gpointer user_data) {
-			SecondExecTest * _this = static_cast<SecondExecTest *>(user_data);
-			_this->last_focus_appid = appid;
-		}
-
-		static void resume_cb (const gchar * appid, gpointer user_data) {
-			SecondExecTest * _this = static_cast<SecondExecTest *>(user_data);
-			_this->last_resume_appid = appid;
-
-			if (_this->resume_timeout > 0) {
-				_this->pause(_this->resume_timeout);
-			}
-		}
-
-	protected:
-		virtual void SetUp() {
-			testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
-			g_test_dbus_up(testbus);
-
-			upstart_app_launch_observer_add_app_focus(focus_cb, this);
-			upstart_app_launch_observer_add_app_resume(resume_cb, this);
-		}
-		virtual void TearDown() {
-			upstart_app_launch_observer_delete_app_focus(focus_cb, this);
-			upstart_app_launch_observer_delete_app_resume(resume_cb, this);
-
-			g_test_dbus_down(testbus);
-			g_object_unref(testbus);
-		}
-
-		static gboolean pause_helper (gpointer pmainloop) {
-			g_main_loop_quit((GMainLoop *)pmainloop);
-			return G_SOURCE_REMOVE;
-		}
-
-		void pause (guint time) {
-			if (time > 0) {
-				GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
-				guint timer = g_timeout_add(time, pause_helper, mainloop);
-
-				g_main_loop_run(mainloop);
-
-				g_source_remove(timer);
-				g_main_loop_unref(mainloop);
-			}
-
-			while (g_main_pending()) {
-				g_main_iteration(TRUE);
-			}
-		}
-};
-
-TEST_F(SecondExecTest, AppIdTest)
-{
-	ASSERT_TRUE(second_exec("foo", NULL));
-	pause(50); /* Ensure all the events come through */
-	ASSERT_STREQ(this->last_focus_appid.c_str(), "foo");
-	ASSERT_STREQ(this->last_resume_appid.c_str(), "foo");
-}
-
-GDBusMessage *
-filter_func_good (GDBusConnection * conn, GDBusMessage * message, gboolean incomming, gpointer user_data)
-{
-	if (!incomming) {
-		return message;
-	}
-
-	if (g_strcmp0(g_dbus_message_get_path(message), (gchar *)user_data) == 0) {
-		GDBusMessage * reply = g_dbus_message_new_method_reply(message);
-		g_dbus_connection_send_message(conn, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
-		g_object_unref(message);
-		return NULL;
-	}
-
-	return message;
-}
-
-TEST_F(SecondExecTest, UrlSendTest)
-{
-	upstart_app_launch_mock_set_primary_pid(getpid());
-
-	GDBusConnection * session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-	guint filter = g_dbus_connection_add_filter(session,
-		filter_func_good,
-		(gpointer)"/foo",
-		NULL);
-
-	ASSERT_TRUE(second_exec("foo", "http://www.test.com"));
-	pause(100); /* Ensure all the events come through */
-
-	ASSERT_STREQ(this->last_focus_appid.c_str(), "foo");
-	ASSERT_STREQ(this->last_resume_appid.c_str(), "foo");
-
-	g_dbus_connection_remove_filter(session, filter);
-	g_object_unref(session);
-}
-
-TEST_F(SecondExecTest, UrlSendNoObjectTest)
-{
-	upstart_app_launch_mock_set_primary_pid(getpid());
-
-	ASSERT_TRUE(second_exec("foo", "http://www.test.com"));
-	pause(100); /* Ensure all the events come through */
-
-	ASSERT_STREQ(this->last_focus_appid.c_str(), "foo");
-	ASSERT_STREQ(this->last_resume_appid.c_str(), "foo");
-}
-
-TEST_F(SecondExecTest, UnityTimeoutTest)
-{
-	this->resume_timeout = 100;
-
-	ASSERT_TRUE(second_exec("foo", NULL));
-	pause(100); /* Ensure all the events come through */
-	ASSERT_STREQ(this->last_focus_appid.c_str(), "foo");
-	ASSERT_STREQ(this->last_resume_appid.c_str(), "foo");
-}
-
-TEST_F(SecondExecTest, UnityTimeoutUriTest)
-{
-	this->resume_timeout = 200;
-
-	ASSERT_TRUE(second_exec("foo", "http://www.test.com"));
-	pause(100); /* Ensure all the events come through */
-	ASSERT_STREQ(this->last_focus_appid.c_str(), "foo");
-	ASSERT_STREQ(this->last_resume_appid.c_str(), "foo");
-}
-
-GDBusMessage *
-filter_respawn (GDBusConnection * conn, GDBusMessage * message, gboolean incomming, gpointer user_data)
-{
-	if (g_strcmp0(g_dbus_message_get_member(message), "UnityResumeResponse") == 0) {
-		g_object_unref(message);
-		return NULL;
-	}
-
-	return message;
-}
-
-TEST_F(SecondExecTest, UnityLostTest)
-{
-	upstart_app_launch_mock_set_primary_pid(getpid());
-
-	GDBusConnection * session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-	guint filter = g_dbus_connection_add_filter(session,
-		filter_respawn,
-		NULL,
-		NULL);
-
-	guint start = g_get_monotonic_time();
-
-	ASSERT_TRUE(second_exec("foo", "http://www.test.com"));
-
-	guint end = g_get_monotonic_time();
-
-	ASSERT_LT(end - start, 600 * 1000);
-
-	pause(100); /* Ensure all the events come through */
-	ASSERT_STREQ(this->last_focus_appid.c_str(), "foo");
-	ASSERT_STREQ(this->last_resume_appid.c_str(), "foo");
-
-	g_dbus_connection_remove_filter(session, filter);
-	g_object_unref(session);
-}
-
-