Merge lp:~ted/ubuntu-app-launch/snappy-backend-no-snap into lp:ubuntu-app-launch/16.10

[Ted Gould]

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:352
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~ted/ubuntu-app-launch/snappy-backend-no-snap/+merge/301966/+edit-commit-message

https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/18/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/277/console
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/283
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-1-sourcepkg/release=vivid+overlay/217
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-1-sourcepkg/release=xenial+overlay/217
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-1-sourcepkg/release=yakkety/217
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=vivid+overlay/146/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/146/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=yakkety/146/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=vivid+overlay/146/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/146/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=yakkety/146/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=vivid+overlay/146/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/146/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=yakkety/146/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-ubuntu-app-launch-ci/18/rebuild

review: Needs Fixing (continuous-integration)

[lp:~ted/ubuntu-app-launch/snappy-backend-no-snap]

353. By Ted Gould on 2016-08-04

Grab the revisions in the no-find-discover branch

354. By Ted Gould on 2016-08-04

Pulling through trunk

355. By Ted Gould on 2016-08-05

Adding comments to the functions

356. By Ted Gould on 2016-08-05

Adding comments to the functions

357. By Ted Gould on 2016-08-05

Fix some more comments

358. By Ted Gould on 2016-08-12

Pull through OOM updates

359. By Ted Gould on 2016-08-18

Fix legacy instance pull through

360. By Ted Gould on 2016-08-23

Updating to trunk

361. By Ted Gould on 2016-08-24

Bring in updates to no-find-discover branch

362. By Ted Gould on 2016-08-24

Fix abicheck

363. By Ted Gould on 2016-08-24

Write text explaining the app id schemes for the various backends

364. By Ted Gould on 2016-08-24

Use empty instead of checking the size

365. By Ted Gould on 2016-08-24

Going full auto

366. By Ted Gould on 2016-08-24

Removing a string cast

367. By Ted Gould on 2016-08-24

Spelling fix

368. By Ted Gould on 2016-08-24

Make sure we don't copy the tools structures

369. By Ted Gould on 2016-08-26

Grab changes and Jenkins fixes

370. By Ted Gould on 2016-08-26

Getting some list bus love

371. By Ted Gould on 2016-09-06

Merging trunk

Unmerged revisions

=== modified file 'docs/index.rst'
--- docs/index.rst	2016-04-29 14:20:11 +0000
+++ docs/index.rst	2016-08-04 14:02:19 +0000
@@ -109,7 +109,7 @@
 Application Icon Finder
 ------------------------
 
-.. doxygenclass:: ubuntu::app_launch::app_info::IconFinder
+.. doxygenclass:: ubuntu::app_launch::IconFinder
    :project: libubuntu-app-launch
    :members:
    :protected-members:
@@ -146,6 +146,16 @@
    :private-members:
    :undoc-members:
 
+Upstart Instance
+----------------
+
+.. doxygenclass:: ubuntu::app_launch::app_impls::UpstartInstance
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
 Quality
 =======
 

=== modified file 'helpers.c'
--- helpers.c	2016-08-04 14:02:18 +0000
+++ helpers.c	2016-08-04 14:02:19 +0000
@@ -490,7 +490,7 @@
 	GDBusConnection * con;
 	GMainLoop * mainloop;
 	guint signal_subscribe;
-	guint timeout;
+	GSource * timeout;
 };
 
 static gboolean
@@ -498,7 +498,7 @@
 {
 	handshake_t * handshake = (handshake_t *)user_data;
 	g_main_loop_quit(handshake->mainloop);
-	handshake->timeout = 0;
+	handshake->timeout = NULL;
 	return G_SOURCE_REMOVE;
 }
 
@@ -508,7 +508,9 @@
 	GError * error = NULL;
 	handshake_t * handshake = g_new0(handshake_t, 1);
 
-	handshake->mainloop = g_main_loop_new(NULL, FALSE);
+	GMainContext * context = g_main_context_get_thread_default();
+
+	handshake->mainloop = g_main_loop_new(context, FALSE);
 	handshake->con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
 
 	if (error != NULL) {
@@ -539,7 +541,9 @@
 		&error);
 
 	/* Really, Unity? */
-	handshake->timeout = g_timeout_add_seconds(1, unity_too_slow_cb, handshake);
+	handshake->timeout = g_timeout_source_new_seconds(1);
+	g_source_set_callback(handshake->timeout, unity_too_slow_cb, handshake, NULL);
+	g_source_attach(handshake->timeout, context);
 
 	return handshake;
 }
@@ -552,8 +556,11 @@
 
 	g_main_loop_run(handshake->mainloop);
 
-	if (handshake->timeout != 0)
-		g_source_remove(handshake->timeout);
+	if (handshake->timeout != NULL) {
+		g_source_destroy(handshake->timeout);
+		g_source_unref(handshake->timeout);
+		handshake->timeout = NULL;
+	}
 	g_main_loop_unref(handshake->mainloop);
 	g_dbus_connection_signal_unsubscribe(handshake->con, handshake->signal_subscribe);
 	g_object_unref(handshake->con);

=== modified file 'helpers.h'
--- helpers.h	2015-07-15 02:32:54 +0000
+++ helpers.h	2016-08-04 14:02:19 +0000
@@ -19,6 +19,8 @@
 
 #include <gio/gio.h>
 
+G_BEGIN_DECLS
+
 typedef struct _EnvHandle EnvHandle;
 
 gboolean  app_id_to_triplet      (const gchar *   app_id,
@@ -56,3 +58,6 @@
 
 gboolean   verify_keyfile        (GKeyFile *    inkeyfile,
                                   const gchar * desktop);
+
+G_END_DECLS
+

=== modified file 'libubuntu-app-launch/CMakeLists.txt'
--- libubuntu-app-launch/CMakeLists.txt	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2016-08-04 14:02:19 +0000
@@ -41,25 +41,26 @@
 registry-impl.cpp
 application-impl-base.h
 application-impl-base.cpp
+application-impl-click.h
 application-impl-click.cpp
 application-impl-legacy.h
 application-impl-legacy.cpp
 application-impl-libertine.h
 application-impl-libertine.cpp
+application-info-desktop.h
 application-info-desktop.cpp
+application-icon-finder.h
 application-icon-finder.cpp
 helper-impl-click.cpp
+glib-thread.h
 glib-thread.cpp
 )
 
 set(LAUNCHER_SOURCES
 ubuntu-app-launch.cpp
 second-exec-core.c
-click-exec.c
-desktop-exec.c
 ubuntu-app-launch-trace.c
 app-info.c
-${LAUNCHER_CPP_SOURCES}
 )
 
 add_custom_target(format

=== modified file 'libubuntu-app-launch/app-info.c'
--- libubuntu-app-launch/app-info.c	2015-08-12 02:52:05 +0000
+++ libubuntu-app-launch/app-info.c	2016-08-04 14:02:19 +0000
@@ -21,10 +21,12 @@
 #include <click.h>
 
 #include "ubuntu-app-launch.h"
-#include "app-info.h"
+
+/* Prototypes */
+static gboolean app_info_libertine (const gchar * appid, gchar ** appdir, gchar ** appdesktop);
 
 /* Try and get a manifest and do a couple sanity checks on it */
-JsonObject *
+static JsonObject *
 get_manifest (const gchar * pkg, gchar ** pkgpath)
 {
 	/* Get the directory from click */
@@ -76,130 +78,6 @@
 	return manifest;
 }
 
-/* Types of search we can do for an app name */
-typedef enum _app_name_t app_name_t;
-enum _app_name_t {
-	APP_NAME_ONLY,
-	APP_NAME_FIRST,
-	APP_NAME_LAST
-};
-
-/* Figure out the app name if it's one of the keywords */
-static const gchar *
-manifest_app_name (JsonObject ** manifest, const gchar * pkg, const gchar * original_app)
-{
-	app_name_t app_type = APP_NAME_FIRST;
-
-	if (original_app == NULL) {
-		/* first */
-	} else if (g_strcmp0(original_app, "first-listed-app") == 0) {
-		/* first */
-	} else if (g_strcmp0(original_app, "last-listed-app") == 0) {
-		app_type = APP_NAME_LAST;
-	} else if (g_strcmp0(original_app, "only-listed-app") == 0) {
-		app_type = APP_NAME_ONLY;
-	} else {
-		return original_app;
-	}
-
-	if (*manifest == NULL) {
-		*manifest = get_manifest(pkg, NULL);
-	}
-
-	JsonObject * hooks = json_object_get_object_member(*manifest, "hooks");
-
-	if (hooks == NULL) {
-		return NULL;
-	}
-
-	GList * apps = json_object_get_members(hooks);
-	if (apps == NULL) {
-		return NULL;
-	}
-
-	const gchar * retapp = NULL;
-
-	switch (app_type) {
-	case APP_NAME_ONLY:
-		if (g_list_length(apps) == 1) {
-			retapp = (const gchar *)apps->data;
-		}
-		break;
-	case APP_NAME_FIRST:
-		retapp = (const gchar *)apps->data;
-		break;
-	case APP_NAME_LAST:
-		retapp = (const gchar *)(g_list_last(apps)->data);
-		break;
-	default:
-		break;
-	}
-
-	g_list_free(apps);
-
-	return retapp;
-}
-
-/* Figure out the app version using the manifest */
-static const gchar *
-manifest_version (JsonObject ** manifest, const gchar * pkg, const gchar * original_ver)
-{
-	if (original_ver != NULL && g_strcmp0(original_ver, "current-user-version") != 0) {
-		return original_ver;
-	} else  {
-		if (*manifest == NULL) {
-			*manifest = get_manifest(pkg, NULL);
-		}
-		g_return_val_if_fail(*manifest != NULL, NULL);
-
-		return g_strdup(json_object_get_string_member(*manifest, "version"));
-	}
-
-	return NULL;
-}
-
-/* A click triplet can require using the Click DB and getting a
-   manifest. This code does that to look up the versions */
-gchar *
-click_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver)
-{
-	const gchar * version = NULL;
-	const gchar * application = NULL;
-	JsonObject * manifest = NULL;
-
-	version = manifest_version(&manifest, pkg, ver);
-	g_return_val_if_fail(version != NULL, NULL);
-
-	application = manifest_app_name(&manifest, pkg, app);
-	g_return_val_if_fail(application != NULL, NULL);
-
-	gchar * retval = g_strdup_printf("%s_%s_%s", pkg, application, version);
-
-	/* The object may hold allocation for some of our strings used above */
-	if (manifest)
-		json_object_unref(manifest);
-
-	return retval;
-}
-
-/* Build an appid how we think it should exist and then make sure
-   we can find it. Then pull it together. */
-gchar *
-libertine_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver)
-{
-	if (app == NULL) {
-		return NULL;
-	}
-
-	gchar * synthappid = g_strdup_printf("%s_%s_0.0", pkg, app);
-	if (app_info_libertine(synthappid, NULL, NULL)) {
-		return synthappid;
-	} else {
-		g_free(synthappid);
-		return NULL;
-	}
-}
-
 /* Look to see if the app id results in a desktop file, if so, fill in the params */
 static gboolean
 evaluate_dir (const gchar * dir, const gchar * desktop, gchar ** appdir, gchar ** appdesktop)
@@ -224,7 +102,7 @@
 }
 
 /* Handle the legacy case where we look through the data directories */
-gboolean
+static gboolean
 app_info_legacy (const gchar * appid, gchar ** appdir, gchar ** appdesktop)
 {
 	gchar * desktop = g_strdup_printf("%s.desktop", appid);
@@ -248,7 +126,7 @@
 }
 
 /* Handle the libertine case where we look in the container */
-gboolean
+static gboolean
 app_info_libertine (const gchar * appid, gchar ** appdir, gchar ** appdesktop)
 {
 	char * container = NULL;
@@ -301,7 +179,7 @@
 }
 
 /* Get the information on where the desktop file is from libclick */
-gboolean
+static gboolean
 app_info_click (const gchar * appid, gchar ** appdir, gchar ** appdesktop)
 {
 	gchar * package = NULL;
@@ -352,3 +230,48 @@
 	return TRUE;
 }
 
+/* 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("UBUNTU_APP_LAUNCH_LINK_FARM");
+	if (G_LIKELY(link_farm_dir == NULL)) {
+		click_link = g_build_filename(g_get_home_dir(), ".cache", "ubuntu-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;
+}
+
+/* Determine whether an AppId is realated to a Libertine container by
+   checking the container and program name. */
+static gboolean
+is_libertine (const gchar * appid)
+{
+	if (app_info_libertine(appid, NULL, NULL)) {
+		g_debug("Libertine application detected: %s", appid);
+		return TRUE;
+	} else {
+		return FALSE;
+	}
+}
+
+gboolean
+ubuntu_app_launch_application_info (const gchar * appid, gchar ** appdir, gchar ** appdesktop)
+{
+	if (is_click(appid)) {
+		return app_info_click(appid, appdir, appdesktop);
+	} else if (is_libertine(appid)) {
+		return app_info_libertine(appid, appdir, appdesktop);
+	} else {
+		return app_info_legacy(appid, appdir, appdesktop);
+	}
+}
+

=== removed file 'libubuntu-app-launch/app-info.h'
--- libubuntu-app-launch/app-info.h	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/app-info.h	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-/*
- * 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 <gio/gio.h>
-
-G_BEGIN_DECLS
-
-gboolean app_info_legacy (const gchar * appid, gchar ** appdir, gchar ** appdesktop);
-gboolean app_info_libertine (const gchar * appid, gchar ** appdir, gchar ** appdesktop);
-gboolean app_info_click (const gchar * appid, gchar ** appdir, gchar ** appdesktop);
-
-gchar * click_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver);
-gchar * libertine_triplet_to_app_id (const gchar * pkg, const gchar * app, const gchar * ver);
-
-gboolean start_application_core (GDBusConnection * con, GCancellable * cancel, const gchar * appid, const gchar * const * uris, gboolean test);
-
-G_END_DECLS

=== modified file 'libubuntu-app-launch/appid.h'
--- libubuntu-app-launch/appid.h	2016-04-18 18:29:32 +0000
+++ libubuntu-app-launch/appid.h	2016-08-04 14:02:19 +0000
@@ -29,6 +29,8 @@
 namespace app_launch
 {
 
+class Registry;
+
 /** \brief The set of information that is used to uniquely identify an
            application in Ubuntu.
 
@@ -104,9 +106,21 @@
         It can be used, but is slower than parse() if you've got well formed data
         already.
 
+        \note This will use the default registry instance, it is generally
+              recommended to have your own instead of using the default.
+
         \param sappid String with the concatenated AppID
     */
     static AppID find(const std::string& sappid);
+    /** Find is a more tollerant version of parse(), it handles legacy applications,
+        short AppIDs ($package_$app) and other forms of that are in common usage.
+        It can be used, but is slower than parse() if you've got well formed data
+        already.
+
+        \param registry Registry instance to use for persistant connections
+        \param sappid String with the concatenated AppID
+    */
+    static AppID find(const std::shared_ptr<Registry>& registry, const std::string& sappid);
     /** Check to see whether a string is a valid AppID string
 
         \param sappid String with the concatenated AppID
@@ -130,6 +144,9 @@
     /** Find the AppID for an application where you only know the package
         name.
 
+        \note This will use the default registry instance, it is generally
+              recommended to have your own instead of using the default.
+
         \param package Name of the package
         \param appwildcard Specification of how to search the manifest for apps
         \param versionwildcard Specification of how to search for the version
@@ -140,6 +157,9 @@
     /** Find the AppID for an application where you know the package
         name and application name.
 
+        \note This will use the default registry instance, it is generally
+              recommended to have your own instead of using the default.
+
         \param package Name of the package
         \param appname Name of the application
         \param versionwildcard Specification of how to search for the version
@@ -149,15 +169,55 @@
                           VersionWildcard versionwildcard = VersionWildcard::CURRENT_USER_VERSION);
     /** Create an AppID providing known strings of packages and names
 
+        \note This will use the default registry instance, it is generally
+              recommended to have your own instead of using the default.
+
         \param package Name of the package
         \param appname Name of the application
         \param version Version of the package
     */
     static AppID discover(const std::string& package, const std::string& appname, const std::string& version);
+
+    /** Find the AppID for an application where you only know the package
+        name.
+
+        \param registry Registry instance to use for persistant connections
+        \param package Name of the package
+        \param appwildcard Specification of how to search the manifest for apps
+        \param versionwildcard Specification of how to search for the version
+    */
+    static AppID discover(const std::shared_ptr<Registry>& registry,
+                          const std::string& package,
+                          ApplicationWildcard appwildcard = ApplicationWildcard::FIRST_LISTED,
+                          VersionWildcard versionwildcard = VersionWildcard::CURRENT_USER_VERSION);
+    /** Find the AppID for an application where you know the package
+        name and application name.
+
+        \param registry Registry instance to use for persistant connections
+        \param package Name of the package
+        \param appname Name of the application
+        \param versionwildcard Specification of how to search for the version
+    */
+    static AppID discover(const std::shared_ptr<Registry>& registry,
+                          const std::string& package,
+                          const std::string& appname,
+                          VersionWildcard versionwildcard = VersionWildcard::CURRENT_USER_VERSION);
+    /** Create an AppID providing known strings of packages and names
+
+        \param registry Registry instance to use for persistant connections
+        \param package Name of the package
+        \param appname Name of the application
+        \param version Version of the package
+    */
+    static AppID discover(const std::shared_ptr<Registry>& registry,
+                          const std::string& package,
+                          const std::string& appname,
+                          const std::string& version);
 };
 
 bool operator==(const AppID& a, const AppID& b);
 bool operator!=(const AppID& a, const AppID& b);
+bool operator<(const AppID& a, const AppID& b);
 
 };  // namespace app_launch
 };  // namespace ubuntu

=== modified file 'libubuntu-app-launch/application-impl-base.cpp'
--- libubuntu-app-launch/application-impl-base.cpp	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application-impl-base.cpp	2016-08-04 14:02:19 +0000
@@ -25,9 +25,10 @@
 
 #include <upstart.h>
 
-#include "app-info.h"
 #include "application-impl-base.h"
+#include "helpers.h"
 #include "registry-impl.h"
+#include "second-exec-core.h"
 
 namespace ubuntu
 {
@@ -46,6 +47,49 @@
     return !instances().empty();
 }
 
+std::list<std::pair<std::string, std::string>> Base::confinedEnv(const std::string& package, const std::string& pkgdir)
+{
+    std::list<std::pair<std::string, std::string>> retval{{"UBUNTU_APPLICATION_ISOLATION", "1"}};
+
+    /* C Funcs can return null, which offends std::string */
+    auto cset = [&retval](const gchar* key, const gchar* value) {
+        if (value != nullptr)
+        {
+            g_debug("Setting '%s' to '%s'", key, value);
+            retval.emplace_back(std::make_pair(key, value));
+        }
+    };
+
+    cset("XDG_CACHE_HOME", g_get_user_cache_dir());
+    cset("XDG_CONFIG_HOME", g_get_user_config_dir());
+    cset("XDG_DATA_HOME", g_get_user_data_dir());
+    cset("XDG_RUNTIME_DIR", g_get_user_runtime_dir());
+
+    /* Add the application's dir to the list of sources for data */
+    const gchar* basedatadirs = g_getenv("XDG_DATA_DIRS");
+    if (basedatadirs == NULL || basedatadirs[0] == '\0')
+    {
+        basedatadirs = "/usr/local/share:/usr/share";
+    }
+    gchar* datadirs = g_strjoin(":", pkgdir.c_str(), basedatadirs, NULL);
+    cset("XDG_DATA_DIRS", datadirs);
+    g_free(datadirs);
+
+    /* Set TMPDIR to something sane and application-specific */
+    gchar* tmpdir = g_strdup_printf("%s/confined/%s", g_get_user_runtime_dir(), package.c_str());
+    cset("TMPDIR", tmpdir);
+    g_debug("Creating '%s'", tmpdir);
+    g_mkdir_with_parents(tmpdir, 0700);
+    g_free(tmpdir);
+
+    /* Do the same for nvidia */
+    gchar* nv_shader_cachedir = g_strdup_printf("%s/%s", g_get_user_cache_dir(), package.c_str());
+    cset("__GL_SHADER_DISK_CACHE_PATH", nv_shader_cachedir);
+    g_free(nv_shader_cachedir);
+
+    return retval;
+}
+
 bool UpstartInstance::isRunning()
 {
     return primaryPid() != 0;
@@ -157,17 +201,20 @@
 
 std::string UpstartInstance::logPath()
 {
-    auto cpath = ubuntu_app_launch_application_log_path(std::string(appId_).c_str());
-    if (cpath != nullptr)
-    {
-        std::string retval(cpath);
-        g_free(cpath);
-        return retval;
-    }
-    else
-    {
-        return {};
-    }
+    std::string logfile = job_;
+    if (!instance_.empty())
+    {
+        logfile += "-";
+        logfile += instance_;
+    }
+
+    logfile += ".log";
+
+    gchar* cpath = g_build_filename(g_get_user_cache_dir(), "upstart", logfile.c_str(), nullptr);
+    std::string path(cpath);
+    g_free(cpath);
+
+    return path;
 }
 
 std::vector<pid_t> UpstartInstance::pids()
@@ -209,7 +256,65 @@
 
 void UpstartInstance::stop()
 {
-    ubuntu_app_launch_stop_application(std::string(appId_).c_str());
+    if (!registry_->impl->thread.executeOnThread<bool>([this]() {
+
+            g_debug("Stopping job %s app_id %s instance_id %s", job_.c_str(), std::string(appId_).c_str(),
+                    instance_.c_str());
+
+            auto jobpath = registry_->impl->upstartJobPath(job_);
+            if (jobpath.empty())
+            {
+                throw new std::runtime_error("Unable to get job path for Upstart job '" + job_ + "'");
+            }
+
+            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", std::string(appId_).c_str())));
+
+            if (!instance_.empty())
+            {
+                g_variant_builder_add_value(
+                    &builder, g_variant_new_take_string(g_strdup_printf("INSTANCE_ID=%s", instance_.c_str())));
+            }
+
+            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(registry_->impl->_dbus.get(),                   /* Dbus */
+                                            DBUS_SERVICE_UPSTART,                           /* Upstart name */
+                                            jobpath.c_str(),                                /* path */
+                                            DBUS_INTERFACE_UPSTART_JOB,                     /* interface */
+                                            "Stop",                                         /* method */
+                                            g_variant_builder_end(&builder),                /* params */
+                                            NULL,                                           /* return */
+                                            G_DBUS_CALL_FLAGS_NONE,                         /* flags */
+                                            -1,                                             /* timeout: default */
+                                            registry_->impl->thread.getCancellable().get(), /* cancelable */
+                                            &error);                                        /* error (hopefully not) */
+
+            if (stop_variant != nullptr)
+            {
+                g_variant_unref(stop_variant);
+            }
+
+            if (error != NULL)
+            {
+                g_warning("Unable to stop job %s app_id %s instance_id %s: %s", job_.c_str(),
+                          std::string(appId_).c_str(), instance_.c_str(), error->message);
+                g_error_free(error);
+                return false;
+            }
+
+            return true;
+        }))
+    {
+        g_warning("Unable to stop Upstart instance");
+    }
 }
 
 /** Sets the OOM adjustment by getting the list of PIDs and writing
@@ -461,15 +566,19 @@
 UpstartInstance::UpstartInstance(const AppID& appId,
                                  const std::string& job,
                                  const std::string& instance,
+                                 const std::vector<Application::URL>& urls,
                                  const std::shared_ptr<Registry>& registry)
     : appId_(appId)
     , job_(job)
     , instance_(instance)
+    , urls_(urls)
     , registry_(registry)
 {
+    g_debug("Creating a new UpstartInstance for '%s' instance '%s'", std::string(appId_).c_str(), instance.c_str());
 }
 
-std::shared_ptr<gchar*> urlsToStrv(const std::vector<Application::URL>& urls)
+/** Reformat a C++ vector of URLs into a C GStrv of strings */
+std::shared_ptr<gchar*> UpstartInstance::urlsToStrv(const std::vector<Application::URL>& urls)
 {
     if (urls.empty())
     {
@@ -481,32 +590,176 @@
     for (auto url : urls)
     {
         auto str = g_strdup(url.value().c_str());
+        g_debug("Converting URL: %s", str);
         g_array_append_val(array, str);
     }
 
     return std::shared_ptr<gchar*>((gchar**)g_array_free(array, FALSE), g_strfreev);
 }
 
-std::shared_ptr<UpstartInstance> UpstartInstance::launch(const AppID& appId,
-                                                         const std::string& job,
-                                                         const std::string& instance,
-                                                         const std::vector<Application::URL>& urls,
-                                                         const std::shared_ptr<Registry>& registry,
-                                                         launchMode mode)
-{
-    auto urlstrv = urlsToStrv(urls);
-    auto start_result = registry->impl->thread.executeOnThread<gboolean>([registry, &appId, &urlstrv, &mode]() {
-        return start_application_core(registry->impl->_dbus.get(), registry->impl->thread.getCancellable().get(),
-                                      std::string(appId).c_str(), urlstrv.get(),
-                                      mode == launchMode::STANDARD ? FALSE : TRUE);
-    });
-
-    if (start_result == FALSE)
+/** Small helper that we can new/delete to work better with C stuff */
+struct StartCHelper
+{
+    std::shared_ptr<UpstartInstance> ptr;
+};
+
+/** Callback from starting an application. It checks to see whether the
+    app is already running. If it is already running then we need to send
+    the URLs to it via DBus. */
+void UpstartInstance::application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data)
+{
+    StartCHelper* data = reinterpret_cast<StartCHelper*>(user_data);
+    GError* error{nullptr};
+    GVariant* result{nullptr};
+
+    // ual_tracepoint(libual_start_message_callback, std::string(data->appId_).c_str());
+
+    g_debug("Started Message Callback: %s", std::string(data->ptr->appId_).c_str());
+
+    result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(obj), res, &error);
+
+    if (result != nullptr)
+        g_variant_unref(result);
+
+    if (error != nullptr)
     {
+        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)
+            {
+                auto urls = urlsToStrv(data->ptr->urls_);
+                second_exec(data->ptr->registry_->impl->_dbus.get(),                   /* DBus */
+                            data->ptr->registry_->impl->thread.getCancellable().get(), /* cancellable */
+                            data->ptr->primaryPid(),                                   /* primary pid */
+                            std::string(data->ptr->appId_).c_str(),                    /* appid */
+                            urls.get());                                               /* urls */
+            }
+
+            g_free(remote_error);
+        }
+        else
+        {
+            g_warning("Unable to emit event to start application: %s", error->message);
+        }
+        g_error_free(error);
+    }
+
+    delete data;
+}
+
+std::shared_ptr<UpstartInstance> UpstartInstance::launch(
+    const AppID& appId,
+    const std::string& job,
+    const std::string& instance,
+    const std::vector<Application::URL>& urls,
+    const std::shared_ptr<Registry>& registry,
+    launchMode mode,
+    std::function<std::list<std::pair<std::string, std::string>>(void)> getenv)
+{
+    if (appId.empty())
         return {};
-    }
-
-    return std::make_shared<UpstartInstance>(appId, job, instance, registry);
+
+    return registry->impl->thread.executeOnThread<std::shared_ptr<UpstartInstance>>(
+        [&]() -> std::shared_ptr<UpstartInstance> {
+            g_debug("Initializing params for an new UpstartInstance for: %s", std::string(appId).c_str());
+
+            // ual_tracepoint(libual_start, appid);
+            handshake_t* handshake = starting_handshake_start(std::string(appId).c_str());
+            if (handshake == NULL)
+            {
+                g_warning("Unable to setup starting handshake");
+            }
+
+            /* Figure out the DBus path for the job */
+            auto jobpath = registry->impl->upstartJobPath(job);
+
+            /* Build up our environment */
+            std::list<std::pair<std::string, std::string>> env{
+                {"APP_ID", std::string(appId)},                 /* Application ID */
+                {"APP_LAUNCHER_PID", std::to_string(getpid())}, /* Who we are, for bugs */
+            };
+
+            if (!urls.empty())
+            {
+                env.emplace_back(std::make_pair(
+                    "APP_URIS", std::accumulate(urls.begin(), urls.end(), std::string{},
+                                                [](const std::string& prev, Application::URL thisurl) {
+                                                    gchar* gescaped = g_shell_quote(thisurl.value().c_str());
+                                                    std::string escaped;
+                                                    if (gescaped != nullptr)
+                                                    {
+                                                        escaped = gescaped;
+                                                        g_free(gescaped);
+                                                    }
+                                                    else
+                                                    {
+                                                        g_warning("Unable to escape URL: %s", thisurl.value().c_str());
+                                                        return prev;
+                                                    }
+
+                                                    if (prev.empty())
+                                                    {
+                                                        return escaped;
+                                                    }
+                                                    else
+                                                    {
+                                                        return prev + " " + escaped;
+                                                    }
+                                                })));
+            }
+
+            if (mode == launchMode::TEST)
+            {
+                env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
+            }
+
+            env.splice(env.end(), getenv());
+
+            /* Convert to GVariant */
+            GVariantBuilder builder;
+            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+            for (auto envvar : env)
+            {
+                g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf(
+                                                          "%s=%s", envvar.first.c_str(), envvar.second.c_str())));
+            }
+
+            g_variant_builder_close(&builder);
+            g_variant_builder_add_value(&builder, g_variant_new_boolean(TRUE));
+
+            auto retval = std::make_shared<UpstartInstance>(appId, job, instance, urls, registry);
+            auto chelper = new StartCHelper{};
+            chelper->ptr = retval;
+
+            // ual_tracepoint(handshake_wait, app_id);
+            starting_handshake_wait(handshake);
+            // ual_tracepoint(handshake_complete, app_id);
+
+            /* Call the job start function */
+            g_debug("Asking Upstart to start task for: %s", std::string(appId).c_str());
+            g_dbus_connection_call(registry->impl->_dbus.get(),                   /* bus */
+                                   DBUS_SERVICE_UPSTART,                          /* service name */
+                                   jobpath.c_str(),                               /* Path */
+                                   DBUS_INTERFACE_UPSTART_JOB,                    /* interface */
+                                   "Start",                                       /* method */
+                                   g_variant_builder_end(&builder),               /* params */
+                                   NULL,                                          /* return */
+                                   G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                   -1,                                            /* default timeout */
+                                   registry->impl->thread.getCancellable().get(), /* cancelable */
+                                   application_start_cb,                          /* callback */
+                                   chelper                                        /* object */
+                                   );
+
+            // ual_tracepoint(libual_start_message_sent, appid);
+
+            return retval;
+        });
 }
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-base.h'
--- libubuntu-app-launch/application-impl-base.h	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application-impl-base.h	2016-08-04 14:02:19 +0000
@@ -21,6 +21,7 @@
 
 extern "C" {
 #include "ubuntu-app-launch.h"
+#include <gio/gio.h>
 }
 
 #pragma once
@@ -32,6 +33,9 @@
 namespace app_impls
 {
 
+/** Provides some helper functions that can be used by all
+    implementations of application. Stores the registry pointer
+        which everyone wants anyway. */
 class Base : public ubuntu::app_launch::Application
 {
 public:
@@ -40,15 +44,24 @@
     bool hasInstances() override;
 
 protected:
+    /** Pointer to the registry so we can ask it for things */
     std::shared_ptr<Registry> _registry;
+
+    static std::list<std::pair<std::string, std::string>> confinedEnv(const std::string& package,
+                                                                      const std::string& pkgdir);
 };
 
+/** An object that represents an instance of a job on Upstart. This
+    then implements everything needed by the instance interface. Most
+    applications tie into this today and use it as the backend for
+    their instances. */
 class UpstartInstance : public Application::Instance
 {
 public:
     explicit UpstartInstance(const AppID& appId,
                              const std::string& job,
                              const std::string& instance,
+                             const std::vector<Application::URL>& urls,
                              const std::shared_ptr<Registry>& registry);
 
     /* Query lifecycle */
@@ -67,23 +80,32 @@
     void setOomAdjustment(const oom::Score score) override;
     const oom::Score getOomAdjustment() override;
 
-    /* Creating by launch */
+    /** Flag for whether we should include the testing environment variables */
     enum class launchMode
     {
-        STANDARD,
-        TEST
+        STANDARD, /**< Standard variable set */
+        TEST      /**< Include testing environment vars */
     };
-    static std::shared_ptr<UpstartInstance> launch(const AppID& appId,
-                                                   const std::string& job,
-                                                   const std::string& instance,
-                                                   const std::vector<Application::URL>& urls,
-                                                   const std::shared_ptr<Registry>& registry,
-                                                   launchMode mode);
+    static std::shared_ptr<UpstartInstance> launch(
+        const AppID& appId,
+        const std::string& job,
+        const std::string& instance,
+        const std::vector<Application::URL>& urls,
+        const std::shared_ptr<Registry>& registry,
+        launchMode mode,
+        std::function<std::list<std::pair<std::string, std::string>>(void)> getenv);
 
 private:
+    /** Application ID */
     const AppID appId_;
+    /** Upstart job name */
     const std::string job_;
+    /** Instance ID environment value, empty if none */
     const std::string instance_;
+    /** The URLs that this was launched for. Only valid on launched jobs, we
+        should look at perhaps changing that. */
+    std::vector<Application::URL> urls_;
+    /** A link to the registry we're using for connections */
     std::shared_ptr<Registry> registry_;
 
     std::vector<pid_t> forAllPids(std::function<void(pid_t)> eachPid);
@@ -92,6 +114,9 @@
     void oomValueToPid(pid_t pid, const oom::Score oomvalue);
     void oomValueToPidHelper(pid_t pid, const oom::Score oomvalue);
     void pidListToDbus(const std::vector<pid_t>& pids, const std::string& signal);
+
+    static std::shared_ptr<gchar*> urlsToStrv(const std::vector<Application::URL>& urls);
+    static void application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data);
 };
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-click.cpp'
--- libubuntu-app-launch/application-impl-click.cpp	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application-impl-click.cpp	2016-08-04 14:02:19 +0000
@@ -47,7 +47,7 @@
     , _appid(appid)
     , _manifest(manifest)
     , _clickDir(registry->impl->getClickDir(appid.package))
-    , _keyfile(manifestAppDesktop(manifest, appid.package, appid.appname, _clickDir))
+    , _keyfile(manifestAppDesktop(_manifest, appid.package, appid.appname, _clickDir))
 {
     if (!_keyfile)
         throw std::runtime_error{"No keyfile found for click application: " + (std::string)appid};
@@ -58,9 +58,90 @@
     return _appid;
 }
 
+bool Click::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    std::string appiddesktop = std::string(appid) + ".desktop";
+    gchar* click_link = nullptr;
+    const gchar* link_farm_dir = g_getenv("UBUNTU_APP_LAUNCH_LINK_FARM");
+    if (G_LIKELY(link_farm_dir == nullptr))
+    {
+        click_link =
+            g_build_filename(g_get_user_cache_dir(), "ubuntu-app-launch", "desktop", appiddesktop.c_str(), NULL);
+    }
+    else
+    {
+        click_link = g_build_filename(link_farm_dir, appiddesktop.c_str(), NULL);
+    }
+
+    bool click = g_file_test(click_link, G_FILE_TEST_EXISTS);
+    g_free(click_link);
+
+    return click;
+}
+
+bool Click::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
+{
+    return registry->impl->getClickManifest(package) != nullptr;
+}
+
+bool Click::verifyAppname(const AppID::Package& package,
+                          const AppID::AppName& appname,
+                          const std::shared_ptr<Registry>& registry)
+{
+    auto manifest = registry->impl->getClickManifest(package);
+    auto apps = manifestApps(manifest);
+
+    return std::find_if(apps.begin(), apps.end(), [&appname](const AppID::AppName& listApp) -> bool {
+               return appname.value() == listApp.value();
+           }) != apps.end();
+}
+
+AppID::AppName Click::findAppname(const AppID::Package& package,
+                                  AppID::ApplicationWildcard card,
+                                  const std::shared_ptr<Registry>& registry)
+{
+    auto manifest = registry->impl->getClickManifest(package);
+    auto apps = manifestApps(manifest);
+
+    if (apps.size() == 0)
+    {
+        throw std::runtime_error("No apps in package '" + package.value() + "' to find");
+    }
+
+    switch (card)
+    {
+        case AppID::ApplicationWildcard::FIRST_LISTED:
+            return *apps.begin();
+        case AppID::ApplicationWildcard::LAST_LISTED:
+            return *apps.rbegin();
+        case AppID::ApplicationWildcard::ONLY_LISTED:
+            if (apps.size() != 1)
+            {
+                throw std::runtime_error("More than a single app in package '" + package.value() +
+                                         "' when requested to find only app");
+            }
+            return *apps.begin();
+    }
+
+    throw std::logic_error("Got a value of the app wildcard enum that can't exist");
+}
+
+AppID::Version Click::findVersion(const AppID::Package& package,
+                                  const AppID::AppName& appname,
+                                  const std::shared_ptr<Registry>& registry)
+{
+    auto manifest = registry->impl->getClickManifest(package);
+    return manifestVersion(manifest);
+}
+
 std::shared_ptr<Application::Info> Click::info()
 {
-    return std::make_shared<app_info::Desktop>(_keyfile, _clickDir);
+    if (!_info)
+    {
+        _info = std::make_shared<app_info::Desktop>(_keyfile, _clickDir);
+    }
+
+    return _info;
 }
 
 AppID::Version manifestVersion(const std::shared_ptr<JsonObject>& manifest)
@@ -198,23 +279,41 @@
            there or return an empty vector */
         if (sappid == instancename)
         {
-            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-click", sappid, _registry));
+            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-click", sappid,
+                                                                std::vector<Application::URL>{}, _registry));
             break;
         }
     }
     return vect;
 }
 
+std::list<std::pair<std::string, std::string>> Click::launchEnv()
+{
+    auto retval = confinedEnv(_appid.package, _clickDir);
+
+    retval.emplace_back(std::make_pair("APP_DIR", _clickDir));
+
+    /* TODO: Not sure how we're gonna get this */
+    /* APP_DESKTOP_FILE_PATH */
+
+    info();
+
+    retval.emplace_back(std::make_pair("APP_XMIR_ENABLE", _info->xMirEnable().value() ? "1" : "0"));
+    retval.emplace_back(std::make_pair("APP_EXEC", _info->execLine().value()));
+
+    return retval;
+}
+
 std::shared_ptr<Application::Instance> Click::launch(const std::vector<Application::URL>& urls)
 {
     return UpstartInstance::launch(appId(), "application-click", std::string(appId()), urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD);
+                                   UpstartInstance::launchMode::STANDARD, [this]() { return launchEnv(); });
 }
 
 std::shared_ptr<Application::Instance> Click::launchTest(const std::vector<Application::URL>& urls)
 {
     return UpstartInstance::launch(appId(), "application-click", std::string(appId()), urls, _registry,
-                                   UpstartInstance::launchMode::TEST);
+                                   UpstartInstance::launchMode::TEST, [this]() { return launchEnv(); });
 }
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-click.h'
--- libubuntu-app-launch/application-impl-click.h	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application-impl-click.h	2016-08-04 14:02:19 +0000
@@ -17,9 +17,11 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "application-impl-base.h"
+#include "application-info-desktop.h"
+
 #include <gio/gdesktopappinfo.h>
 #include <json-glib/json-glib.h>
-#include "application-impl-base.h"
 
 #pragma once
 
@@ -44,8 +46,22 @@
 
     std::vector<std::shared_ptr<Instance>> instances() override;
 
-    std::shared_ptr<Instance> launch(const std::vector<Application::URL> &urls = {}) override;
-    std::shared_ptr<Instance> launchTest(const std::vector<Application::URL> &urls = {}) override;
+    std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override;
+    std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override;
+
+    static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry);
+
+    static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry);
+    static bool verifyAppname(const AppID::Package& package,
+                              const AppID::AppName& appname,
+                              const std::shared_ptr<Registry>& registry);
+    static AppID::AppName findAppname(const AppID::Package& package,
+                                      AppID::ApplicationWildcard card,
+                                      const std::shared_ptr<Registry>& registry);
+    static AppID::Version findVersion(const AppID::Package& package,
+                                      const AppID::AppName& appname,
+                                      const std::shared_ptr<Registry>& registry);
+
 private:
     AppID _appid;
 
@@ -53,6 +69,10 @@
 
     std::string _clickDir;
     std::shared_ptr<GKeyFile> _keyfile;
+
+    std::shared_ptr<app_info::Desktop> _info;
+
+    std::list<std::pair<std::string, std::string>> launchEnv();
 };
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-legacy.cpp'
--- libubuntu-app-launch/application-impl-legacy.cpp	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application-impl-legacy.cpp	2016-08-04 14:02:19 +0000
@@ -40,27 +40,18 @@
     }
 }
 
-Legacy::Legacy(const AppID::AppName& appname,
-               const std::string& basedir,
-               const std::shared_ptr<GKeyFile>& keyfile,
-               const std::shared_ptr<Registry>& registry)
-    : Base(registry)
-    , _appname(appname)
-    , _basedir(basedir)
-    , _keyfile(keyfile)
-{
-    if (!_keyfile)
-        throw std::runtime_error{"Unable to find keyfile for legacy application: " + appname.value()};
-}
-
 Legacy::Legacy(const AppID::AppName& appname, const std::shared_ptr<Registry>& registry)
     : Base(registry)
     , _appname(appname)
 {
     std::tie(_basedir, _keyfile) = keyfileForApp(appname);
 
+    appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, _registry, true, false);
+
     if (!_keyfile)
+    {
         throw std::runtime_error{"Unable to find keyfile for legacy application: " + appname.value()};
+    }
 }
 
 std::pair<std::string, std::shared_ptr<GKeyFile>> keyfileForApp(const AppID::AppName& name)
@@ -105,13 +96,79 @@
 
 std::shared_ptr<Application::Info> Legacy::info()
 {
-    if (!appinfo_)
-    {
-        appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, _registry, true);
-    }
     return appinfo_;
 }
 
+bool Legacy::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    try
+    {
+        if (!appid.version.value().empty())
+        {
+            return false;
+        }
+
+        return verifyAppname(appid.package, appid.appname, registry);
+    }
+    catch (std::runtime_error& e)
+    {
+        return false;
+    }
+}
+
+bool Legacy::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
+{
+    return package.value().empty();
+}
+
+bool Legacy::verifyAppname(const AppID::Package& package,
+                           const AppID::AppName& appname,
+                           const std::shared_ptr<Registry>& registry)
+{
+    if (!verifyPackage(package, registry))
+    {
+        throw std::runtime_error{"Invalid Legacy package: " + std::string(package)};
+    }
+
+    std::string desktop = std::string(appname) + ".desktop";
+    std::function<bool(const gchar* dir)> evaldir = [&desktop](const gchar* dir) {
+        char* fulldir = g_build_filename(dir, "applications", desktop.c_str(), nullptr);
+        gboolean found = g_file_test(fulldir, G_FILE_TEST_EXISTS);
+        g_free(fulldir);
+        return found == TRUE;
+    };
+
+    if (evaldir(g_get_user_data_dir()))
+    {
+        return true;
+    }
+
+    const char* const* data_dirs = g_get_system_data_dirs();
+    for (int i = 0; data_dirs[i] != nullptr; i++)
+    {
+        if (evaldir(data_dirs[i]))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+AppID::AppName Legacy::findAppname(const AppID::Package& package,
+                                   AppID::ApplicationWildcard card,
+                                   const std::shared_ptr<Registry>& registry)
+{
+    throw std::runtime_error("Legacy apps can't be discovered by package");
+}
+
+AppID::Version Legacy::findVersion(const AppID::Package& package,
+                                   const AppID::AppName& appname,
+                                   const std::shared_ptr<Registry>& registry)
+{
+    return AppID::Version::from_raw({});
+}
+
 const std::regex desktop_remover("^(.*)\\.desktop$");
 
 std::list<std::shared_ptr<Application>> Legacy::list(const std::shared_ptr<Registry>& registry)
@@ -177,7 +234,8 @@
         g_debug("Looking at legacy instance: %s", instance.c_str());
         if (std::equal(startsWith.begin(), startsWith.end(), instance.begin()))
         {
-            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-legacy", instance, _registry));
+            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-legacy", instance,
+                                                                std::vector<Application::URL>{}, _registry));
         }
     }
 
@@ -186,16 +244,72 @@
     return vect;
 }
 
+std::list<std::pair<std::string, std::string>> Legacy::launchEnv(const std::string& instance)
+{
+    std::list<std::pair<std::string, std::string>> retval;
+
+    /* TODO: Not sure how we're gonna get this */
+    /* APP_DESKTOP_FILE_PATH */
+
+    info();
+
+    retval.emplace_back(std::make_pair("APP_XMIR_ENABLE", appinfo_->xMirEnable().value() ? "1" : "0"));
+    retval.emplace_back(std::make_pair("APP_EXEC", appinfo_->execLine().value()));
+
+    /* Honor the 'Path' key if it is in the desktop file */
+    if (g_key_file_has_key(_keyfile.get(), "Desktop Entry", "Path", nullptr))
+    {
+        gchar* path = g_key_file_get_string(_keyfile.get(), "Desktop Entry", "Path", nullptr);
+        retval.emplace_back(std::make_pair("APP_DIR", path));
+        g_free(path);
+    }
+
+    /* If they've asked for an Apparmor profile, let's use it! */
+    gchar* apparmor = g_key_file_get_string(_keyfile.get(), "Desktop Entry", "X-Ubuntu-AppArmor-Profile", nullptr);
+    if (apparmor != nullptr)
+    {
+        retval.emplace_back(std::make_pair("APP_EXEC_POLICY", apparmor));
+        g_free(apparmor);
+
+        retval.splice(retval.end(), confinedEnv(_appname, "/usr/share"));
+    }
+    else
+    {
+        retval.emplace_back(std::make_pair("APP_EXEC_POLICY", "unconfined"));
+    }
+
+    retval.emplace_back(std::make_pair("INSTANCE_ID", instance));
+
+    return retval;
+}
+
+std::string Legacy::getInstance()
+{
+    auto single = g_key_file_get_boolean(_keyfile.get(), "Desktop Entry", "X-Ubuntu-Single-Instance", nullptr);
+    if (single)
+    {
+        return {};
+    }
+    else
+    {
+        return std::to_string(g_get_real_time());
+    }
+}
+
 std::shared_ptr<Application::Instance> Legacy::launch(const std::vector<Application::URL>& urls)
 {
-    return UpstartInstance::launch(appId(), "application-legacy", std::string(appId()) + "-", urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD);
+    std::string instance = getInstance();
+    return UpstartInstance::launch(appId(), "application-legacy", "-" + instance, urls, _registry,
+                                   UpstartInstance::launchMode::STANDARD,
+                                   [this, instance]() { return launchEnv(instance); });
 }
 
 std::shared_ptr<Application::Instance> Legacy::launchTest(const std::vector<Application::URL>& urls)
 {
-    return UpstartInstance::launch(appId(), "application-legacy", std::string(appId()) + "-", urls, _registry,
-                                   UpstartInstance::launchMode::TEST);
+    std::string instance = getInstance();
+    return UpstartInstance::launch(appId(), "application-legacy", "-" + instance, urls, _registry,
+                                   UpstartInstance::launchMode::TEST,
+                                   [this, instance]() { return launchEnv(instance); });
 }
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-legacy.h'
--- libubuntu-app-launch/application-impl-legacy.h	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application-impl-legacy.h	2016-08-04 14:02:19 +0000
@@ -35,10 +35,6 @@
 {
 public:
     Legacy(const AppID::AppName& appname, const std::shared_ptr<Registry>& registry);
-    Legacy(const AppID::AppName& appname,
-           const std::string& basedir,
-           const std::shared_ptr<GKeyFile>& keyfile,
-           const std::shared_ptr<Registry>& registry);
 
     AppID appId() override
     {
@@ -54,11 +50,27 @@
     std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override;
     std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override;
 
+    static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry);
+
+    static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry);
+    static bool verifyAppname(const AppID::Package& package,
+                              const AppID::AppName& appname,
+                              const std::shared_ptr<Registry>& registry);
+    static AppID::AppName findAppname(const AppID::Package& package,
+                                      AppID::ApplicationWildcard card,
+                                      const std::shared_ptr<Registry>& registry);
+    static AppID::Version findVersion(const AppID::Package& package,
+                                      const AppID::AppName& appname,
+                                      const std::shared_ptr<Registry>& registry);
+
 private:
     AppID::AppName _appname;
     std::string _basedir;
     std::shared_ptr<GKeyFile> _keyfile;
     std::shared_ptr<app_info::Desktop> appinfo_;
+
+    std::list<std::pair<std::string, std::string>> launchEnv(const std::string& instance);
+    std::string getInstance();
 };
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
--- libubuntu-app-launch/application-impl-libertine.cpp	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2016-08-04 14:02:19 +0000
@@ -18,7 +18,6 @@
  */
 
 #include "application-impl-libertine.h"
-#include "application-info-desktop.h"
 #include "libertine.h"
 #include "registry-impl.h"
 
@@ -107,6 +106,71 @@
     return keyfile;
 }
 
+bool Libertine::hasAppId(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    try
+    {
+        if (appid.version.value() != "0.0")
+        {
+            return false;
+        }
+
+        return verifyAppname(appid.package, appid.appname, registry);
+    }
+    catch (std::runtime_error& e)
+    {
+        return false;
+    }
+}
+
+bool Libertine::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
+{
+    auto containers = std::shared_ptr<gchar*>(libertine_list_containers(), g_strfreev);
+
+    for (int i = 0; containers.get()[i] != nullptr; i++)
+    {
+        auto container = containers.get()[i];
+        if (std::string(container) == package.value())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool Libertine::verifyAppname(const AppID::Package& package,
+                              const AppID::AppName& appname,
+                              const std::shared_ptr<Registry>& registry)
+{
+    auto apps = std::shared_ptr<gchar*>(libertine_list_apps_for_container(package.value().c_str()), g_strfreev);
+
+    for (int i = 0; apps.get()[i] != nullptr; i++)
+    {
+        auto appid = AppID::parse(apps.get()[i]);
+        if (appid.appname.value() == appname.value())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+AppID::AppName Libertine::findAppname(const AppID::Package& package,
+                                      AppID::ApplicationWildcard card,
+                                      const std::shared_ptr<Registry>& registry)
+{
+    throw std::runtime_error("Legacy apps can't be discovered by package");
+}
+
+AppID::Version Libertine::findVersion(const AppID::Package& package,
+                                      const AppID::AppName& appname,
+                                      const std::shared_ptr<Registry>& registry)
+{
+    return AppID::Version::from_raw("0.0");
+}
+
 std::list<std::shared_ptr<Application>> Libertine::list(const std::shared_ptr<Registry>& registry)
 {
     std::list<std::shared_ptr<Application>> applist;
@@ -131,7 +195,11 @@
 
 std::shared_ptr<Application::Info> Libertine::info()
 {
-    return std::make_shared<app_info::Desktop>(_keyfile, _basedir, _registry);
+    if (!appinfo_)
+    {
+        appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, _registry, false, true);
+    }
+    return appinfo_;
 }
 
 std::vector<std::shared_ptr<Application::Instance>> Libertine::instances()
@@ -142,23 +210,53 @@
     for (auto instancename : _registry->impl->upstartInstancesForJob("application-legacy"))
     {
         if (std::equal(sappid.begin(), sappid.end(), instancename.begin()))
-            vect.emplace_back(
-                std::make_shared<UpstartInstance>(appId(), "application-legacy", sappid + "-", _registry));
+            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-legacy", sappid + "-",
+                                                                std::vector<Application::URL>{}, _registry));
     }
 
     return vect;
 }
 
+std::list<std::pair<std::string, std::string>> Libertine::launchEnv()
+{
+    std::list<std::pair<std::string, std::string>> retval;
+
+    /* TODO: Not sure how we're gonna get this */
+    /* APP_DESKTOP_FILE_PATH */
+
+    info();
+
+    retval.emplace_back(std::make_pair("APP_XMIR_ENABLE", appinfo_->xMirEnable().value() ? "1" : "0"));
+
+    /* The container is our confinement */
+    retval.emplace_back(std::make_pair("APP_EXEC_POLICY", "unconfined"));
+
+    auto libertine_launch = g_getenv("UBUNTU_APP_LAUNCH_LIBERTINE_LAUNCH");
+    if (libertine_launch == nullptr)
+    {
+        libertine_launch = LIBERTINE_LAUNCH;
+    }
+
+    auto desktopexec = appinfo_->execLine().value();
+    auto execline = std::string(libertine_launch) + " \"" + _container.value() + "\" " + desktopexec;
+    retval.emplace_back(std::make_pair("APP_EXEC", execline));
+
+    /* TODO: Go multi instance */
+    retval.emplace_back(std::make_pair("INSTANCE_ID", ""));
+
+    return retval;
+}
+
 std::shared_ptr<Application::Instance> Libertine::launch(const std::vector<Application::URL>& urls)
 {
     return UpstartInstance::launch(appId(), "application-legacy", std::string(appId()) + "-", urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD);
+                                   UpstartInstance::launchMode::STANDARD, [this]() { return launchEnv(); });
 }
 
 std::shared_ptr<Application::Instance> Libertine::launchTest(const std::vector<Application::URL>& urls)
 {
     return UpstartInstance::launch(appId(), "application-legacy", std::string(appId()) + "-", urls, _registry,
-                                   UpstartInstance::launchMode::TEST);
+                                   UpstartInstance::launchMode::TEST, [this]() { return launchEnv(); });
 }
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-libertine.h'
--- libubuntu-app-launch/application-impl-libertine.h	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application-impl-libertine.h	2016-08-04 14:02:19 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "application-impl-base.h"
+#include "application-info-desktop.h"
 #include <gio/gdesktopappinfo.h>
 
 #pragma once
@@ -50,11 +51,27 @@
     std::shared_ptr<Instance> launch(const std::vector<Application::URL>& urls = {}) override;
     std::shared_ptr<Instance> launchTest(const std::vector<Application::URL>& urls = {}) override;
 
+    static bool hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry);
+
+    static bool verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry);
+    static bool verifyAppname(const AppID::Package& package,
+                              const AppID::AppName& appname,
+                              const std::shared_ptr<Registry>& registry);
+    static AppID::AppName findAppname(const AppID::Package& package,
+                                      AppID::ApplicationWildcard card,
+                                      const std::shared_ptr<Registry>& registry);
+    static AppID::Version findVersion(const AppID::Package& package,
+                                      const AppID::AppName& appname,
+                                      const std::shared_ptr<Registry>& registry);
+
 private:
     AppID::Package _container;
     AppID::AppName _appname;
     std::shared_ptr<GKeyFile> _keyfile;
     std::string _basedir;
+    std::shared_ptr<app_info::Desktop> appinfo_;
+
+    std::list<std::pair<std::string, std::string>> launchEnv();
 };
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-info-desktop.cpp'
--- libubuntu-app-launch/application-info-desktop.cpp	2016-05-10 19:09:34 +0000
+++ libubuntu-app-launch/application-info-desktop.cpp	2016-08-04 14:02:19 +0000
@@ -157,7 +157,8 @@
 Desktop::Desktop(std::shared_ptr<GKeyFile> keyfile,
                  const std::string& basePath,
                  std::shared_ptr<Registry> registry,
-                 bool allowNoDisplay)
+                 bool allowNoDisplay,
+                 bool xMirDefault)
     : _keyfile([keyfile, allowNoDisplay]() {
         if (!keyfile)
         {
@@ -269,6 +270,8 @@
     , _rotatesWindow(
           boolFromKeyfile<Application::Info::RotatesWindow>(keyfile, "X-Ubuntu-Rotates-Window-Contents", false))
     , _ubuntuLifecycle(boolFromKeyfile<Application::Info::UbuntuLifecycle>(keyfile, "X-Ubuntu-Touch", false))
+    , _xMirEnable(boolFromKeyfile<XMirEnable>(keyfile, "X-Ubuntu-XMir-Enable", xMirDefault))
+    , _exec(stringFromKeyfile<Exec>(keyfile, "Exec"))
 {
 }
 

=== modified file 'libubuntu-app-launch/application-info-desktop.h'
--- libubuntu-app-launch/application-info-desktop.h	2016-04-29 18:51:31 +0000
+++ libubuntu-app-launch/application-info-desktop.h	2016-08-04 14:02:19 +0000
@@ -36,7 +36,8 @@
     Desktop(std::shared_ptr<GKeyFile> keyfile,
             const std::string& basePath,
             std::shared_ptr<Registry> registry = nullptr,
-            bool allowNoDisplay = false);
+            bool allowNoDisplay = false,
+            bool xMirDefault = false);
 
     const Application::Info::Name& name() override
     {
@@ -71,7 +72,21 @@
         return _ubuntuLifecycle;
     }
 
-private:
+    struct XMirEnableTag;
+    typedef TypeTagger<XMirEnableTag, bool> XMirEnable;
+    virtual XMirEnable xMirEnable()
+    {
+        return _xMirEnable;
+    }
+
+    struct ExecTag;
+    typedef TypeTagger<ExecTag, std::string> Exec;
+    virtual Exec execLine()
+    {
+        return _exec;
+    }
+
+protected:
     std::shared_ptr<GKeyFile> _keyfile;
     std::string _basePath;
 
@@ -83,6 +98,9 @@
     Application::Info::Orientations _supportedOrientations;
     Application::Info::RotatesWindow _rotatesWindow;
     Application::Info::UbuntuLifecycle _ubuntuLifecycle;
+
+    XMirEnable _xMirEnable;
+    Exec _exec;
 };
 
 };  // namespace AppInfo

=== modified file 'libubuntu-app-launch/application.cpp'
--- libubuntu-app-launch/application.cpp	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/application.cpp	2016-08-04 14:02:19 +0000
@@ -18,7 +18,6 @@
  */
 
 extern "C" {
-#include "app-info.h"
 #include "ubuntu-app-launch.h"
 }
 
@@ -26,7 +25,9 @@
 #include "application-impl-legacy.h"
 #include "application-impl-libertine.h"
 #include "application.h"
+#include "registry.h"
 
+#include <functional>
 #include <iostream>
 #include <regex>
 
@@ -42,22 +43,21 @@
         throw std::runtime_error("AppID is empty");
     }
 
-    std::string sappid = appid;
-    if (app_info_click(sappid.c_str(), NULL, NULL))
+    if (app_impls::Click::hasAppId(appid, registry))
     {
         return std::make_shared<app_impls::Click>(appid, registry);
     }
-    else if (app_info_libertine(sappid.c_str(), NULL, NULL))
+    else if (app_impls::Libertine::hasAppId(appid, registry))
     {
         return std::make_shared<app_impls::Libertine>(appid.package, appid.appname, registry);
     }
-    else if (app_info_legacy(sappid.c_str(), NULL, NULL))
+    else if (app_impls::Legacy::hasAppId(appid, registry))
     {
         return std::make_shared<app_impls::Legacy>(appid.appname, registry);
     }
     else
     {
-        throw std::runtime_error("Invalid app ID: " + sappid);
+        throw std::runtime_error("Invalid app ID: " + std::string(appid));
     }
 }
 
@@ -106,6 +106,12 @@
 
 AppID AppID::find(const std::string& sappid)
 {
+    auto registry = Registry::getDefault();
+    return find(registry, sappid);
+}
+
+AppID AppID::find(const std::shared_ptr<Registry>& registry, const std::string& sappid)
+{
     std::smatch match;
 
     if (std::regex_match(sappid, match, full_appid_regex))
@@ -115,7 +121,7 @@
     }
     else if (std::regex_match(sappid, match, short_appid_regex))
     {
-        return discover(match[1].str(), match[2].str());
+        return discover(registry, match[1].str(), match[2].str());
     }
     else if (std::regex_match(sappid, match, legacy_appid_regex))
     {
@@ -156,67 +162,181 @@
            a.version.value() != b.version.value();
 }
 
+bool operator<(const AppID& a, const AppID& b)
+{
+    return std::string(a) < std::string(b);
+}
+
 bool AppID::empty() const
 {
     return package.value().empty() && appname.value().empty() && version.value().empty();
 }
 
-std::string app_wildcard(AppID::ApplicationWildcard card)
-{
-    switch (card)
-    {
-        case AppID::ApplicationWildcard::FIRST_LISTED:
-            return "first-listed-app";
-        case AppID::ApplicationWildcard::LAST_LISTED:
-            return "last-listed-app";
-        case AppID::ApplicationWildcard::ONLY_LISTED:
-            return "only-listed-app";
-    }
-
-    return "";
-}
-
-std::string ver_wildcard(AppID::VersionWildcard card)
-{
-    switch (card)
-    {
-        case AppID::VersionWildcard::CURRENT_USER_VERSION:
-            return "current-user-version";
-    }
-
-    return "";
+/* Basically we're making our own VTable of static functions. Static
+   functions don't go in the normal VTables, so we can't use our class
+   inheritance here to help. So we're just packing these puppies into
+   a data structure and itterating over it. */
+struct DiscoverTools
+{
+    std::function<bool(const AppID::Package& package, const std::shared_ptr<Registry>& registry)> verifyPackage;
+    std::function<bool(
+        const AppID::Package& package, const AppID::AppName& appname, const std::shared_ptr<Registry>& registry)>
+        verifyAppname;
+    std::function<AppID::AppName(
+        const AppID::Package& package, AppID::ApplicationWildcard card, const std::shared_ptr<Registry>& registry)>
+        findAppname;
+    std::function<AppID::Version(
+        const AppID::Package& package, const AppID::AppName& appname, const std::shared_ptr<Registry>& registry)>
+        findVersion;
+    std::function<bool(const AppID& appid, const std::shared_ptr<Registry>& registry)> hasAppId;
+};
+
+static const std::vector<DiscoverTools> discoverTools{
+    /* Click */
+    {app_impls::Click::verifyPackage, app_impls::Click::verifyAppname, app_impls::Click::findAppname,
+     app_impls::Click::findVersion, app_impls::Click::hasAppId},
+    /* Libertine */
+    {app_impls::Libertine::verifyPackage, app_impls::Libertine::verifyAppname, app_impls::Libertine::findAppname,
+     app_impls::Libertine::findVersion, app_impls::Libertine::hasAppId},
+    /* Legacy */
+    {app_impls::Legacy::verifyPackage, app_impls::Legacy::verifyAppname, app_impls::Legacy::findAppname,
+     app_impls::Legacy::findVersion, app_impls::Legacy::hasAppId}};
+
+AppID AppID::discover(const std::shared_ptr<Registry>& registry,
+                      const std::string& package,
+                      const std::string& appname,
+                      const std::string& version)
+{
+    auto pkg = AppID::Package::from_raw(package);
+
+    for (auto tools : discoverTools)
+    {
+        /* Figure out which type we have */
+        try
+        {
+            if (tools.verifyPackage(pkg, registry))
+            {
+                auto app = AppID::AppName::from_raw({});
+
+                if (appname.empty() || appname == "first-listed-app")
+                {
+                    app = tools.findAppname(pkg, ApplicationWildcard::FIRST_LISTED, registry);
+                }
+                else if (appname == "last-listed-app")
+                {
+                    app = tools.findAppname(pkg, ApplicationWildcard::LAST_LISTED, registry);
+                }
+                else if (appname == "only-listed-app")
+                {
+                    app = tools.findAppname(pkg, ApplicationWildcard::ONLY_LISTED, registry);
+                }
+                else
+                {
+                    app = AppID::AppName::from_raw(appname);
+                    if (!tools.verifyAppname(pkg, app, registry))
+                    {
+                        throw std::runtime_error("App name passed in is not valid for this package type");
+                    }
+                }
+
+                auto ver = AppID::Version::from_raw({});
+                if (version.empty() || version == "current-user-version")
+                {
+                    ver = tools.findVersion(pkg, app, registry);
+                }
+                else
+                {
+                    ver = AppID::Version::from_raw(version);
+                    if (!tools.hasAppId({pkg, app, ver}, registry))
+                    {
+                        throw std::runtime_error("Invalid version passed for this package type");
+                    }
+                }
+
+                return AppID{pkg, app, ver};
+            }
+        }
+        catch (std::runtime_error& e)
+        {
+            continue;
+        }
+    }
+
+    return {};
+}
+
+AppID AppID::discover(const std::shared_ptr<Registry>& registry,
+                      const std::string& package,
+                      ApplicationWildcard appwildcard,
+                      VersionWildcard versionwildcard)
+{
+    auto pkg = AppID::Package::from_raw(package);
+
+    for (auto tools : discoverTools)
+    {
+        try
+        {
+            if (tools.verifyPackage(pkg, registry))
+            {
+                auto app = tools.findAppname(pkg, appwildcard, registry);
+                auto ver = tools.findVersion(pkg, app, registry);
+                return AppID{pkg, app, ver};
+            }
+        }
+        catch (std::runtime_error& e)
+        {
+            /* Normal, try another */
+            continue;
+        }
+    }
+
+    return {};
+}
+
+AppID AppID::discover(const std::shared_ptr<Registry>& registry,
+                      const std::string& package,
+                      const std::string& appname,
+                      VersionWildcard versionwildcard)
+{
+    auto pkg = AppID::Package::from_raw(package);
+    auto app = AppID::AppName::from_raw(appname);
+
+    for (auto tools : discoverTools)
+    {
+        try
+        {
+            if (tools.verifyPackage(pkg, registry) && tools.verifyAppname(pkg, app, registry))
+            {
+                auto ver = tools.findVersion(pkg, app, registry);
+                return AppID{pkg, app, ver};
+            }
+        }
+        catch (std::runtime_error& e)
+        {
+            /* Normal, try another */
+            continue;
+        }
+    }
+
+    return {};
 }
 
 AppID AppID::discover(const std::string& package, const std::string& appname, const std::string& version)
 {
-    auto cappid = ubuntu_app_launch_triplet_to_app_id(package.c_str(), appname.c_str(), version.c_str());
-
-    auto appid = cappid != nullptr ? AppID::parse(cappid) : AppID::parse("");
-
-    g_free(cappid);
-
-    return appid;
+    auto registry = Registry::getDefault();
+    return discover(registry, package, appname, version);
 }
 
 AppID AppID::discover(const std::string& package, ApplicationWildcard appwildcard, VersionWildcard versionwildcard)
 {
-    return discover(package, app_wildcard(appwildcard), ver_wildcard(versionwildcard));
+    auto registry = Registry::getDefault();
+    return discover(registry, package, appwildcard, versionwildcard);
 }
 
 AppID AppID::discover(const std::string& package, const std::string& appname, VersionWildcard versionwildcard)
 {
-    auto appid = discover(package, appname, ver_wildcard(versionwildcard));
-
-    if (appid.empty())
-    {
-        /* If we weren't able to go that route, we can see if it's libertine */
-        if (app_info_libertine((package + "_" + appname + "_0.0").c_str(), nullptr, nullptr))
-        {
-            appid = AppID(Package::from_raw(package), AppName::from_raw(appname), Version::from_raw("0.0"));
-        }
-    }
-
-    return appid;
+    auto registry = Registry::getDefault();
+    return discover(registry, package, appname, versionwildcard);
 }
 
 enum class oom::Score : std::int32_t

=== removed file 'libubuntu-app-launch/click-exec.c'
--- libubuntu-app-launch/click-exec.c	2014-09-17 14:11:59 +0000
+++ libubuntu-app-launch/click-exec.c	1970-01-01 00:00:00 +0000
@@ -1,170 +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 <gio/gio.h>
-#include <click.h>
-#include "helpers.h"
-#include "ubuntu-app-launch-trace.h"
-#include "ual-tracepoint.h"
-
-/*
-
-INTRODUCTION:
-
-This is the utility that executes a click package based on the Application ID.
-Actually it just determines what needs to be executed, and asks Upstart to execute
-it so that it can be tracked better.  This process runs OUTSIDE of the app armor
-confinement for the application.  It also DOES NOT use any files that can be modified
-by the user.  So things like the desktop file in ~/.local/share/applications are
-all off limits.
-
-For information on Click packages and the manifest look at the Click package documentation:
-
-https://click.readthedocs.org/en/latest/
-
-*/
-
-gboolean
-click_task_setup (GDBusConnection * bus, const gchar * app_id, EnvHandle * handle)
-{
-	g_return_val_if_fail(bus != NULL, FALSE);
-	g_return_val_if_fail(app_id != NULL, FALSE);
-	g_return_val_if_fail(handle != NULL, FALSE);
-
-	ual_tracepoint(click_start, app_id);
-
-	GError * error = NULL;
-
-	handshake_t * handshake = starting_handshake_start(app_id);
-	if (handshake == NULL) {
-		g_warning("Unable to setup starting handshake");
-	}
-
-	ual_tracepoint(click_starting_sent, app_id);
-
-	gchar * package = NULL;
-	/* 'Parse' the App ID */
-	if (!app_id_to_triplet(app_id, &package, NULL, NULL)) {
-		g_warning("Unable to parse App ID: '%s'", app_id);
-		return FALSE;
-	}
-
-	/* 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 FALSE;
-	}
-	/* 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 FALSE;
-	}
-	gchar * pkgdir = click_user_get_path(user, package, &error);
-	if (error != NULL) {
-		g_warning("Unable to get the Click package directory for %s: %s", package, error->message);
-		g_error_free(error);
-		g_free(package);
-		g_object_unref(user);
-		g_object_unref(db);
-		return FALSE;
-	}
-	g_object_unref(user);
-	g_object_unref(db);
-
-	ual_tracepoint(click_found_pkgdir, app_id);
-
-	if (!g_file_test(pkgdir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
-		g_warning("Application directory '%s' doesn't exist", pkgdir);
-		g_free(pkgdir);
-		g_free(package);
-		return FALSE;
-	}
-
-	g_debug("Setting 'APP_DIR' to '%s'", pkgdir);
-	env_handle_add(handle, "APP_DIR", pkgdir);
-
-	set_confined_envvars(handle, package, pkgdir);
-
-	ual_tracepoint(click_configured_env, app_id);
-
-	gchar * desktopfile = manifest_to_desktop(pkgdir, app_id);
-
-	g_free(pkgdir);
-	g_free(package);
-
-	if (desktopfile == NULL) {
-		g_warning("Desktop file unable to be found");
-		return FALSE;
-	}
-
-	ual_tracepoint(click_read_manifest, app_id);
-
-	GKeyFile * keyfile = g_key_file_new();
-
-	env_handle_add(handle, "APP_DESKTOP_FILE_PATH", desktopfile);
-	g_key_file_load_from_file(keyfile, desktopfile, 0, &error);
-	if (error != NULL) {
-		g_warning("Unable to load desktop file '%s': %s", desktopfile, error->message);
-		g_error_free(error);
-		g_key_file_free(keyfile);
-		g_free(desktopfile);
-		return FALSE;
-	}
-
-	if (g_key_file_has_key(keyfile, "Desktop Entry", "X-Ubuntu-XMir-Enable", NULL)) {
-		if (g_key_file_get_boolean(keyfile, "Desktop Entry", "X-Ubuntu-XMir-Enable", NULL)) {
-			env_handle_add(handle, "APP_XMIR_ENABLE", "1");
-		} else {
-			env_handle_add(handle, "APP_XMIR_ENABLE", "0");
-		}
-	}
-
-	/* This string is quoted using desktop file quoting:
-	   http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#exec-variables */
-	gchar * exec = desktop_to_exec(keyfile, desktopfile);
-	if (exec == NULL) {
-		return FALSE;
-	}
-
-	ual_tracepoint(click_read_desktop, app_id);
-
-	g_debug("Setting 'APP_EXEC' to '%s'", exec);
-	env_handle_add(handle, "APP_EXEC", exec);
-
-	g_free(exec);
-	g_key_file_unref(keyfile);
-	g_free(desktopfile);
-
-	ual_tracepoint(handshake_wait, app_id);
-
-	starting_handshake_wait(handshake);
-
-	ual_tracepoint(handshake_complete, app_id);
-
-	return TRUE;
-}

=== removed file 'libubuntu-app-launch/click-exec.h'
--- libubuntu-app-launch/click-exec.h	2014-08-22 20:59:55 +0000
+++ libubuntu-app-launch/click-exec.h	1970-01-01 00:00:00 +0000
@@ -1,25 +0,0 @@
-/*
- * 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 "helpers.h"
-
-gboolean click_task_setup (GDBusConnection * bus, const gchar * app_id, EnvHandle * envhandle);
-
-

=== removed file 'libubuntu-app-launch/desktop-exec.c'
--- libubuntu-app-launch/desktop-exec.c	2016-01-26 21:17:25 +0000
+++ libubuntu-app-launch/desktop-exec.c	1970-01-01 00:00:00 +0000
@@ -1,218 +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 <unistd.h>
-#include <errno.h>
-#include <string.h>
-#include <glib.h>
-#include <gio/gio.h>
-
-#include "helpers.h"
-#include "ubuntu-app-launch-trace.h"
-#include "recoverable-problem.h"
-#include "ual-tracepoint.h"
-#include "ubuntu-app-launch.h"
-#include "app-info.h"
-
-/* Reports an error on the caller of UAL so that we can track
-   who is trying to launch bad AppIDs, and then fix their bug
-   so that we get better reporting upstream. */
-void
-report_error_on_caller (const gchar * app_id) {
-	g_warning("Unable to find keyfile for application '%s'", app_id);
-
-	const gchar * props[3] = {
-		"AppId", NULL,
-		NULL
-	};
-	props[1] = app_id;
-
-	GPid pid = getpid();
-
-	/* Checking to see if we're using the command line tool to create
-	   the appid. Chances are in that case it's a user error, and we
-	   don't need to automatically record it, the user mistyped. */
-	gboolean debugtool = FALSE;
-	if (pid != 0) {
-		const gchar * cmdpath = "/proc/self/cmdline";
-		gchar * cmdline = NULL;
-
-		if (g_file_get_contents(cmdpath, &cmdline, NULL, NULL)) {
-			if (g_strstr_len(cmdline, -1, "ubuntu-app-launch") != NULL) {
-				debugtool = TRUE;
-			}
-
-			g_free(cmdline);
-		} else {
-			/* The caller has already exited, probably a debug tool */
-			debugtool = TRUE;
-		}
-	}
-
-	if (!debugtool) {
-		report_recoverable_problem("ubuntu-app-launch-invalid-appid", pid, TRUE, props);
-	} else {
-		g_debug("Suppressing appid recoverable error for debug tool");
-	}
-}
-
-/* Get the keyfile object for a libertine container based application. Look into
-   the container's filesystem on disk and find it in /usr/share/applications in there.
-   Those are currently the only apps that we look at today. We're not ensuring anything
-   about the file other than it has basic sanity. */
-GKeyFile *
-keyfile_for_libertine (const gchar * appid, gchar ** outcontainer)
-{
-	gchar * desktopfile = NULL;
-	gchar * desktopdir = NULL;
-
-	if (!app_info_libertine(appid, &desktopdir, &desktopfile)) {
-		return NULL;
-	}
-
-	gchar * desktopfull = g_build_filename(desktopdir, desktopfile, NULL);
-	g_debug("Desktop full: %s", desktopfull);
-	g_free(desktopdir);
-	g_free(desktopfile);
-
-	/* We now think we have a valid 'desktopfile' path */
-	GKeyFile * keyfile = g_key_file_new();
-	gboolean loaded = g_key_file_load_from_file(keyfile, desktopfull, G_KEY_FILE_NONE, NULL);
-
-	if (!loaded) {
-		g_free(desktopfull);
-		g_key_file_free(keyfile);
-		return NULL;
-	}
-
-	if (!verify_keyfile(keyfile, desktopfull)) {
-		g_free(desktopfull);
-		g_key_file_free(keyfile);
-		return NULL;
-	}
-
-	g_free(desktopfull);
-
-	if (outcontainer != NULL) {
-		ubuntu_app_launch_app_id_parse(appid, outcontainer, NULL, NULL);
-	}
-
-	return keyfile;
-}
-
-gboolean
-desktop_task_setup (GDBusConnection * bus, const gchar * app_id, EnvHandle * handle, gboolean is_libertine)
-{
-	if (app_id == NULL) {
-		g_error("No APP_ID environment variable defined");
-		return FALSE;
-	}
-
-	ual_tracepoint(desktop_start, app_id);
-
-	handshake_t * handshake = starting_handshake_start(app_id);
-	if (handshake == NULL) {
-		g_warning("Unable to setup starting handshake");
-	}
-
-	ual_tracepoint(desktop_starting_sent, app_id);
-
-	gchar * desktopfilename = NULL;
-	GKeyFile * keyfile = NULL;
-	gchar * libertinecontainer = NULL;
-	if (is_libertine) {
-		/* desktopfilename not set, not useful in this context */
-		keyfile = keyfile_for_libertine(app_id, &libertinecontainer);
-	} else {
-		keyfile = keyfile_for_appid(app_id, &desktopfilename);
-	}
-
-	if (keyfile == NULL) {
-		report_error_on_caller(app_id);
-		g_free(libertinecontainer);
-		return FALSE;
-	}
-
-	ual_tracepoint(desktop_found, app_id);
-
-	/* Desktop file name so that libs can get other info from it */
-	if (desktopfilename != NULL) {
-		env_handle_add(handle, "APP_DESKTOP_FILE_PATH", desktopfilename);
-		g_free(desktopfilename);
-	}
-
-	if (g_key_file_has_key(keyfile, "Desktop Entry", "Path", NULL)) {
-		gchar * path = g_key_file_get_string(keyfile, "Desktop Entry", "Path", NULL);
-		env_handle_add(handle, "APP_DIR", path);
-		g_free(path);
-	}
-
-	gchar * apparmor = g_key_file_get_string(keyfile, "Desktop Entry", "X-Ubuntu-AppArmor-Profile", NULL);
-	if (apparmor != NULL) {
-		env_handle_add(handle, "APP_EXEC_POLICY", apparmor);
-		set_confined_envvars(handle, app_id, "/usr/share");
-		g_free(apparmor);
-	} else {
-		env_handle_add(handle, "APP_EXEC_POLICY", "unconfined");
-	}
-
-	if (g_key_file_has_key(keyfile, "Desktop Entry", "X-Ubuntu-XMir-Enable", NULL)) {
-		if (g_key_file_get_boolean(keyfile, "Desktop Entry", "X-Ubuntu-XMir-Enable", NULL)) {
-			env_handle_add(handle, "APP_XMIR_ENABLE", "1");
-		} else {
-			env_handle_add(handle, "APP_XMIR_ENABLE", "0");
-		}
-	} else if (is_libertine) {
-		/* Default to X for libertine stuff */
-		env_handle_add(handle, "APP_XMIR_ENABLE", "1");
-	}
-
-	/* This string is quoted using desktop file quoting:
-	   http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#exec-variables */
-	gchar * execline = desktop_to_exec(keyfile, app_id);
-	g_return_val_if_fail(execline != NULL, FALSE);
-
-	if (is_libertine) {
-		static const gchar * libertine_launch = NULL;
-		if (G_UNLIKELY(libertine_launch == NULL)) {
-			libertine_launch = g_getenv("UBUNTU_APP_LAUNCH_LIBERTINE_LAUNCH");
-			if (libertine_launch == NULL) {
-				libertine_launch = LIBERTINE_LAUNCH;
-			}
-		}
-
-		gchar * libexec = g_strdup_printf("%s \"%s\" %s", libertine_launch, libertinecontainer, execline);
-		g_free(execline);
-		execline = libexec;
-	}
-	g_free(libertinecontainer); /* Handles NULL, let's be sure it goes away */
-
-	env_handle_add(handle, "APP_EXEC", execline);
-	g_free(execline);
-
-	g_key_file_free(keyfile);
-
-	ual_tracepoint(handshake_wait, app_id);
-
-	starting_handshake_wait(handshake);
-
-	ual_tracepoint(handshake_complete, app_id);
-
-	return TRUE;
-}

=== removed file 'libubuntu-app-launch/desktop-exec.h'
--- libubuntu-app-launch/desktop-exec.h	2015-07-15 02:12:04 +0000
+++ libubuntu-app-launch/desktop-exec.h	1970-01-01 00:00:00 +0000
@@ -1,26 +0,0 @@
-/*
- * 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]>
- */
-
-#pragma once
-
-#include <glib.h>
-#include "helpers.h"
-
-gboolean desktop_task_setup (GDBusConnection * bus, const gchar * appid, EnvHandle * envhandle, gboolean is_libertine);
-

=== modified file 'libubuntu-app-launch/registry.cpp'
--- libubuntu-app-launch/registry.cpp	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/registry.cpp	2016-08-04 14:02:19 +0000
@@ -91,7 +91,7 @@
     std::list<std::shared_ptr<Application>> apps;
     for (auto instance : instanceset)
     {
-        auto appid = AppID::find(instance);
+        auto appid = AppID::find(connection, instance);
         auto app = Application::create(appid, connection);
         apps.push_back(app);
     }

=== modified file 'libubuntu-app-launch/second-exec-core.c'
--- libubuntu-app-launch/second-exec-core.c	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/second-exec-core.c	2016-08-04 14:02:19 +0000
@@ -29,24 +29,38 @@
 typedef struct {
 	GDBusConnection * bus;
 	gchar * appid;
-	gchar * input_uris;
+	gchar ** input_uris;
 	GPid app_pid;
 	guint connections_open;
 	GVariant * app_data;
 	gchar * dbus_path;
 	guint64 unity_starttime;
-	guint timer;
+	GSource * timer;
 	guint signal;
 } second_exec_t;
 
 static void second_exec_complete (second_exec_t * data);
 
+static GSource *
+thread_default_timeout (guint interval, GSourceFunc func, gpointer data)
+{
+	GSource * src = g_timeout_source_new(interval);
+	GMainContext * context = g_main_context_get_thread_default();
+
+	g_source_set_callback(src, func, data, NULL);
+
+	g_source_attach(src, context);
+
+	return src;
+}
+
 /* Unity didn't respond in time, continue on */
 static gboolean
 timer_cb (gpointer user_data)
 {
 	ual_tracepoint(second_exec_resume_timeout, ((second_exec_t *)user_data)->appid);
 	g_warning("Unity didn't respond in 500ms to resume the app");
+
 	second_exec_complete(user_data);
 	return G_SOURCE_REMOVE;
 }
@@ -67,7 +81,7 @@
 			second_exec_complete(data);
 		} else {
 			g_debug("Timer Set");
-			data->timer = g_timeout_add(500 - (timespent / 1000), timer_cb, data);
+			data->timer = thread_default_timeout(500 - (timespent / 1000), timer_cb, data);
 		}
 	}
 	return;
@@ -82,9 +96,10 @@
 	g_debug("Unity Completed Resume");
 	ual_tracepoint(second_exec_resume_complete, data->appid);
 
-	if (data->timer != 0) {
-		g_source_remove(data->timer);
-		data->timer = 0;
+	if (data->timer != NULL) {
+		g_source_destroy(data->timer);
+		g_source_unref(data->timer);
+		data->timer = NULL;
 	}
 
 	if (data->connections_open == 0) {
@@ -107,31 +122,17 @@
 	}
 
 	GVariant * uris = NULL;
-	gchar ** uri_split = NULL;
-	GError * error = NULL;
-
-	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", data->input_uris, error->message);
-			g_error_free(error);
-		}
-
+
+	if (data->input_uris == NULL) {
 		uris = g_variant_new_array(G_VARIANT_TYPE_STRING, NULL, 0);
-
-		if (uri_split != NULL) {
-			g_strfreev(uri_split);
-		}
 	} else {
 		GVariantBuilder builder;
 		g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
 
 		int i;
-		for (i = 0; uri_split[i] != NULL; i++) {
-			g_variant_builder_add_value(&builder, g_variant_new_take_string(uri_split[i]));
+		for (i = 0; data->input_uris[i] != NULL; i++) {
+			g_variant_builder_add_value(&builder, g_variant_new_string(data->input_uris[i]));
 		}
-		g_free(uri_split);
 
 		uris = g_variant_builder_end(&builder);
 	}
@@ -281,7 +282,7 @@
 }
 
 /* Starts to look for the PID and the connections for that PID */
-void
+static void
 find_appid_pid (GDBusConnection * session, second_exec_t * data)
 {
 	GError * error = NULL;
@@ -310,16 +311,6 @@
 	g_debug("Got bus names");
 	ual_tracepoint(second_exec_got_dbus_names, data->appid);
 
-	/* 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. */
-	data->app_pid = ubuntu_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);
 	ual_tracepoint(second_exec_got_primary_pid, data->appid);
 
@@ -364,16 +355,17 @@
 }
 
 gboolean
-second_exec (GDBusConnection * session, GCancellable * cancel, const gchar * app_id, const gchar * appuris)
+second_exec (GDBusConnection * session, GCancellable * cancel, GPid pid, const gchar * app_id, gchar ** appuris)
 {
-	ual_tracepoint(second_exec_start, app_id, appuris);
+	ual_tracepoint(second_exec_start, app_id);
 	GError * error = NULL;
 
 	/* 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->input_uris = g_strdupv(appuris);
 	data->bus = g_object_ref(session);
+	data->app_pid = pid;
 
 	/* Set up listening for the unfrozen signal from Unity */
 	data->signal = g_dbus_connection_signal_subscribe(session,
@@ -414,11 +406,17 @@
 	/* If we've got something to give out, start looking for how */
 	if (data->input_uris != NULL) {
 		find_appid_pid(session, data);
+	} else {
+		g_debug("No URIs to send");
 	}
 
 	/* Loop and wait for everything to align */
-	if (data->connections_open == 0 && data->unity_starttime == 0) {
-		second_exec_complete(data);
+	if (data->connections_open == 0) {
+		if (data->unity_starttime == 0) {
+			second_exec_complete(data);
+		} else {
+			data->timer = thread_default_timeout(500, timer_cb, data);
+		}
 	}
 
 	return TRUE;
@@ -461,11 +459,15 @@
 	if (data->signal != 0)
 		g_dbus_connection_signal_unsubscribe(data->bus, data->signal);
 
+	if (data->timer != NULL) {
+		g_source_destroy(data->timer);
+		g_source_unref(data->timer);
+	}
 	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_strfreev(data->input_uris);
 	g_free(data->dbus_path);
 	g_free(data);
 

=== modified file 'libubuntu-app-launch/second-exec-core.h'
--- libubuntu-app-launch/second-exec-core.h	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/second-exec-core.h	2016-08-04 14:02:19 +0000
@@ -20,5 +20,9 @@
 
 #include <gio/gio.h>
 
-gboolean second_exec (GDBusConnection * con, GCancellable * cancel, const gchar * app_id, const gchar * appuris);
+G_BEGIN_DECLS
+
+gboolean second_exec (GDBusConnection * con, GCancellable * cancel, GPid pid, const gchar * app_id, gchar ** appuris);
+
+G_END_DECLS
 

=== modified file 'libubuntu-app-launch/ubuntu-app-launch-trace.tp'
--- libubuntu-app-launch/ubuntu-app-launch-trace.tp	2015-07-15 01:42:22 +0000
+++ libubuntu-app-launch/ubuntu-app-launch-trace.tp	2016-08-04 14:02:19 +0000
@@ -67,10 +67,9 @@
   Second Exec tracking
  *******************************/
 TRACEPOINT_EVENT(ubuntu_app_launch, second_exec_start,
-	TP_ARGS(const char *, appid, const char *, appuris),
+	TP_ARGS(const char *, appid),
 	TP_FIELDS(
 		ctf_string(appid, appid)
-		ctf_string(appuris, appuris)
 	)
 )
 TRACEPOINT_EVENT(ubuntu_app_launch, second_exec_emit_resume,

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.cpp'
--- libubuntu-app-launch/ubuntu-app-launch.cpp	2016-08-04 14:02:18 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.cpp	2016-08-04 14:02:19 +0000
@@ -28,14 +28,10 @@
 #include <zeitgeist.h>
 
 #include "ubuntu-app-launch-trace.h"
-#include "second-exec-core.h"
 #include "helpers.h"
 #include "ual-tracepoint.h"
-#include "click-exec.h"
-#include "desktop-exec.h"
 #include "recoverable-problem.h"
 #include "proxy-socket-demangler.h"
-#include "app-info.h"
 }
 
 /* C++ Interface */
@@ -43,7 +39,6 @@
 #include "appid.h"
 #include "registry.h"
 
-static void apps_for_job (GDBusConnection * con, const gchar * name, GArray * apps, gboolean truncate_legacy);
 static void free_helper (gpointer value);
 int kill (pid_t pid, int signal);
 static gchar * escape_dbus_string (const gchar * input);
@@ -71,51 +66,6 @@
 	return urisjoin;
 }
 
-typedef struct {
-	gchar * appid;
-	gchar * uris;
-	GDBusConnection * con;
-	GCancellable * cancel;
-} 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;
-
-	ual_tracepoint(libual_start_message_callback, data->appid);
-
-	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->con, data->cancel, 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_clear_object(&data->con);
-	g_clear_object(&data->cancel);
-	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 *
@@ -159,246 +109,54 @@
 	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)
-{
-	ual_tracepoint(desktop_single_start, appid);
-
-	GKeyFile * keyfile = keyfile_for_appid(appid, NULL);
-
-	if (keyfile == NULL) {
-		g_warning("Unable to find keyfile for application '%s'", appid);
-		return FALSE;
-	}
-
-	ual_tracepoint(desktop_single_found, appid);
-
-	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);
-
-	ual_tracepoint(desktop_single_finished, appid, singleinstance ? "single" : "unmanaged");
-
-	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("UBUNTU_APP_LAUNCH_LINK_FARM");
-	if (G_LIKELY(link_farm_dir == NULL)) {
-		click_link = g_build_filename(g_get_home_dir(), ".cache", "ubuntu-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;
-}
-
-/* Determine whether an AppId is realated to a Libertine container by
-   checking the container and program name. */
-static gboolean
-is_libertine (const gchar * appid)
-{
-	if (app_info_libertine(appid, NULL, NULL)) {
-		g_debug("Libertine application detected: %s", appid);
-		return TRUE;
-	} else {
-		return FALSE;
-	}
-}
-
-gboolean
-start_application_core (GDBusConnection * con, GCancellable * cancel, const gchar * appid, const gchar * const * uris, gboolean test)
-{
-	ual_tracepoint(libual_start, appid);
-
-	g_return_val_if_fail(appid != NULL, FALSE);
-
-	gboolean click = is_click(appid);
-	ual_tracepoint(libual_determine_type, appid, click ? "click" : "legacy");
-
-	/* Figure out if it is libertine */
-	gboolean libertine = FALSE;
-	if (!click) {
-		libertine = is_libertine(appid);
-	}
-
-	ual_tracepoint(libual_determine_libertine, appid, libertine ? "container" : "host");
-
-	/* 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) {
-		g_object_unref(con);
-		g_warning("Unable to get job path");
-		return FALSE;
-	}
-
-	ual_tracepoint(libual_job_path_determined, appid, jobpath);
-
-	/* Callback data */
-	app_start_t * app_start_data = g_new0(app_start_t, 1);
-	app_start_data->appid = g_strdup(appid);
-	app_start_data->con = G_DBUS_CONNECTION(g_object_ref(con));
-	app_start_data->cancel = cancel ? G_CANCELLABLE(g_object_ref(cancel)) : nullptr;
-
-	/* 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)));
-	g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf("APP_LAUNCHER_PID=%d", getpid())));
-
-	if (uris != NULL) {
-		gchar * urisjoin = app_uris_string(uris);
-		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 (libertine || 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));
-		}
-	}
-
-	if (test) {
-		g_variant_builder_add_value(&builder, g_variant_new_string("QT_LOAD_TESTABILITY=1"));
-	}
-
-	gboolean setup_complete = FALSE;
-	if (click) {
-		setup_complete = click_task_setup(con, appid, (EnvHandle*)&builder);
-	} else {
-		setup_complete = desktop_task_setup(con, appid, (EnvHandle*)&builder, libertine);
-	}
-
-	if (setup_complete) {
-		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,
-		                       cancel, /* cancelable */
-		                       application_start_cb,
-		                       app_start_data);
-
-		ual_tracepoint(libual_start_message_sent, appid);
-	} else {
-		g_variant_builder_clear(&builder);
-	}
-
-	return setup_complete;
-}
-
 gboolean
 ubuntu_app_launch_start_application (const gchar * appid, const gchar * const * uris)
 {
-	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-	g_return_val_if_fail(con != NULL, FALSE);
-
-	auto coreret = start_application_core(con, nullptr, appid, uris, FALSE);
-
-	g_object_unref(con);
-	return coreret;
+	try {
+		auto registry = ubuntu::app_launch::Registry::getDefault();
+		auto appId = ubuntu::app_launch::AppID::find(appid);
+		auto app = ubuntu::app_launch::Application::create(appId, registry);
+
+		std::vector<ubuntu::app_launch::Application::URL> urivect;
+		for (auto i = 0; uris != nullptr && uris[i] != nullptr; i++)
+			urivect.emplace_back(ubuntu::app_launch::Application::URL::from_raw(uris[i]));
+
+		auto instance = app->launch(urivect);
+
+		if (instance) {
+			return TRUE;
+		} else {
+			return FALSE;
+		}
+	} catch (std::runtime_error &e) {
+		g_warning("Unable to start app '%s': %s", appid, e.what());
+		return FALSE;
+	}
 }
 
 gboolean
 ubuntu_app_launch_start_application_test (const gchar * appid, const gchar * const * uris)
 {
-	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-	g_return_val_if_fail(con != NULL, FALSE);
-
-	auto coreret = start_application_core(con, nullptr, appid, uris, TRUE);
-
-	g_object_unref(con);
-	return coreret;
-}
-
-static void
-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);
-
-	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) {
-		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);
+	try {
+		auto registry = ubuntu::app_launch::Registry::getDefault();
+		auto appId = ubuntu::app_launch::AppID::find(appid);
+		auto app = ubuntu::app_launch::Application::create(appId, registry);
+
+		std::vector<ubuntu::app_launch::Application::URL> urivect;
+		for (auto i = 0; uris != nullptr && uris[i] != nullptr; i++)
+			urivect.emplace_back(ubuntu::app_launch::Application::URL::from_raw(uris[i]));
+
+		auto instance = app->launchTest(urivect);
+
+		if (instance) {
+			return TRUE;
+		} else {
+			return FALSE;
+		}
+	} catch (std::runtime_error &e) {
+		g_warning("Unable to start app '%s': %s", appid, e.what());
+		return FALSE;
+	}
 }
 
 static void
@@ -413,49 +171,21 @@
 {
 	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;
-	unsigned int i;
-
-	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(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(con, "application-click", appid, NULL);
-			found = TRUE;
-			break; /* There can be only one with click */
-		}
-	}
-
-	if (apps->len > 0)
-		g_array_remove_range(apps, 0, apps->len);
-
-	/* 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(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(con, "application-legacy", appid, &(instanceid[1]));
-			found = TRUE;
-		}
-	}
-	g_free(appiddash);
-
-	g_array_free(apps, TRUE);
-	g_object_unref(con);
-
-	return found;
+	try {
+		auto registry = ubuntu::app_launch::Registry::getDefault();
+		auto appId = ubuntu::app_launch::AppID::find(appid);
+		auto app = ubuntu::app_launch::Application::create(appId, registry);
+
+		auto instances = app->instances();
+		for (auto instance : instances) {
+			instance->stop();
+		}
+
+		return TRUE;
+	} catch (std::runtime_error &e) {
+		g_warning("Unable to stop app '%s': %s", appid, e.what());
+		return FALSE;
+	}
 }
 
 gboolean
@@ -489,59 +219,14 @@
 gchar *
 ubuntu_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 (!is_libertine(appid) && 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;
-}
-
-gboolean
-ubuntu_app_launch_application_info (const gchar * appid, gchar ** appdir, gchar ** appdesktop)
-{
-	if (is_click(appid)) {
-		return app_info_click(appid, appdir, appdesktop);
-	} else if (is_libertine(appid)) {
-		return app_info_libertine(appid, appdir, appdesktop);
-	} else {
-		return app_info_legacy(appid, appdir, appdesktop);
+	try {
+		auto registry = ubuntu::app_launch::Registry::getDefault();
+		auto appId = ubuntu::app_launch::AppID::find(appid);
+		auto app = ubuntu::app_launch::Application::create(appId, registry);
+		auto log = app->instances()[0]->logPath();
+		return g_strdup(log.c_str());
+	} catch (...) {
+		return NULL;
 	}
 }
 
@@ -1147,43 +832,6 @@
 	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 (GDBusConnection * con, const gchar * jobname, GArray * apps, gboolean truncate_legacy)
-{
-	apps_for_job_t data = {apps, truncate_legacy, jobname};
-
-	foreach_job_instance(con, jobname, apps_for_job_instance, &data);
-}
-
 gchar **
 ubuntu_app_launch_list_running_apps (void)
 {
@@ -1208,7 +856,7 @@
 	g_return_val_if_fail(appid != NULL, 0);
 
 	try {
-		auto registry = std::make_shared<ubuntu::app_launch::Registry>();
+		auto registry = ubuntu::app_launch::Registry::getDefault();
 		auto appId = ubuntu::app_launch::AppID::find(appid);
 		auto app = ubuntu::app_launch::Application::create(appId, registry);
 		return app->instances()[0]->primaryPid();
@@ -1224,7 +872,7 @@
 ubuntu_app_launch_get_pids (const gchar * appid)
 {
 	try {
-		auto registry = std::make_shared<ubuntu::app_launch::Registry>();
+		auto registry = ubuntu::app_launch::Registry::getDefault();
 		auto appId = ubuntu::app_launch::AppID::find(appid);
 		auto app = ubuntu::app_launch::Application::create(appId, registry);
 		auto pids = app->instances()[0]->pids();
@@ -1245,7 +893,7 @@
 {
 	g_return_val_if_fail(appid != NULL, FALSE);
 	try {
-		auto registry = std::make_shared<ubuntu::app_launch::Registry>();
+		auto registry = ubuntu::app_launch::Registry::getDefault();
 		auto appId = ubuntu::app_launch::AppID::find(appid);
 		auto app = ubuntu::app_launch::Application::create(appId, registry);
 
@@ -1296,16 +944,24 @@
 {
 	g_return_val_if_fail(pkg != NULL, NULL);
 
-	/* Check if is a libertine container */
-	gchar * libertinepath = g_build_filename(g_get_user_cache_dir(), "libertine-container", pkg, NULL);
-	gboolean libcontainer = g_file_test(libertinepath, G_FILE_TEST_EXISTS);
-	g_free(libertinepath);
-
-	if (libcontainer) {
-		return libertine_triplet_to_app_id(pkg, app, ver);
-	} else {
-		return click_triplet_to_app_id(pkg, app, ver);
-	}
+	std::string package{pkg};
+	std::string appname;
+	std::string version;
+
+	if (app != nullptr) {
+		appname = app;
+	}
+
+	if (ver != nullptr) {
+		version = ver;
+	}
+
+	auto appid = ubuntu::app_launch::AppID::discover(package, appname, version);
+	if (appid.empty()) {
+		return nullptr;
+	}
+
+	return g_strdup(std::string(appid).c_str());
 }
 
 /* Print an error if we couldn't start it */

=== modified file 'tests/exec-util-test.cc'
--- tests/exec-util-test.cc	2016-01-20 22:47:01 +0000
+++ tests/exec-util-test.cc	2016-08-04 14:02:19 +0000
@@ -24,6 +24,7 @@
 #include <libdbustest/dbus-test.h>
 #include <gio/gio.h>
 #include <libubuntu-app-launch/ubuntu-app-launch.h>
+#include <libubuntu-app-launch/registry.h>
 
 class ExecUtil : public ::testing::Test
 {
@@ -79,6 +80,7 @@
 
 		virtual void TearDown() {
 			ubuntu_app_launch_observer_delete_app_starting(starting_cb, NULL);
+			ubuntu::app_launch::Registry::clearDefault();
 
 			g_clear_object(&mock);
 			g_clear_object(&service);
@@ -130,8 +132,11 @@
 				/* Test the variable */
 				auto varfunc = enums[var];
 				EXPECT_NE(nullptr, varfunc);
-				if (varfunc)
+				if (varfunc) {
 					varfunc(value);
+				} else {
+					g_warning("Unable to find function for '%s'", var);
+				}
 
 				/* Mark it as found */
 				env_found[var] = true;
@@ -143,6 +148,9 @@
 
 			for(auto enumval : enums) {
 				EXPECT_TRUE(env_found[enumval.first]);
+				if (!env_found[enumval.first]) {
+					g_warning("Unable to find enum %s", enumval.first.c_str());
+				}
 			}
 		}
 };
@@ -177,8 +185,10 @@
 			EXPECT_STREQ("com.test.good_application_1.2.3", value); }},
 		{"APP_LAUNCHER_PID", [](const gchar * value) {
 			EXPECT_EQ(getpid(), atoi(value)); }},
-		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
-			EXPECT_STREQ(APP_DIR "/application.desktop", value); }},
+		/* {"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
+			EXPECT_STREQ(APP_DIR "/application.desktop", value); }}, */
+		{"APP_XMIR_ENABLE", [](const gchar * value) {
+			EXPECT_STREQ("0", value); }},
 	});
 
 #undef APP_DIR
@@ -189,8 +199,8 @@
 	StartCheckEnv("foo", {
 		{"APP_EXEC", [](const gchar * value) {
 			EXPECT_STREQ("foo", value); }},
-		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
-			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/foo.desktop", value); }},
+		/* {"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
+			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/foo.desktop", value); }}, */
 		{"APP_EXEC_POLICY", [](const gchar * value) {
 			EXPECT_STREQ("unconfined", value); }},
 		{"APP_ID", [](const gchar * value) {
@@ -198,6 +208,8 @@
 		{"INSTANCE_ID", nocheck},
 		{"APP_LAUNCHER_PID", [](const gchar * value) {
 			EXPECT_EQ(getpid(), atoi(value)); }},
+		{"APP_XMIR_ENABLE", [](const gchar * value) {
+			EXPECT_STREQ("0", value); }},
 	});
 }
 
@@ -206,8 +218,8 @@
 	StartCheckEnv("xmir", {
 		{"APP_EXEC", [](const gchar * value) {
 			EXPECT_STREQ("xfoo", value); }},
-		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
-			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/xmir.desktop", value); }},
+		/* {"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
+			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/xmir.desktop", value); }}, */
 		{"APP_EXEC_POLICY", [](const gchar * value) {
 			EXPECT_STREQ("unconfined", value); }},
 		{"APP_ID", [](const gchar * value) {
@@ -225,8 +237,8 @@
 	StartCheckEnv("noxmir", {
 		{"APP_EXEC", [](const gchar * value) {
 			EXPECT_STREQ("noxmir", value); }},
-		{"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
-			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/noxmir.desktop", value); }},
+		/* {"APP_DESKTOP_FILE_PATH", [](const gchar * value) {
+			EXPECT_STREQ(CMAKE_SOURCE_DIR "/applications/noxmir.desktop", value); }}, */
 		{"APP_EXEC_POLICY", [](const gchar * value) {
 			EXPECT_STREQ("unconfined", value); }},
 		{"APP_ID", [](const gchar * value) {
@@ -255,7 +267,7 @@
 		{"APP_ID", [](const gchar * value) {
 			EXPECT_STREQ("com.test.mir_mir_1", value); }},
 		{"APP_LAUNCHER_PID", nocheck},
-		{"APP_DESKTOP_FILE_PATH", nocheck},
+		/* {"APP_DESKTOP_FILE_PATH", nocheck}, */
 		{"APP_XMIR_ENABLE", [](const gchar * value) {
 			EXPECT_STREQ("1", value); }},
 	});
@@ -277,7 +289,7 @@
 		{"APP_ID", [](const gchar * value) {
 			EXPECT_STREQ("com.test.mir_nomir_1", value); }},
 		{"APP_LAUNCHER_PID", nocheck},
-		{"APP_DESKTOP_FILE_PATH", nocheck},
+		/* {"APP_DESKTOP_FILE_PATH", nocheck}, */
 		{"APP_XMIR_ENABLE", [](const gchar * value) {
 			EXPECT_STREQ("0", value); }},
 	});

=== modified file 'tests/libual-cpp-test.cc'
--- tests/libual-cpp-test.cc	2016-08-04 14:02:18 +0000
+++ tests/libual-cpp-test.cc	2016-08-04 14:02:19 +0000
@@ -25,6 +25,7 @@
 
 #include "mir-mock.h"
 #include <gio/gio.h>
+#include <glib/gstdio.h>
 #include <gtest/gtest.h>
 #include <zeitgeist.h>
 
@@ -342,7 +343,7 @@
     }
 };
 
-TEST_F(LibUAL, StartApplication)
+TEST_F(LibUAL, StartClickApplication)
 {
     DbusTestDbusMockObject* obj =
         dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
@@ -399,7 +400,7 @@
     return;
 }
 
-TEST_F(LibUAL, StartApplicationTest)
+TEST_F(LibUAL, StartClickApplicationTest)
 {
     DbusTestDbusMockObject* obj =
         dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
@@ -427,7 +428,7 @@
     g_variant_unref(env);
 }
 
-TEST_F(LibUAL, StopApplication)
+TEST_F(LibUAL, StopClickApplication)
 {
     DbusTestDbusMockObject* obj =
         dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
@@ -456,15 +457,15 @@
         std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-click-com.test.good_application_1.2.3.log"),
         app->instances()[0]->logPath());
 
-    appid = ubuntu::app_launch::AppID::find("single");
+    appid = ubuntu::app_launch::AppID::find(registry, "single");
     app = ubuntu::app_launch::Application::create(appid, registry);
 
-	ASSERT_LT(0, app->instances().size());
+    ASSERT_LT(0, app->instances().size());
 
     EXPECT_EQ(std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-legacy-single-.log"),
               app->instances()[0]->logPath());
 
-    appid = ubuntu::app_launch::AppID::find("multiple");
+    appid = ubuntu::app_launch::AppID::find(registry, "multiple");
     app = ubuntu::app_launch::Application::create(appid, registry);
 
     EXPECT_EQ(std::string(CMAKE_SOURCE_DIR "/libertine-data/upstart/application-legacy-multiple-2342345.log"),
@@ -486,9 +487,10 @@
     EXPECT_TRUE(app->instances()[0]->hasPid(300));
 
     /* Check primary pid, which comes from Upstart */
+    EXPECT_TRUE(app->instances()[0]->isRunning());
     EXPECT_EQ(getpid(), app->instances()[0]->primaryPid());
 
-    auto multiappid = ubuntu::app_launch::AppID::find("multiple");
+    auto multiappid = ubuntu::app_launch::AppID::find(registry, "multiple");
     auto multiapp = ubuntu::app_launch::Application::create(multiappid, registry);
     auto instances = multiapp->instances();
     ASSERT_LT(0, instances.size());
@@ -520,7 +522,7 @@
     ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(cgmock, cgobject, NULL));
 
     /* Legacy Single Instance */
-    auto singleappid = ubuntu::app_launch::AppID::find("single");
+    auto singleappid = ubuntu::app_launch::AppID::find(registry, "single");
     auto singleapp = ubuntu::app_launch::Application::create(singleappid, registry);
 
     ASSERT_LT(0, singleapp->instances().size());
@@ -549,50 +551,53 @@
 
     /* Test with current-user-version, should return the version in the manifest */
     EXPECT_EQ("com.test.good_application_1.2.3",
-              (std::string)ubuntu::app_launch::AppID::discover("com.test.good", "application"));
+              (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.good", "application"));
 
     /* Test with version specified, shouldn't even read the manifest */
     EXPECT_EQ("com.test.good_application_1.2.4",
-              (std::string)ubuntu::app_launch::AppID::discover("com.test.good", "application", "1.2.4"));
+              (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.good", "application", "1.2.4"));
 
     /* Test with out a version or app, should return the version in the manifest */
-    EXPECT_EQ("com.test.good_application_1.2.3", (std::string)ubuntu::app_launch::AppID::discover(
-                                                     "com.test.good", "first-listed-app", "current-user-version"));
+    EXPECT_EQ("com.test.good_application_1.2.3",
+              (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.good", "first-listed-app",
+                                                               "current-user-version"));
 
     /* Make sure we can select the app from a list correctly */
     EXPECT_EQ("com.test.multiple_first_1.2.3",
               (std::string)ubuntu::app_launch::AppID::discover(
-                  "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::FIRST_LISTED));
-    EXPECT_EQ("com.test.multiple_first_1.2.3", (std::string)ubuntu::app_launch::AppID::discover("com.test.multiple"));
+                  registry, "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::FIRST_LISTED));
+    EXPECT_EQ("com.test.multiple_first_1.2.3",
+              (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.multiple"));
     EXPECT_EQ("com.test.multiple_fifth_1.2.3",
               (std::string)ubuntu::app_launch::AppID::discover(
-                  "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::LAST_LISTED));
+                  registry, "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::LAST_LISTED));
     EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(
-                      "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::ONLY_LISTED));
+                      registry, "com.test.multiple", ubuntu::app_launch::AppID::ApplicationWildcard::ONLY_LISTED));
     EXPECT_EQ("com.test.good_application_1.2.3",
               (std::string)ubuntu::app_launch::AppID::discover(
-                  "com.test.good", ubuntu::app_launch::AppID::ApplicationWildcard::ONLY_LISTED));
+                  registry, "com.test.good", ubuntu::app_launch::AppID::ApplicationWildcard::ONLY_LISTED));
 
     /* A bunch that should be NULL */
-    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("com.test.no-hooks"));
-    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("com.test.no-json"));
-    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("com.test.no-object"));
-    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("com.test.no-version"));
+    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.no-hooks"));
+    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.no-json"));
+    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.no-object"));
+    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "com.test.no-version"));
 
     /* Libertine tests */
-    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("container-name"));
-    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover("container-name", "not-exist"));
-    EXPECT_EQ("container-name_test_0.0", (std::string)ubuntu::app_launch::AppID::discover("container-name", "test"));
+    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "container-name"));
+    EXPECT_EQ("", (std::string)ubuntu::app_launch::AppID::discover(registry, "container-name", "not-exist"));
+    EXPECT_EQ("container-name_test_0.0",
+              (std::string)ubuntu::app_launch::AppID::discover(registry, "container-name", "test"));
     EXPECT_EQ("container-name_user-app_0.0",
-              (std::string)ubuntu::app_launch::AppID::discover("container-name", "user-app"));
+              (std::string)ubuntu::app_launch::AppID::discover(registry, "container-name", "user-app"));
 }
 
 TEST_F(LibUAL, AppIdParse)
 {
     EXPECT_FALSE(ubuntu::app_launch::AppID::parse("com.ubuntu.test_test_123").empty());
-    EXPECT_FALSE(ubuntu::app_launch::AppID::find("inkscape").empty());
+    EXPECT_FALSE(ubuntu::app_launch::AppID::find(registry, "inkscape").empty());
     EXPECT_FALSE(ubuntu::app_launch::AppID::parse("chatter.robert-ancell_chatter_2").empty());
-    EXPECT_FALSE(ubuntu::app_launch::AppID::find("chatter.robert-ancell_chatter").empty());
+    EXPECT_FALSE(ubuntu::app_launch::AppID::find(registry, "chatter.robert-ancell_chatter").empty());
 
     auto id = ubuntu::app_launch::AppID::parse("com.ubuntu.test_test_123");
 
@@ -960,7 +965,7 @@
         dbus_test_dbus_mock_get_object(mock, "/com/test/application_legacy", "com.ubuntu.Upstart0_6.Job", NULL);
 
     /* Check for a single-instance app */
-    auto singleappid = ubuntu::app_launch::AppID::find("single");
+    auto singleappid = ubuntu::app_launch::AppID::find(registry, "single");
     auto singleapp = ubuntu::app_launch::Application::create(singleappid, registry);
 
     singleapp->launch();
@@ -985,7 +990,7 @@
     ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
 
     /* Check for a multi-instance app */
-    auto multipleappid = ubuntu::app_launch::AppID::find("multiple");
+    auto multipleappid = ubuntu::app_launch::AppID::find(registry, "multiple");
     auto multipleapp = ubuntu::app_launch::Application::create(multipleappid, registry);
 
     multipleapp->launch();
@@ -1462,7 +1467,7 @@
         signal_increment, &resumed_count, nullptr);
 
     /* Get our app object */
-    auto appid = ubuntu::app_launch::AppID::find("com.test.good_application_1.2.3");
+    auto appid = ubuntu::app_launch::AppID::find(registry, "com.test.good_application_1.2.3");
     auto app = ubuntu::app_launch::Application::create(appid, registry);
 
     ASSERT_EQ(1, app->instances().size());
@@ -1572,7 +1577,7 @@
              dbus_test_task_get_state(DBUS_TEST_TASK(zgmock)) != DBUS_TEST_TASK_STATE_RUNNING);
 
     /* Get our app object */
-    auto appid = ubuntu::app_launch::AppID::find("com.test.good_application_1.2.3");
+    auto appid = ubuntu::app_launch::AppID::find(registry, "com.test.good_application_1.2.3");
     auto app = ubuntu::app_launch::Application::create(appid, registry);
 
     ASSERT_EQ(1, app->instances().size());
@@ -1657,7 +1662,7 @@
     } while (dbus_test_task_get_state(DBUS_TEST_TASK(cgmock2)) != DBUS_TEST_TASK_STATE_RUNNING);
 
     /* Get our app object */
-    auto appid = ubuntu::app_launch::AppID::find("com.test.good_application_1.2.3");
+    auto appid = ubuntu::app_launch::AppID::find(registry, "com.test.good_application_1.2.3");
     auto app = ubuntu::app_launch::Application::create(appid, registry);
 
     ASSERT_EQ(1, app->instances().size());
@@ -1868,7 +1873,7 @@
     EXPECT_EQ("Application", app->info()->name().value());
 
     /* Correct values from a legacy */
-    auto barid = ubuntu::app_launch::AppID::find("bar");
+    auto barid = ubuntu::app_launch::AppID::find(registry, "bar");
     EXPECT_THROW(ubuntu::app_launch::Application::create(barid, registry), std::runtime_error);
 
     /* Correct values for libertine */

=== modified file 'tests/list-apps.cpp'
--- tests/list-apps.cpp	2016-08-04 14:02:18 +0000
+++ tests/list-apps.cpp	2016-08-04 14:02:19 +0000
@@ -135,7 +135,7 @@
     auto registry = std::make_shared<ubuntu::app_launch::Registry>();
     auto apps = ubuntu::app_launch::app_impls::Legacy::list(registry);
 
-    EXPECT_EQ(1, apps.size());
+    EXPECT_EQ(0, apps.size());
 }
 
 TEST_F(ListApps, ListLibertine)
@@ -156,5 +156,5 @@
     /* Get all the apps */
     auto apps = ubuntu::app_launch::Registry::installedApps(registry);
 
-    EXPECT_EQ(14, apps.size());
+    EXPECT_EQ(13, apps.size());
 }