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

[Ted Gould]

Support launching applications installed as snaps

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

291. By Ted Gould on 2016-07-26

Adding some helper functions to make the tests easier to read

292. By Ted Gould on 2016-07-26

Add an interfaces test

293. By Ted Gould on 2016-07-26

Test getting the interfaces for an AppID

294. By Ted Gould on 2016-07-26

This branch isn't going to have an event watcher, just remove it for now

295. By Ted Gould on 2016-07-26

Adding some negative tests

296. By Ted Gould on 2016-07-26

Adding a list apps framework.

297. By Ted Gould on 2016-07-27

Building all our tests, but we'd like more results

298. By Ted Gould on 2016-07-27

Making it so that we can list ourselves some apps

299. By Ted Gould on 2016-07-27

Verify the apps that are returned

300. By Ted Gould on 2016-07-28

Making it so that we can get a testable Click directory and properly handle its errors

301. By Ted Gould on 2016-07-28

Verify some of the data returned in the list of apps

302. By Ted Gould on 2016-07-28

Make it so that we can have the snapd mock in the overall tests

303. By Ted Gould on 2016-07-28

Adding more snapd cases

304. By Ted Gould on 2016-07-28

Getting Libertine apps out of the container

305. By Ted Gould on 2016-07-28

Remove unused code

306. By Ted Gould on 2016-07-28

Adding snap start/stop tests

307. By Ted Gould on 2016-07-29

Moving stop application code over to C++

308. By Ted Gould on 2016-07-29

Making the shared lib a double build

309. By Ted Gould on 2016-08-01

Get the PID earlier so that the C interface functions can use the default registry and work better

310. By Ted Gould on 2016-08-01

Put the socket in /tmp

311. By Ted Gould on 2016-08-01

Cleanup shutting down of the mock

312. By Ted Gould on 2016-08-01

Making it so that the CURL timeout can be disabled for tests

313. By Ted Gould on 2016-08-01

Making the timers and loops work on the thread default context

314. By Ted Gould on 2016-08-02

Fix exec lines to include the shell script

315. By Ted Gould on 2016-08-02

Flipping some discover

316. By Ted Gould on 2016-08-02

Adding a registry parameter

317. By Ted Gould on 2016-08-02

Flesh out Click implementations

318. By Ted Gould on 2016-08-02

Flesh out the snap implementation

319. By Ted Gould on 2016-08-02

Make the discover with strings understand the well known strings and turn them into enums

320. By Ted Gould on 2016-08-02

Provide discover functions that allow passing the registry in

321. By Ted Gould on 2016-08-02

Use the registry param functions

322. By Ted Gould on 2016-08-02

Catch exceptions from verifyPackage and specify which type we'll handle

323. By Ted Gould on 2016-08-02

Make the C triplet function use the C++ discover code

324. By Ted Gould on 2016-08-02

Adding a registry friendly version of ::find

325. By Ted Gould on 2016-08-02

Fixing our test database

326. By Ted Gould on 2016-08-02

Fix test to match fix to database

327. By Ted Gould on 2016-08-02

Use the registry pointer for our ::find() call

328. By Ted Gould on 2016-08-03

Supporting instances in the snappy upstart job

329. By Ted Gould on 2016-08-03

Adding a revision

330. By Ted Gould on 2016-08-03

Removing app-info.h from the C++ code

331. By Ted Gould on 2016-08-03

Move over the log file code to use the C++ interface

332. By Ted Gould on 2016-08-03

Remove app-info.h and put app_info() function in app-info.c

333. By Ted Gould on 2016-08-03

Test the snap package discoveries

334. By Ted Gould on 2016-08-03

Check isRunning() as well

335. By Ted Gould on 2016-08-03

Doc fixes

336. By Ted Gould on 2016-08-03

Documentation on the base class header

337. By Ted Gould on 2016-08-03

Adding new classes to the documentation generation

338. By Ted Gould on 2016-08-03

Adding more docs

339. By Ted Gould on 2016-08-03

Moar docs!

340. By Ted Gould on 2016-08-03

Make sure we list snap packages

341. By Ted Gould on 2016-08-03

Make sure we detect snaps starting and stopping

342. By Ted Gould on 2016-08-03

Grabbing libcurl

343. By Ted Gould on 2016-08-04

Tying in the breakout branch versions so we only have the snap backend added here

344. By Ted Gould on 2016-08-04

Pulling through trunk

345. By Ted Gould on 2016-08-04

Checking for appname based on Snappy's definition of it

346. By Ted Gould on 2016-08-05

More comments

347. By Ted Gould on 2016-08-12

Pull through OOM updates

348. By Ted Gould on 2016-08-17

Make the failure handle snap instances

349. By Ted Gould on 2016-08-18

Fix legacy instance pull through

350. By Ted Gould on 2016-08-23

Updating to trunk

351. By Ted Gould on 2016-08-24

Grabbing upstream changes

352. By Ted Gould on 2016-08-24

Update to changing internal APIs

353. By Ted Gould on 2016-08-24

Fix app counts

354. By Ted Gould on 2016-08-24

Adding more documentation to get up to snuff

355. By Ted Gould on 2016-08-25

Add error message and free error

356. By Ted Gould on 2016-08-25

Better equality

357. By Ted Gould on 2016-08-25

Pull the appid vs. pkginfo checking into its own function

358. By Ted Gould on 2016-08-25

for (auto → for (const auto&

359. By Ted Gould on 2016-08-25

Everyone hates moving

360. By Ted Gould on 2016-08-25

Be more persistent

361. By Ted Gould on 2016-08-25

Add more description to hasAppID

362. By Ted Gould on 2016-08-25

Remove unneeded try/catch

363. By Ted Gould on 2016-08-25

Empty commit

364. By Ted Gould on 2016-08-25

Switch to using appid_ member variable

365. By Ted Gould on 2016-08-25

Switch to use member variable

366. By Ted Gould on 2016-08-25

More description on forAllPlugs

367. By Ted Gould on 2016-08-25

Make sure not to init std::string's with nullptr

368. By Ted Gould on 2016-08-25

Avoid going to the point of null return

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-08-26

Make sure the list-apps socket and the libual-cpp-tests sockets are different so they can run in parallel

372. By Ted Gould on 2016-08-26

Make snappy backend include based on having new enough cURL

373. By Ted Gould on 2016-08-26

Hardcode in the host so that we're not effected by different URL parsers in different versions of cURL

374. By Ted Gould on 2016-08-26

Make sure we're not copying in a for loop

375. By Ted Gould on 2016-08-26

Make sure we have strings for the values of the members

376. By Ted Gould on 2016-08-26

Clean up types

377. By Ted Gould on 2016-08-26

Use STL insert and fix 'apps' check

378. By Ted Gould on 2016-08-26

Get the message out

379. By Ted Gould on 2016-08-26

Check to ensure these are strings too

380. By Ted Gould on 2016-08-26

Oops, put result in the wrong bin

381. By Ted Gould on 2016-09-06

Merging trunk

382. By Ted Gould on 2016-09-08

Typo

383. By Ted Gould on 2016-09-13

Remove errant changelog entry

Unmerged revisions

=== modified file '.bzrignore'
--- .bzrignore	2015-12-10 21:01:26 +0000
+++ .bzrignore	2016-08-03 18:41:53 +0000
@@ -11,3 +11,4 @@
 libubuntu-app-launch/proxy-socket-demangler.c
 libubuntu-app-launch/proxy-socket-demangler.h
 libubuntu-app-launch/ubuntu-app-launch-2.pc
+application-snap.conf

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-08-03 18:41:52 +0000
+++ CMakeLists.txt	2016-08-03 18:41:53 +0000
@@ -89,6 +89,9 @@
 pkg_check_modules(LIBERTINE libertine)
 include_directories(${LIBERTINE_INCLUDE_DIRS})
 
+pkg_check_modules(CURL libcurl)
+include_directories(${CURL_INCLUDE_DIRS})
+
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")

=== modified file 'debian/changelog'
--- debian/changelog	2016-05-10 19:11:21 +0000
+++ debian/changelog	2016-08-03 18:41:53 +0000
@@ -1,3 +1,9 @@
+ubuntu-app-launch (0.9+16.04.20160730-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Introducing Snappy backend
+
+ -- Ted Gould <[e-mail]>  Fri, 29 Jul 2016 11:05:47 -0500
+
 ubuntu-app-launch (0.9+16.04.20160510.2-0ubuntu1) xenial; urgency=medium
 
   * Allow invalid desktop files for OTA11 quick fix (LP: #1580092)

=== modified file 'docs/index.rst'
--- docs/index.rst	2016-04-29 14:20:11 +0000
+++ docs/index.rst	2016-08-03 18:41:53 +0000
@@ -96,6 +96,16 @@
    :private-members:
    :undoc-members:
 
+Application Implementation Snappy
+---------------------------------
+
+.. doxygenclass:: ubuntu::app_launch::app_impls::Snap
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
 Application Info Desktop
 ------------------------
 
@@ -106,10 +116,20 @@
    :private-members:
    :undoc-members:
 
+Application Info Snap
+------------------------
+
+.. doxygenclass:: ubuntu::app_launch::app_impls::SnapInfo
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
 Application Icon Finder
 ------------------------
 
-.. doxygenclass:: ubuntu::app_launch::app_info::IconFinder
+.. doxygenclass:: ubuntu::app_launch::IconFinder
    :project: libubuntu-app-launch
    :members:
    :protected-members:
@@ -136,6 +156,16 @@
    :private-members:
    :undoc-members:
 
+Snapd Info
+----------
+
+.. doxygenclass:: ubuntu::app_launch::snapd::Info
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
 Type Tagger
 -----------
 
@@ -146,6 +176,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-03 18:41:52 +0000
+++ helpers.c	2016-08-03 18:41:53 +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-03 18:41:53 +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-03 18:41:52 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2016-08-03 18:41:53 +0000
@@ -41,25 +41,30 @@
 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-impl-snap.h
+application-impl-snap.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
+snapd-info.h
+snapd-info.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
@@ -71,8 +76,26 @@
 
 add_gdbus_codegen_with_namespace(LAUNCHER_GEN_SOURCES proxy-socket-demangler com.canonical.UbuntuAppLaunch. proxy ${CMAKE_SOURCE_DIR}/data/com.canonical.UbuntuAppLaunch.SocketDemangler.xml)
 
-
-add_library(ubuntu-launcher SHARED ${LAUNCHER_SOURCES} ${LAUNCHER_GEN_SOURCES})
+add_library(launcher-static ${LAUNCHER_SOURCES} ${LAUNCHER_CPP_SOURCES} ${LAUNCHER_GEN_SOURCES})
+
+target_link_libraries(launcher-static
+	${GLIB2_LIBARIES}
+	${GOBJECT2_LIBRARIES}
+	${LIBUPSTART_LIBRARIES}
+	${GIO2_LIBRARIES}
+	${LTTNG_LIBRARIES}
+	${JSONGLIB_LIBRARIES}
+	${CLICK_LIBRARIES}
+	${ZEITGEIST_LIBRARIES}
+	${MIR_LIBRARIES}
+	${LIBERTINE_LIBRARIES}
+	${CURL_LIBRARIES}
+	-lpthread
+	helpers
+	-Wl,--no-undefined
+)
+
+add_library(ubuntu-launcher SHARED ${LAUNCHER_SOURCES} ${LAUNCHER_CPP_SOURCES} ${LAUNCHER_GEN_SOURCES})
 
 set_target_properties(ubuntu-launcher PROPERTIES
 	VERSION ${ABI_VERSION}.0.0
@@ -93,6 +116,7 @@
 	${ZEITGEIST_LIBRARIES}
 	${MIR_LIBRARIES}
 	${LIBERTINE_LIBRARIES}
+	${CURL_LIBRARIES}
 	-lpthread
 	helpers
 	-Wl,--no-undefined

=== 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-03 18:41:53 +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-03 18:41:52 +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-03 18:41:53 +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.
 
@@ -68,7 +70,10 @@
         under the "hooks" key in the JSON manifest. */
     AppName appname;
     /** Version of the package that is installed. This is always resolved when
-        creating the struct. */
+        creating the struct.
+
+        \note For snaps this is actually the 'revision' instead of the version
+              since that is unique where 'version' is not. */
     Version version;
 
     /** Turn the structure into a string. This is required for many older C based
@@ -104,9 +109,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 +147,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 +160,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 +172,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-03 18:41:52 +0000
+++ libubuntu-app-launch/application-impl-base.cpp	2016-08-03 18:41:53 +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-03 18:41:52 +0000
+++ libubuntu-app-launch/application-impl-base.h	2016-08-03 18:41:53 +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-03 18:41:52 +0000
+++ libubuntu-app-launch/application-impl-click.cpp	2016-08-03 18:41:53 +0000
@@ -21,6 +21,8 @@
 #include "application-info-desktop.h"
 #include "registry-impl.h"
 
+#include <algorithm>
+
 namespace ubuntu
 {
 namespace app_launch
@@ -31,6 +33,7 @@
 AppID::Version manifestVersion(const std::shared_ptr<JsonObject>& manifest);
 std::list<AppID::AppName> manifestApps(const std::shared_ptr<JsonObject>& manifest);
 std::shared_ptr<GKeyFile> manifestAppDesktop(const std::shared_ptr<JsonObject>& manifest,
+                                             const std::string& package,
                                              const std::string& app,
                                              const std::string& clickDir);
 
@@ -44,7 +47,7 @@
     , _appid(appid)
     , _manifest(manifest)
     , _clickDir(registry->impl->getClickDir(appid.package))
-    , _keyfile(manifestAppDesktop(manifest, 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};
@@ -55,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)
@@ -65,7 +149,7 @@
     auto cstr = json_object_get_string_member(manifest.get(), "version");
 
     if (cstr == nullptr)
-        throw std::runtime_error("Unable to find version number in manifest");
+        throw std::runtime_error("Unable to find version number in manifest: " + Registry::Impl::printJson(manifest));
 
     auto cppstr = AppID::Version::from_raw((const gchar*)cstr);
     return cppstr;
@@ -95,17 +179,24 @@
         }
     }
 
-    g_list_free_full(gapps, g_free);
+    g_list_free(gapps);
     return apps;
 }
 
 std::shared_ptr<GKeyFile> manifestAppDesktop(const std::shared_ptr<JsonObject>& manifest,
+                                             const std::string& package,
                                              const std::string& app,
                                              const std::string& clickDir)
 {
+    if (!manifest)
+    {
+        throw std::runtime_error("No manifest for package '" + package + "'");
+    }
+
     auto hooks = json_object_get_object_member(manifest.get(), "hooks");
     if (hooks == nullptr)
-        throw std::runtime_error("Manifest for application '" + app + "' does not have a 'hooks' field");
+        throw std::runtime_error("Manifest for application '" + app + "' does not have a 'hooks' field: " +
+                                 Registry::Impl::printJson(manifest));
 
     auto gapps = json_object_get_members(hooks);
     if (gapps == nullptr)
@@ -113,11 +204,13 @@
 
     auto hooklist = json_object_get_object_member(hooks, app.c_str());
     if (hooklist == nullptr)
-        throw std::runtime_error("Manifest for does not have an application '" + app + "'");
+        throw std::runtime_error("Manifest for does not have an application '" + app + "': " +
+                                 Registry::Impl::printJson(manifest));
 
     auto desktoppath = json_object_get_string_member(hooklist, "desktop");
     if (desktoppath == nullptr)
-        throw std::runtime_error("Manifest for application '" + app + "' does not have a 'desktop' hook");
+        throw std::runtime_error("Manifest for application '" + app + "' does not have a 'desktop' hook: " +
+                                 Registry::Impl::printJson(manifest));
 
     auto path = std::shared_ptr<gchar>(g_build_filename(clickDir.c_str(), desktoppath, nullptr), g_free);
 
@@ -137,17 +230,40 @@
 {
     std::list<std::shared_ptr<Application>> applist;
 
-    for (auto pkg : registry->impl->getClickPackages())
+    try
     {
-        auto manifest = registry->impl->getClickManifest(pkg);
-
-        for (auto appname : manifestApps(manifest))
+        for (auto pkg : registry->impl->getClickPackages())
         {
-            AppID appid{package : pkg, appname : appname, version : manifestVersion(manifest)};
-            auto app = std::make_shared<Click>(appid, manifest, registry);
-            applist.push_back(app);
+            try
+            {
+                auto manifest = registry->impl->getClickManifest(pkg);
+
+                for (auto appname : manifestApps(manifest))
+                {
+                    try
+                    {
+                        AppID appid{package : pkg, appname : appname, version : manifestVersion(manifest)};
+                        auto app = std::make_shared<Click>(appid, manifest, registry);
+                        applist.push_back(app);
+                    }
+                    catch (std::runtime_error& e)
+                    {
+                        g_debug("Unable to create Click for application '%s' in package '%s': %s",
+                                appname.value().c_str(), pkg.value().c_str(), e.what());
+                    }
+                }
+            }
+            catch (std::runtime_error& e)
+            {
+                g_debug("Unable to get information to build Click app on package '%s': %s", pkg.value().c_str(),
+                        e.what());
+            }
         }
     }
+    catch (std::runtime_error& e)
+    {
+        g_debug("Unable to get packages from Click database: %s", e.what());
+    }
 
     return applist;
 }
@@ -163,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-03 18:41:52 +0000
+++ libubuntu-app-launch/application-impl-click.h	2016-08-03 18:41:53 +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-03 18:41:52 +0000
+++ libubuntu-app-launch/application-impl-legacy.cpp	2016-08-03 18:41:53 +0000
@@ -21,6 +21,8 @@
 #include "application-info-desktop.h"
 #include "registry-impl.h"
 
+#include <regex>
+
 namespace ubuntu
 {
 namespace app_launch
@@ -28,6 +30,7 @@
 namespace app_impls
 {
 
+const std::string snappyDesktopPath{"/var/lib/snapd"};
 std::pair<std::string, std::shared_ptr<GKeyFile>> keyfileForApp(const AppID::AppName& name);
 
 void clear_keyfile(GKeyFile* keyfile)
@@ -38,27 +41,23 @@
     }
 }
 
-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()};
+    }
+
+    if (std::equal(snappyDesktopPath.begin(), snappyDesktopPath.end(), _basedir.begin()))
+    {
+        throw std::runtime_error{"Looking like a legacy app, but should be a Snap: " + appname.value()};
+    }
 }
 
 std::pair<std::string, std::shared_ptr<GKeyFile>> keyfileForApp(const AppID::AppName& name)
@@ -103,13 +102,81 @@
 
 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)
 {
     std::list<std::shared_ptr<Application>> list;
@@ -128,8 +195,34 @@
             continue;
         }
 
-        auto app = std::make_shared<Legacy>(AppID::AppName::from_raw(g_app_info_get_id(G_APP_INFO(appinfo))), registry);
-        list.push_back(app);
+        auto desktopappid = std::string(g_app_info_get_id(G_APP_INFO(appinfo)));
+        std::string appname;
+        std::smatch match;
+        if (std::regex_match(desktopappid, match, desktop_remover))
+        {
+            appname = match[1].str();
+        }
+        else
+        {
+            continue;
+        }
+
+        auto fileappid = g_desktop_app_info_get_string(appinfo, "x-Ubuntu-UAL-Application-ID");
+        if (fileappid != nullptr)
+        {
+            g_free(fileappid);
+            continue;
+        }
+
+        try
+        {
+            auto app = std::make_shared<Legacy>(AppID::AppName::from_raw(appname), registry);
+            list.push_back(app);
+        }
+        catch (std::runtime_error& e)
+        {
+            g_debug("Unable to create application for legacy appname '%s': %s", appname.c_str(), e.what());
+        }
     }
 
     g_list_free_full(head, g_object_unref);
@@ -147,7 +240,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));
         }
     }
 
@@ -156,16 +250,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-03 18:41:52 +0000
+++ libubuntu-app-launch/application-impl-legacy.h	2016-08-03 18:41:53 +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-03 18:41:52 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2016-08-03 18:41:53 +0000
@@ -18,7 +18,6 @@
  */
 
 #include "application-impl-libertine.h"
-#include "application-info-desktop.h"
 #include "libertine.h"
 #include "registry-impl.h"
 
@@ -107,34 +106,100 @@
     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;
 
-    auto containers = libertine_list_containers();
+    auto containers = std::shared_ptr<gchar*>(libertine_list_containers(), g_strfreev);
 
-    for (int i = 0; containers[i] != nullptr; i++)
+    for (int i = 0; containers.get()[i] != nullptr; i++)
     {
-        auto container = containers[i];
-        auto apps = libertine_list_apps_for_container(container);
+        auto container = containers.get()[i];
+        auto apps = std::shared_ptr<gchar*>(libertine_list_apps_for_container(container), g_strfreev);
 
-        for (int i = 0; apps[i] != nullptr; i++)
+        for (int i = 0; apps.get()[i] != nullptr; i++)
         {
-            auto sapp = std::make_shared<Libertine>(AppID::Package::from_raw(container),
-                                                    AppID::AppName::from_raw(apps[i]), registry);
+            auto appid = AppID::parse(apps.get()[i]);
+            auto sapp = std::make_shared<Libertine>(appid.package, appid.appname, registry);
             applist.push_back(sapp);
         }
-
-        g_strfreev(apps);
     }
-    g_strfreev(containers);
 
     return applist;
 }
 
 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()
@@ -145,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-03 18:41:52 +0000
+++ libubuntu-app-launch/application-impl-libertine.h	2016-08-03 18:41:53 +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

=== added file 'libubuntu-app-launch/application-impl-snap.cpp'
--- libubuntu-app-launch/application-impl-snap.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/application-impl-snap.cpp	2016-08-03 18:41:53 +0000
@@ -0,0 +1,439 @@
+/*
+ * Copyright © 2016 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 "application-impl-snap.h"
+#include "application-info-desktop.h"
+#include "registry-impl.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_impls
+{
+
+/************************
+ ** Interface Lists
+ ************************/
+
+/** All the interfaces that we support running applications with */
+const std::set<std::string> SUPPORTED_INTERFACES{"unity8", "unity7", "x11"};
+/** All the interfaces that we run XMir for by default */
+const std::set<std::string> XMIR_INTERFACES{"unity7", "x11"};
+/** All the interfaces that we tell Unity support lifecycle */
+const std::set<std::string> LIFECYCLE_INTERFACES{"unity8"};
+
+/************************
+ ** Info support
+ ************************/
+
+/** Subclassing the desktop info object so that we can override a couple
+    of properties with interface definitions. This may grow as we add more
+    fields to the desktop spec that come from Snappy interfaces. */
+class SnapInfo : public app_info::Desktop
+{
+    /** The core interface for this snap */
+    std::string interface_;
+    /** AppID of snap */
+    AppID appId_;
+
+public:
+    SnapInfo(const AppID& appid,
+             const std::shared_ptr<Registry>& registry,
+             const std::string& interface,
+             const std::string& snapDir)
+        : Desktop(
+              [appid, snapDir]() -> std::shared_ptr<GKeyFile> {
+                  /* This is a function to get the keyfile out of the snap using
+                     the paths that snappy places things inside the dir. */
+                  std::string path = snapDir + "/meta/gui/" + appid.appname.value() + ".desktop";
+                  std::shared_ptr<GKeyFile> keyfile(g_key_file_new(), g_key_file_free);
+                  GError* error = nullptr;
+                  g_key_file_load_from_file(keyfile.get(), path.c_str(), G_KEY_FILE_NONE, &error);
+                  if (error != nullptr)
+                  {
+                      auto perror = std::shared_ptr<GError>(error, g_error_free);
+                      throw std::runtime_error("Unable to find keyfile for '" + std::string(appid) + "' at '" + path +
+                                               "' because: " + perror.get()->message);
+                  }
+
+                  return keyfile;
+              }(),
+              snapDir,
+              registry,
+              false)
+        , interface_(interface)
+        , appId_(appid)
+    {
+    }
+
+    /** Return the xMirEnable value based on whether the interface is
+        in the list of interfaces using XMir */
+    XMirEnable xMirEnable() override
+    {
+        if (XMIR_INTERFACES.find(interface_) != XMIR_INTERFACES.end())
+        {
+            return XMirEnable::from_raw(true);
+        }
+        else
+        {
+            return XMirEnable::from_raw(false);
+        }
+    }
+
+    /** Return the xMirEnable value based on whether the interface is
+        in the list of interfaces supporting the lifecycle */
+    UbuntuLifecycle supportsUbuntuLifecycle() override
+    {
+        if (LIFECYCLE_INTERFACES.find(interface_) != LIFECYCLE_INTERFACES.end())
+        {
+            return UbuntuLifecycle::from_raw(true);
+        }
+        else
+        {
+            return UbuntuLifecycle::from_raw(false);
+        }
+    }
+
+    /** Figures out the exec line for a snappy command. We're not using
+        the Exec in the desktop file exactly, but assuming that it is kinda
+        what we want to be run. So we're replacing that with the script, which
+        we have to use as we can't get the command that is in the snap
+        metadata as Snapd won't give it to us. So we're parsing the Exec line
+        and replacing the first entry. Then putting it back together again. */
+    Exec execLine() override
+    {
+        std::string keyfile = _exec.value();
+        gchar** parsed = nullptr;
+        GError* error = nullptr;
+
+        g_shell_parse_argv(keyfile.c_str(), nullptr, &parsed, &error);
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to parse exec line: %s", keyfile.c_str());
+            return Exec::from_raw({});
+        }
+
+        if (g_strv_length(parsed) < 1)
+        {
+            g_warning("Parse resulted in a blank line");
+            g_strfreev(parsed);
+            return Exec::from_raw({});
+        }
+
+        /* Skip the first entry */
+        gchar** parsedpp = &(parsed[1]);
+
+        gchar* params = g_strjoinv(" ", parsedpp);
+        g_strfreev(parsed);
+
+        std::string binname;
+        if (appId_.package.value() == appId_.appname.value())
+        {
+            binname = appId_.package.value();
+        }
+        else
+        {
+            binname = appId_.package.value() + " " + appId_.appname.value();
+        }
+
+        binname = "/snap/bin/" + binname + " " + params;
+        g_free(params);
+
+        return Exec::from_raw(binname);
+    }
+};
+
+/************************
+ ** Snap implementation
+ ************************/
+
+/** Creates a Snap application object. Will throw exceptions if the AppID
+    doesn't resolve into a valid package or that package doesn't have a desktop
+    file that matches the app name.
+
+    \param appid Application ID of the snap
+    \param registry Registry to use for persistant connections
+    \param interface Primary interface that we found this snap for
+*/
+Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const std::string& interface)
+    : Base(registry)
+    , appid_(appid)
+    , interface_(interface)
+{
+    pkgInfo_ = registry->impl->snapdInfo.pkgInfo(appid.package);
+    if (!pkgInfo_)
+    {
+        throw std::runtime_error("Unable to get snap package info for AppID: " + std::string(appid));
+    }
+
+    if (pkgInfo_->revision != appid.version.value() ||
+        pkgInfo_->appnames.find(appid.appname) == pkgInfo_->appnames.end())
+    {
+        throw std::runtime_error("AppID does not match installed package for: " + std::string(appid));
+    }
+
+    info_ = std::make_shared<SnapInfo>(appid_, _registry, interface_, pkgInfo_->directory);
+}
+
+/** Uses the findInterface() function to find the interface if we don't
+    have one.
+
+    \param appid Application ID of the snap
+    \param registry Registry to use for persistant connections
+*/
+Snap::Snap(const AppID& appid, const std::shared_ptr<Registry>& registry)
+    : Snap(appid, registry, findInterface(appid, registry))
+{
+}
+
+/** Lists all the Snappy apps that are using one of our supported interfaces.
+    Also makes sure they're valid.
+
+    \param registry Registry to use for persistant connections
+*/
+std::list<std::shared_ptr<Application>> Snap::list(const std::shared_ptr<Registry>& registry)
+{
+    std::list<std::shared_ptr<Application>> apps;
+
+    for (auto interface : SUPPORTED_INTERFACES)
+    {
+        for (auto id : registry->impl->snapdInfo.appsForInterface(interface))
+        {
+            try
+            {
+                auto app = std::make_shared<Snap>(id, registry, interface);
+                apps.push_back(app);
+            }
+            catch (std::runtime_error& e)
+            {
+                g_warning("Unable to make Snap object for '%s': %s", std::string(id).c_str(), e.what());
+            }
+        }
+    }
+
+    return apps;
+}
+
+/** Returns the stored AppID */
+AppID Snap::appId()
+{
+    return appid_;
+}
+
+/** Asks Snapd for the interfaces to determine which one the application
+    can support.
+
+    \param appid Application ID of the snap
+    \param registry Registry to use for persistant connections
+*/
+std::string Snap::findInterface(const AppID& appid, const std::shared_ptr<Registry>& registry)
+{
+    auto ifaceset = registry->impl->snapdInfo.interfacesForAppId(appid);
+
+    for (auto interface : SUPPORTED_INTERFACES)
+    {
+        if (ifaceset.find(interface) != ifaceset.end())
+        {
+            return interface;
+        }
+    }
+
+    throw std::runtime_error("Interface not found for: " + std::string(appid));
+}
+
+/** Checks if an AppID could be a snap. Note it doesn't look for a desktop
+    file just the package, app and version.
+
+    \param appid Application ID of the snap
+    \param registry Registry to use for persistant connections
+*/
+bool Snap::hasAppId(const AppID& appId, const std::shared_ptr<Registry>& registry)
+{
+    try
+    {
+        auto pkginfo = registry->impl->snapdInfo.pkgInfo(appId.package);
+        if (!pkginfo)
+        {
+            return false;
+        }
+
+        return pkginfo->revision == appId.version.value() &&
+               pkginfo->appnames.find(appId.appname) != pkginfo->appnames.end();
+    }
+    catch (std::runtime_error& e)
+    {
+        return false;
+    }
+}
+
+/** Look to see if a package is a valid Snap package name
+
+    \param package Package name
+    \param registry Registry to use for persistant connections
+*/
+bool Snap::verifyPackage(const AppID::Package& package, const std::shared_ptr<Registry>& registry)
+{
+    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
+    return pkgInfo != nullptr;
+}
+
+/** Look to see if an appname is a valid for a Snap package
+
+    \param package Package name
+    \param appname Command name
+    \param registry Registry to use for persistant connections
+*/
+bool Snap::verifyAppname(const AppID::Package& package,
+                         const AppID::AppName& appname,
+                         const std::shared_ptr<Registry>& registry)
+{
+    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
+    return pkgInfo->appnames.find(appname) != pkgInfo->appnames.end();
+}
+
+/** Look for an application name on a Snap package based on a
+    wildcard type.
+
+    \param package Package name
+    \param card Wildcard to use for finding the appname
+    \param registry Registry to use for persistant connections
+*/
+AppID::AppName Snap::findAppname(const AppID::Package& package,
+                                 AppID::ApplicationWildcard card,
+                                 const std::shared_ptr<Registry>& registry)
+{
+    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
+
+    if (pkgInfo->appnames.size() == 0)
+    {
+        throw std::runtime_error("No apps in package '" + package.value() + "' to find");
+    }
+
+    switch (card)
+    {
+        case AppID::ApplicationWildcard::FIRST_LISTED:
+            return AppID::AppName::from_raw(*pkgInfo->appnames.begin());
+        case AppID::ApplicationWildcard::LAST_LISTED:
+            return AppID::AppName::from_raw(*pkgInfo->appnames.rbegin());
+        case AppID::ApplicationWildcard::ONLY_LISTED:
+            if (pkgInfo->appnames.size() != 1)
+            {
+                throw std::runtime_error("More than a single app in package '" + package.value() +
+                                         "' when requested to find only app");
+            }
+            return AppID::AppName::from_raw(*pkgInfo->appnames.begin());
+    }
+
+    throw std::logic_error("Got a value of the app wildcard enum that can't exist");
+}
+
+/** Look for a version of a Snap package
+
+    \param package Package name
+    \param appname Not used for snaps
+    \param registry Registry to use for persistant connections
+*/
+AppID::Version Snap::findVersion(const AppID::Package& package,
+                                 const AppID::AppName& appname,
+                                 const std::shared_ptr<Registry>& registry)
+{
+    auto pkgInfo = registry->impl->snapdInfo.pkgInfo(package);
+    return AppID::Version::from_raw(pkgInfo->revision);
+}
+
+/** Returns a reference to the info for the snap */
+std::shared_ptr<Application::Info> Snap::info()
+{
+    return info_;
+}
+
+/** Get all of the instances of this snap package that are running */
+std::vector<std::shared_ptr<Application::Instance>> Snap::instances()
+{
+    std::vector<std::shared_ptr<Instance>> vect;
+    auto startsWith = std::string(appId()) + "-";
+
+    for (auto instance : _registry->impl->upstartInstancesForJob("application-snap"))
+    {
+        g_debug("Looking at snap instance: %s", instance.c_str());
+        if (std::equal(startsWith.begin(), startsWith.end(), instance.begin()))
+        {
+            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-snap", instance,
+                                                                std::vector<Application::URL>{}, _registry));
+        }
+    }
+
+    g_debug("Snap app '%s' has %d instances", std::string(appId()).c_str(), int(vect.size()));
+
+    return vect;
+}
+
+/** Return the launch environment for this snap. That includes whether
+    or not it needs help from XMir (including Libertine helpers)
+*/
+std::list<std::pair<std::string, std::string>> Snap::launchEnv()
+{
+    g_debug("Getting snap specific environment");
+    std::list<std::pair<std::string, std::string>> retval;
+
+    retval.emplace_back(std::make_pair("APP_XMIR_ENABLE", info_->xMirEnable().value() ? "1" : "0"));
+    if (info_->xMirEnable())
+    {
+        /* If we're setting up XMir we also need the other helpers
+           that libertine is helping with */
+        /* retval.emplace_back(std::make_pair("APP_EXEC", "libertine-launch --no-container " +
+         * info_->execLine().value())); */
+        /* Not yet */
+        retval.emplace_back(std::make_pair("APP_EXEC", info_->execLine().value()));
+    }
+    else
+    {
+        retval.emplace_back(std::make_pair("APP_EXEC", info_->execLine().value()));
+    }
+
+    return retval;
+}
+
+/** Create a new instance of this Snap
+
+    \param urls URLs to pass to the command
+*/
+std::shared_ptr<Application::Instance> Snap::launch(const std::vector<Application::URL>& urls)
+{
+    g_debug("Launching a snap: %s", std::string(appId()).c_str());
+    return UpstartInstance::launch(appId(), "application-snap", std::string(appId()) + "-", urls, _registry,
+                                   UpstartInstance::launchMode::STANDARD, [this]() { return launchEnv(); });
+}
+
+/** Create a new instance of this Snap with a testing environment
+    setup for it.
+
+    \param urls URLs to pass to the command
+*/
+std::shared_ptr<Application::Instance> Snap::launchTest(const std::vector<Application::URL>& urls)
+{
+    return UpstartInstance::launch(appId(), "application-snap", std::string(appId()) + "-", urls, _registry,
+                                   UpstartInstance::launchMode::TEST, [this]() { return launchEnv(); });
+}
+
+}  // namespace app_impls
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/application-impl-snap.h'
--- libubuntu-app-launch/application-impl-snap.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/application-impl-snap.h	2016-08-03 18:41:53 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright © 2016 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 "application-impl-base.h"
+#include "application-info-desktop.h"
+#include "snapd-info.h"
+
+#pragma once
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace app_impls
+{
+
+/** Class implementing a Applications that are installed in the
+    system as Snaps. This class connects to snapd to get information
+    on the interfaces of the installed snaps and sees if any of them
+    are applicable to the user session. Currently that means if the
+    command has the unity8, unity7 or x11 interface.
+*/
+class Snap : public Base
+{
+public:
+    Snap(const AppID& appid, const std::shared_ptr<Registry>& registry);
+    Snap(const AppID& appid, const std::shared_ptr<Registry>& registry, const std::string& interface);
+
+    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry);
+
+    AppID appId() override;
+
+    std::shared_ptr<Info> info() override;
+
+    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;
+
+    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 of the Snap. Should be the name of the snap package.
+        The name of the command. And then the revision. */
+    AppID appid_;
+    /** The app's displayed information. Should be from a desktop
+        file that is put in ${SNAP_DIR}/meta/gui/${command}.desktop */
+    std::shared_ptr<app_info::Desktop> info_;
+    /** Which interface we thing we're coming from. Depends on how
+        we handle setting up the environment for the command. */
+    std::string interface_;
+    /** Information that we get from Snapd on the package */
+    std::shared_ptr<snapd::Info::PkgInfo> pkgInfo_;
+
+    std::list<std::pair<std::string, std::string>> launchEnv();
+    static std::string findInterface(const AppID& appid, const std::shared_ptr<Registry>& registry);
+};
+
+}  // namespace app_impls
+}  // namespace app_launch
+}  // namespace ubuntu

=== 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-03 18:41:53 +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-03 18:41:53 +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-03 18:41:52 +0000
+++ libubuntu-app-launch/application.cpp	2016-08-03 18:41:53 +0000
@@ -18,15 +18,17 @@
  */
 
 extern "C" {
-#include "app-info.h"
 #include "ubuntu-app-launch.h"
 }
 
 #include "application-impl-click.h"
 #include "application-impl-legacy.h"
 #include "application-impl-libertine.h"
+#include "application-impl-snap.h"
 #include "application.h"
+#include "registry.h"
 
+#include <functional>
 #include <iostream>
 #include <regex>
 
@@ -42,22 +44,25 @@
         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::Snap::hasAppId(appid, registry))
+    {
+        return std::make_shared<app_impls::Snap>(appid, registry);
+    }
+    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 +111,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 +126,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 +167,184 @@
            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},
+    /* Snap */
+    {app_impls::Snap::verifyPackage, app_impls::Snap::verifyAppname, app_impls::Snap::findAppname,
+     app_impls::Snap::findVersion, app_impls::Snap::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/glib-thread.h'
--- libubuntu-app-launch/glib-thread.h	2016-02-08 21:28:43 +0000
+++ libubuntu-app-launch/glib-thread.h	2016-08-03 18:41:53 +0000
@@ -17,11 +17,13 @@
  *   Ted Gould <[e-mail]>
  */
 
+#include <future>
 #include <thread>
-#include <future>
 
 #include <gio/gio.h>
 
+#pragma once
+
 namespace GLib
 {
 
@@ -33,14 +35,7 @@
     std::shared_ptr<GCancellable> _cancel;
 
 public:
-    ContextThread(std::function<void()> beforeLoop =
-                      []
-                  {
-                  },
-                  std::function<void()> afterLoop =
-                      []
-                  {
-                  });
+    ContextThread(std::function<void()> beforeLoop = [] {}, std::function<void()> afterLoop = [] {});
     ~ContextThread();
 
     void quit();
@@ -58,9 +53,15 @@
         }
 
         std::promise<T> promise;
-        std::function<void()> magicFunc = [&promise, &work]()
-        {
-            promise.set_value(work());
+        std::function<void()> magicFunc = [&promise, &work]() {
+            try
+            {
+                promise.set_value(work());
+            }
+            catch (...)
+            {
+                promise.set_exception(std::current_exception());
+            }
         };
 
         executeOnThread(magicFunc);

=== modified file 'libubuntu-app-launch/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2016-08-03 18:41:52 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2016-08-03 18:41:53 +0000
@@ -87,6 +87,7 @@
             }
         }
 
+        g_debug("Initialized Click DB");
         return true;
     });
 
@@ -96,19 +97,33 @@
     }
 }
 
+/** Helper function for printing JSON objects to debug output */
+std::string Registry::Impl::printJson(std::shared_ptr<JsonObject> jsonobj)
+{
+    auto node = json_node_alloc();
+    json_node_init_object(node, jsonobj.get());
+
+    auto snode = std::shared_ptr<JsonNode>(node, json_node_unref);
+    return printJson(snode);
+}
+
+/** Helper function for printing JSON nodes to debug output */
+std::string Registry::Impl::printJson(std::shared_ptr<JsonNode> jsonnode)
+{
+    auto gstr = json_to_string(jsonnode.get(), TRUE);
+    std::string retval = gstr;
+    g_free(gstr);
+
+    return retval;
+}
+
 std::shared_ptr<JsonObject> Registry::Impl::getClickManifest(const std::string& package)
 {
     initClick();
 
     auto retval = thread.executeOnThread<std::shared_ptr<JsonObject>>([this, package]() {
         GError* error = nullptr;
-        auto retval = std::shared_ptr<JsonObject>(click_user_get_manifest(_clickUser.get(), package.c_str(), &error),
-                                                  [](JsonObject* obj) {
-                                                      if (obj != nullptr)
-                                                      {
-                                                          json_object_unref(obj);
-                                                      }
-                                                  });
+        auto mani = click_user_get_manifest(_clickUser.get(), package.c_str(), &error);
 
         if (error != nullptr)
         {
@@ -116,6 +131,13 @@
             throw std::runtime_error(perror->message);
         }
 
+        auto node = json_node_alloc();
+        json_node_init_object(node, mani);
+
+        auto retval = std::shared_ptr<JsonObject>(json_node_dup_object(node), json_object_unref);
+
+        json_node_unref(node);
+
         return retval;
     });
 
@@ -131,7 +153,7 @@
 
     return thread.executeOnThread<std::list<AppID::Package>>([this]() {
         GError* error = nullptr;
-        GList* pkgs = click_db_get_packages(_clickDB.get(), FALSE, &error);
+        GList* pkgs = click_user_get_package_names(_clickUser.get(), &error);
 
         if (error != nullptr)
         {
@@ -142,7 +164,11 @@
         std::list<AppID::Package> list;
         for (GList* item = pkgs; item != NULL; item = g_list_next(item))
         {
-            list.emplace_back(AppID::Package::from_raw((gchar*)item->data));
+            auto pkgobj = reinterpret_cast<gchar*>(item->data);
+            if (pkgobj)
+            {
+                list.emplace_back(AppID::Package::from_raw(pkgobj));
+            }
         }
 
         g_list_free_full(pkgs, g_free);

=== modified file 'libubuntu-app-launch/registry-impl.h'
--- libubuntu-app-launch/registry-impl.h	2016-08-03 18:41:52 +0000
+++ libubuntu-app-launch/registry-impl.h	2016-08-03 18:41:53 +0000
@@ -19,6 +19,7 @@
 
 #include "glib-thread.h"
 #include "registry.h"
+#include "snapd-info.h"
 #include <click.h>
 #include <gio/gio.h>
 #include <json-glib/json-glib.h>
@@ -59,6 +60,7 @@
 
     GLib::ContextThread thread;
     std::shared_ptr<GDBusConnection> _dbus;
+    snapd::Info snapdInfo;
 
     std::shared_ptr<IconFinder> getIconFinder(std::string basePath);
 
@@ -70,6 +72,9 @@
     std::list<std::string> upstartInstancesForJob(const std::string& job);
     std::string upstartJobPath(const std::string& job);
 
+    static std::string printJson(std::shared_ptr<JsonObject> jsonobj);
+    static std::string printJson(std::shared_ptr<JsonNode> jsonnode);
+
 private:
     Registry* _registry;
 #if 0

=== modified file 'libubuntu-app-launch/registry.cpp'
--- libubuntu-app-launch/registry.cpp	2016-08-03 18:41:52 +0000
+++ libubuntu-app-launch/registry.cpp	2016-08-03 18:41:53 +0000
@@ -27,6 +27,7 @@
 #include "application-impl-click.h"
 #include "application-impl-legacy.h"
 #include "application-impl-libertine.h"
+#include "application-impl-snap.h"
 
 #include "helper-impl-click.h"
 
@@ -50,6 +51,8 @@
 
     /* Get all the legacy instances */
     instances.splice(instances.begin(), connection->impl->upstartInstancesForJob("application-legacy"));
+    /* Get all the snap instances */
+    instances.splice(instances.begin(), connection->impl->upstartInstancesForJob("application-snap"));
 
     /* Remove the instance ID */
     std::transform(instances.begin(), instances.end(), instances.begin(), [](std::string &instancename) -> std::string {
@@ -91,7 +94,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);
     }
@@ -106,6 +109,7 @@
     list.splice(list.begin(), app_impls::Click::list(connection));
     list.splice(list.begin(), app_impls::Legacy::list(connection));
     list.splice(list.begin(), app_impls::Libertine::list(connection));
+    list.splice(list.begin(), app_impls::Snap::list(connection));
 
     return list;
 }

=== modified file 'libubuntu-app-launch/second-exec-core.c'
--- libubuntu-app-launch/second-exec-core.c	2016-08-03 18:41:52 +0000
+++ libubuntu-app-launch/second-exec-core.c	2016-08-03 18:41:53 +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-03 18:41:52 +0000
+++ libubuntu-app-launch/second-exec-core.h	2016-08-03 18:41:53 +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
 

=== added file 'libubuntu-app-launch/snapd-info.cpp'
--- libubuntu-app-launch/snapd-info.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/snapd-info.cpp	2016-08-03 18:41:53 +0000
@@ -0,0 +1,430 @@
+/*
+ * Copyright © 2016 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 "snapd-info.h"
+
+#include "registry-impl.h"
+
+#include <curl/curl.h>
+#include <vector>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace snapd
+{
+
+/** Initializes the info object which mostly means checking what is overridden
+    by environment variables (mostly for testing) and making sure there is a
+    snapd socket available to us. */
+Info::Info()
+{
+    auto snapdEnv = g_getenv("UBUNTU_APP_LAUNCH_SNAPD_SOCKET");
+    if (G_UNLIKELY(snapdEnv != nullptr))
+    {
+        snapdSocket = snapdEnv;
+    }
+    else
+    {
+        snapdSocket = "/run/snapd.socket";
+    }
+
+    auto snapcBasedir = g_getenv("UBUNTU_APP_LAUNCH_SNAP_BASEDIR");
+    if (G_UNLIKELY(snapcBasedir != nullptr))
+    {
+        snapBasedir = snapcBasedir;
+    }
+    else
+    {
+        snapBasedir = "/snap";
+    }
+
+    if (g_file_test(snapdSocket.c_str(), G_FILE_TEST_EXISTS))
+    {
+        snapdExists = true;
+    }
+}
+
+/** Gets package information out of snapd by using the REST
+    interface and turning the JSON object into a C++ Struct
+
+    \param package Name of the package to look for
+*/
+std::shared_ptr<Info::PkgInfo> Info::pkgInfo(const AppID::Package &package) const
+{
+    if (!snapdExists)
+    {
+        return {};
+    }
+
+    try
+    {
+        auto snapnode = snapdJson("/v2/snaps/" + package.value());
+        auto snapobject = json_node_get_object(snapnode.get());
+        if (snapobject == nullptr)
+        {
+            throw std::runtime_error("Results returned by snapd were not a valid JSON object");
+        }
+
+        /******************************************/
+        /* Validation of the object we got        */
+        /******************************************/
+        for (auto member : {"name", "status", "revision", "type", "version", "apps"})
+        {
+            if (!json_object_has_member(snapobject, member))
+            {
+                throw std::runtime_error("Snap JSON didn't have a '" + std::string(member) + "'");
+            }
+        }
+
+        std::string namestr = json_object_get_string_member(snapobject, "name");
+        if (namestr != package.value())
+        {
+            throw std::runtime_error("Snapd returned information for snap '" + namestr + "' when we asked for '" +
+                                     package.value() + "'");
+        }
+
+        std::string statusstr = json_object_get_string_member(snapobject, "status");
+        if (statusstr != "active")
+        {
+            throw std::runtime_error("Snap is not in the 'active' state.");
+        }
+
+        std::string typestr = json_object_get_string_member(snapobject, "type");
+        if (typestr != "app")
+        {
+            throw std::runtime_error("Specified snap is not an application, we only support applications");
+        }
+
+        /******************************************/
+        /* Validation complete — build the object */
+        /******************************************/
+
+        auto pkgstruct = std::make_shared<PkgInfo>();
+        pkgstruct->name = namestr;
+        pkgstruct->version = json_object_get_string_member(snapobject, "version");
+        std::string revisionstr = json_object_get_string_member(snapobject, "revision");
+        pkgstruct->revision = revisionstr;
+
+        /* TODO: Seems like snapd should give this to us */
+        auto gdir = g_build_filename(snapBasedir.c_str(), namestr.c_str(), revisionstr.c_str(), nullptr);
+        pkgstruct->directory = gdir;
+        g_free(gdir);
+
+        auto appsarray = json_object_get_array_member(snapobject, "apps");
+        for (unsigned int i = 0; i < json_array_get_length(appsarray); i++)
+        {
+            auto appobj = json_array_get_object_element(appsarray, i);
+            if (json_object_has_member(appobj, "name"))
+            {
+                auto appname = json_object_get_string_member(appobj, "name");
+                if (appname)
+                {
+                    pkgstruct->appnames.insert(appname);
+                }
+            }
+        }
+
+        return pkgstruct;
+    }
+    catch (std::runtime_error &e)
+    {
+        g_warning("Unable to get snap information for '%s': %s", package.value().c_str(), e.what());
+        return {};
+    }
+}
+
+/** Function that acts as the return from cURL to add data to
+    our storage vector.
+
+    \param ptr incoming data
+    \param size block size
+    \param nmemb number of blocks
+    \param userdata our local vector to store things in
+*/
+static size_t snapd_writefunc(char *ptr, size_t size, size_t nmemb, void *userdata)
+{
+    unsigned int i;
+    std::vector<char> *data = static_cast<std::vector<char> *>(userdata);
+    data->reserve(data->size() + (size * nmemb)); /* allocate once */
+    for (i = 0; i < size * nmemb; i++)
+    {
+        data->push_back(ptr[i]);
+    }
+    return i;
+}
+
+/** Asks the snapd process for some JSON. This function parses the basic
+    response JSON that snapd returns and will error if a return code error
+    is in the JSON. It then passes on the "result" part of the response
+    to the caller.
+
+    \param endpoint End of the URL to pass to snapd
+*/
+std::shared_ptr<JsonNode> Info::snapdJson(const std::string &endpoint) const
+{
+    /* Setup the CURL connection and suck some data */
+    CURL *curl = curl_easy_init();
+    if (curl == nullptr)
+    {
+        throw std::runtime_error("Unable to create new cURL connection");
+    }
+
+    std::vector<char> data;
+
+    /* Configure the command */
+    // curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+    curl_easy_setopt(curl, CURLOPT_URL, ("http:" + endpoint).c_str());
+    curl_easy_setopt(curl, CURLOPT_UNIX_SOCKET_PATH, snapdSocket.c_str());
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, snapd_writefunc);
+
+    /* Overridable timeout */
+    if (g_getenv("UBUNTU_APP_LAUNCH_DISABLE_SNAPD_TIMEOUT") != nullptr)
+    {
+        curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 100L);
+    }
+
+    /* Run the actual request (blocking) */
+    auto res = curl_easy_perform(curl);
+
+    if (res != CURLE_OK)
+    {
+        curl_easy_cleanup(curl);
+        throw std::runtime_error("snapd HTTP server returned an error: " + std::string(curl_easy_strerror(res)));
+    }
+    else
+    {
+        g_debug("Got %d bytes from snapd", int(data.size()));
+    }
+
+    curl_easy_cleanup(curl);
+
+    /* Cool, we have data */
+    auto parser = std::shared_ptr<JsonParser>(json_parser_new(), [](JsonParser *parser) { g_clear_object(&parser); });
+    GError *error = nullptr;
+    json_parser_load_from_data(parser.get(), /* parser */
+                               data.data(),  /* array */
+                               data.size(),  /* size */
+                               &error);      /* error */
+
+    if (error != nullptr)
+    {
+        g_warning("Can not parse! %s", error->message);
+        g_error_free(error);
+        throw std::runtime_error("Can not parse JSON response");
+    }
+
+    auto root = json_parser_get_root(parser.get());
+    auto rootobj = json_node_get_object(root);
+
+    if (rootobj == nullptr)
+    {
+        throw std::runtime_error("Root of JSON result isn't an object");
+    }
+
+    /* Check members */
+    for (auto member : {"status", "status-code", "result", "type"})
+    {
+        if (!json_object_has_member(rootobj, member))
+        {
+            throw std::runtime_error("Resulting JSON didn't have a '" + std::string(member) + "'");
+        }
+    }
+
+    auto status = json_object_get_int_member(rootobj, "status-code");
+    if (status != 200)
+    {
+        throw std::runtime_error("Status code is: " + std::to_string(status));
+    }
+
+    std::string statusstr = json_object_get_string_member(rootobj, "status");
+    if (statusstr != "OK")
+    {
+        throw std::runtime_error("Status string is: " + statusstr);
+    }
+
+    std::string typestr = json_object_get_string_member(rootobj, "type");
+    if (typestr != "sync")
+    {
+        throw std::runtime_error("We only support 'sync' results right now, but we got a: " + typestr);
+    }
+
+    auto result = std::shared_ptr<JsonNode>(json_node_ref(json_object_get_member(rootobj, "result")), json_node_unref);
+
+    return result;
+}
+
+/** Looks through all the plugs in the interfaces and runs a function
+    based on them
+
+    \param plugfunc Function to execute on each plug
+*/
+void Info::forAllPlugs(std::function<void(JsonObject *plugobj)> plugfunc) const
+{
+    if (!snapdExists)
+    {
+        return;
+    }
+
+    auto interfacesnode = snapdJson("/v2/interfaces");
+    auto interface = json_node_get_object(interfacesnode.get());
+    if (interface == nullptr)
+    {
+        throw std::runtime_error("Interfaces result isn't an object: " + Registry::Impl::printJson(interfacesnode));
+    }
+
+    for (auto member : {"plugs", "slots"})
+    {
+        if (!json_object_has_member(interface, member))
+        {
+            throw std::runtime_error("Interface JSON didn't have a '" + std::string(member) + "'");
+        }
+    }
+
+    auto plugarray = json_object_get_array_member(interface, "plugs");
+    for (unsigned int i = 0; i < json_array_get_length(plugarray); i++)
+    {
+        auto ifaceobj = json_array_get_object_element(plugarray, i);
+        try
+        {
+            for (auto member : {"snap", "interface", "apps"})
+            {
+                if (!json_object_has_member(ifaceobj, member))
+                {
+                    throw std::runtime_error("Interface JSON didn't have a '" + std::string(member) + "'");
+                }
+            }
+
+            plugfunc(ifaceobj);
+        }
+        catch (std::runtime_error &e)
+        {
+            /* We'll check the others even if one is bad */
+            // g_debug("Malformed inteface instance: %s", e.what());
+            continue;
+        }
+    }
+}
+
+/** Gets all the apps that are available for a given interface. It asks snapd
+    for the list of interfaces and then finds this one, turning it into a set
+    of AppIDs
+
+    \param in_interface Which interface to get the set of apps for
+*/
+std::set<AppID> Info::appsForInterface(const std::string &in_interface) const
+{
+    bool interfacefound = false;
+    std::set<AppID> appids;
+
+    try
+    {
+        forAllPlugs([this, &interfacefound, &appids, in_interface](JsonObject *ifaceobj) {
+            std::string interfacename = json_object_get_string_member(ifaceobj, "interface");
+            if (interfacename != in_interface)
+            {
+                return;
+            }
+
+            interfacefound = true;
+
+            auto cname = json_object_get_string_member(ifaceobj, "snap");
+            if (cname == nullptr)
+            {
+                return;
+            }
+            std::string snapname(cname);
+
+            auto pkginfo = pkgInfo(AppID::Package::from_raw(snapname));
+            if (!pkginfo)
+            {
+                return;
+            }
+
+            std::string revision = pkginfo->revision;
+
+            auto apps = json_object_get_array_member(ifaceobj, "apps");
+            for (unsigned int k = 0; k < json_array_get_length(apps); k++)
+            {
+                std::string appname = json_array_get_string_element(apps, k);
+
+                appids.emplace(AppID(AppID::Package::from_raw(snapname),   /* package */
+                                     AppID::AppName::from_raw(appname),    /* appname */
+                                     AppID::Version::from_raw(revision))); /* version */
+            }
+        });
+
+        if (!interfacefound)
+        {
+            g_debug("Unable to find information on interface '%s'", in_interface.c_str());
+        }
+    }
+    catch (std::runtime_error &e)
+    {
+        g_warning("Unable to get interface information: %s", e.what());
+    }
+
+    return appids;
+}
+
+/** Finds all the interfaces for a specific appid
+
+    \param appid AppID to search for
+*/
+std::set<std::string> Info::interfacesForAppId(const AppID &appid) const
+{
+
+    std::set<std::string> interfaces;
+
+    try
+    {
+        forAllPlugs([&interfaces, appid](JsonObject *ifaceobj) {
+            std::string snapname = json_object_get_string_member(ifaceobj, "snap");
+            if (snapname != appid.package.value())
+            {
+                return;
+            }
+
+            std::string interfacename = json_object_get_string_member(ifaceobj, "interface");
+
+            auto apps = json_object_get_array_member(ifaceobj, "apps");
+            for (unsigned int k = 0; k < json_array_get_length(apps); k++)
+            {
+                std::string appname = json_array_get_string_element(apps, k);
+                if (appname == appid.appname.value())
+                {
+                    interfaces.insert(interfacename);
+                }
+            }
+        });
+    }
+    catch (std::runtime_error &e)
+    {
+        g_warning("Unable to get interface information: %s", e.what());
+    }
+
+    return interfaces;
+}
+
+}  // namespace snapd
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/snapd-info.h'
--- libubuntu-app-launch/snapd-info.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/snapd-info.h	2016-08-03 18:41:53 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright © 2016 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 <list>
+#include <memory>
+#include <set>
+
+#include <json-glib/json-glib.h>
+
+#include "appid.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace snapd
+{
+
+/** Class that implements the connection to Snapd allowing us to get info
+    from it in a C++ friendly way. */
+class Info
+{
+public:
+    Info();
+    virtual ~Info() = default;
+
+    /** Information that we can get from snapd about a package */
+    struct PkgInfo
+    {
+        std::string name;               /**< Name of the package */
+        std::string version;            /**< Version string provided by the package */
+        std::string revision;           /**< Numerical always incrementing revision of the package */
+        std::string directory;          /**< Directory that the snap is uncompressed into */
+        std::set<std::string> appnames; /**< List of appnames in the snap */
+    };
+    std::shared_ptr<PkgInfo> pkgInfo(const AppID::Package &package) const;
+
+    std::set<AppID> appsForInterface(const std::string &interface) const;
+
+    std::set<std::string> interfacesForAppId(const AppID &appid) const;
+
+private:
+    /** Path to the socket of snapd */
+    std::string snapdSocket;
+    /** Directory to use as the base for all snap packages when making paths. This
+        can be overridden with UBUNTU_APP_LAUNCH_SNAP_BASEDIR */
+    std::string snapBasedir;
+    /** Result of a check at init to see if the socket is available. If
+        not all functions will return null results. */
+    bool snapdExists = false;
+
+    std::shared_ptr<JsonNode> snapdJson(const std::string &endpoint) const;
+    void forAllPlugs(std::function<void(JsonObject *plugobj)> plugfunc) const;
+};
+
+}  // namespace snapd
+}  // namespace app_launch
+}  // namespace ubuntu

=== 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-03 18:41:53 +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-03 18:41:52 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.cpp	2016-08-03 18:41:53 +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;
 	}
 }
 
@@ -630,6 +315,9 @@
 		} else if (g_strcmp0(env, "JOB=application-legacy") == 0) {
 			job_found = TRUE;
 			job_legacy = TRUE;
+		} else if (g_strcmp0(env, "JOB=application-snap") == 0) {
+			job_found = TRUE;
+			job_legacy = TRUE;
 		} else if (g_str_has_prefix(env, "INSTANCE=")) {
 			instance = g_strdup(env + strlen("INSTANCE="));
 		}
@@ -1147,43 +835,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 +859,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 +875,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 +896,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 +947,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/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-08-03 18:41:52 +0000
+++ tests/CMakeLists.txt	2016-08-03 18:41:53 +0000
@@ -35,6 +35,7 @@
 add_definitions ( -DSOCKET_DEMANGLER="${CMAKE_BINARY_DIR}/socket-demangler" )
 add_definitions ( -DSOCKET_DEMANGLER_INSTALL="${pkglibexecdir}/socket-demangler" )
 add_definitions ( -DSOCKET_TOOL="${CMAKE_CURRENT_BINARY_DIR}/socket-tool" )
+add_definitions ( -DSNAP_BASEDIR="${CMAKE_CURRENT_SOURCE_DIR}/snap-basedir" )
 
 add_executable (libual-test
 	libual-test.cc
@@ -57,18 +58,27 @@
 add_test (NAME libual-test COMMAND libual-test)
 add_test (NAME libual-cpp-test COMMAND libual-cpp-test)
 
+# Snapd Info Test
+
+add_definitions ( -DSNAPD_TEST_SOCKET="/tmp/snapd-test-socket" )
+add_executable (snapd-info-test
+	snapd-info-test.cpp)
+target_link_libraries (snapd-info-test gtest ${GTEST_LIBS} launcher-static)
+add_test (NAME snapd-info-test COMMAND snapd-info-test)
+
+# List Apps
+
+add_executable (list-apps
+	list-apps.cpp)
+target_link_libraries (list-apps gtest ${GTEST_LIBS} launcher-static)
+add_test (NAME list-apps COMMAND ${CMAKE_CURRENT_BINARY_DIR}/list-apps)
+
 # Application Info Desktop
 
 add_executable (application-info-desktop-test
-  # test
   application-info-desktop.cpp
-
-  # sources
-  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/application-info-desktop.cpp
-  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/application-icon-finder.cpp
-  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/glib-thread.cpp
-  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/registry-impl.cpp)
-target_link_libraries (application-info-desktop-test gtest ${GTEST_LIBS} ubuntu-launcher)
+)
+target_link_libraries (application-info-desktop-test gtest ${GTEST_LIBS} launcher-static)
 
 add_test (NAME application-info-desktop-test COMMAND application-info-desktop-test)
 
@@ -139,5 +149,5 @@
 # Formatted code
 
 add_custom_target(format-tests
-	COMMAND clang-format -i -style=file libual-cpp-test.cc
+	COMMAND clang-format -i -style=file libual-cpp-test.cc snapd-mock.h snapd-info-test.cpp list-apps.cpp
 )

=== modified file 'tests/applications/foo.desktop'
--- tests/applications/foo.desktop	2013-09-24 03:01:51 +0000
+++ tests/applications/foo.desktop	2016-08-03 18:41:53 +0000
@@ -5,3 +5,4 @@
 NoDisplay=false
 Hidden=false
 Terminal=false
+Icon=foo.png

=== modified file 'tests/applications/multiple.desktop'
--- tests/applications/multiple.desktop	2013-12-12 03:08:11 +0000
+++ tests/applications/multiple.desktop	2016-08-03 18:41:53 +0000
@@ -5,4 +5,5 @@
 NoDisplay=false
 Hidden=false
 Terminal=false
+Icon=multiple.png
 X-Ubuntu-Single-Instance=false

=== modified file 'tests/applications/noxmir.desktop'
--- tests/applications/noxmir.desktop	2015-07-01 21:59:17 +0000
+++ tests/applications/noxmir.desktop	2016-08-03 18:41:53 +0000
@@ -6,3 +6,4 @@
 Hidden=false