Merge lp:~ted/ubuntu-app-launch/icon-basepath into lp:ubuntu-app-launch/16.10

[Ted Gould]

Set a base directory for icons that have a full path specified in their desktop file

[lp:~ted/ubuntu-app-launch/icon-basepath]

256. By Ted Gould on 2016-09-13

Switching to be a UAL variable

257. By Ted Gould on 2016-09-14

Merging with release branch

258. By Ted Gould on 2016-09-14

Fix a NULL

259. By Ted Gould on 2016-09-14

Clean up a TODO for the container path

260. By Ted Gould on 2016-09-14

Make it so that we use filename on full filenames even if we have a registry

261. By Ted Gould on 2016-09-14

Make sure that we are using a root that makes sense

Unmerged revisions

=== modified file 'debian/changelog'
--- debian/changelog	2016-09-14 15:32:39 +0000
+++ debian/changelog	2016-09-14 15:32:40 +0000
@@ -1,3 +1,16 @@
+ubuntu-app-launch (0.9+16.10.20160913.1-0ubuntu1) yakkety; urgency=medium
+
+  [ Larry Price ]
+  * Recursively sweep for desktop files for libertine applications.
+
+  [ Ted Gould ]
+  * Fixes, tools and tests related to listing applications
+  * Migrate starting and stopping applications to new classes
+  * Make find and discover use the application implementation functions.
+  * Support launching applications installed as snaps (LP: #1590445)
+
+ -- Ted Gould <[e-mail]>  Tue, 13 Sep 2016 17:43:33 +0000
+
 ubuntu-app-launch (0.9+16.10.20160902-0ubuntu1) yakkety; urgency=medium
 
   * Disable handshake wait with clients doing handshaking (LP: #1618540)
@@ -48,12 +61,6 @@
 
  -- Rodney Dawes <[e-mail]>  Wed, 03 Aug 2016 14:10:45 +0000
 
-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 'libubuntu-app-launch/application-impl-base.cpp'
--- libubuntu-app-launch/application-impl-base.cpp	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/application-impl-base.cpp	2016-09-14 15:32:40 +0000
@@ -739,7 +739,14 @@
             g_debug("Initializing params for an new UpstartInstance for: %s", appIdStr.c_str());
 
             tracepoint(ubuntu_app_launch, libual_start, appIdStr.c_str());
-            auto handshake = starting_handshake_start(appIdStr.c_str());
+
+            int timeout = 1;
+            if (ubuntu::app_launch::Registry::Impl::isWatchingAppStarting())
+            {
+                timeout = 0;
+            }
+
+            auto handshake = starting_handshake_start(appIdStr.c_str(), timeout);
             if (handshake == nullptr)
             {
                 g_warning("Unable to setup starting handshake");

=== modified file 'libubuntu-app-launch/application-impl-click.cpp'
--- libubuntu-app-launch/application-impl-click.cpp	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/application-impl-click.cpp	2016-09-14 15:32:40 +0000
@@ -171,7 +171,8 @@
 {
     if (!_info)
     {
-        _info = std::make_shared<app_info::Desktop>(_keyfile, _clickDir, app_info::DesktopFlags::NONE, nullptr);
+        _info =
+            std::make_shared<app_info::Desktop>(_keyfile, _clickDir, _clickDir, app_info::DesktopFlags::NONE, nullptr);
     }
 
     return _info;
@@ -228,25 +229,15 @@
                                                                      const std::string& app,
                                                                      const std::string& clickDir)
 {
-<<<<<<< TREE
-    JsonObject* hooks = nullptr;
-=======
     if (!manifest)
     {
         throw std::runtime_error("No manifest for package '" + package + "'");
     }
 
     JsonObject* hooks = nullptr;
->>>>>>> MERGE-SOURCE
     if (!json_object_has_member(manifest.get(), "hooks") ||
         (hooks = json_object_get_object_member(manifest.get(), "hooks")) == nullptr)
     {
-<<<<<<< TREE
-        throw std::runtime_error("Manifest for application '" + app + "' does not have a 'hooks' field");
-    }
-
-    JsonObject* hooklist = nullptr;
-=======
         throw std::runtime_error("Manifest for application '" + app + "' does not have a 'hooks' field: " +
                                  Registry::Impl::printJson(manifest));
     }
@@ -262,7 +253,6 @@
     }
 
     JsonObject* hooklist = nullptr;
->>>>>>> MERGE-SOURCE
     if (!json_object_has_member(hooks, app.c_str()) ||
         (hooklist = json_object_get_object_member(hooks, app.c_str())) == nullptr)
     {

=== modified file 'libubuntu-app-launch/application-impl-legacy.cpp'
--- libubuntu-app-launch/application-impl-legacy.cpp	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/application-impl-legacy.cpp	2016-09-14 15:32:40 +0000
@@ -54,8 +54,13 @@
 {
     std::tie(_basedir, _keyfile, desktopPath_) = keyfileForApp(appname);
 
-    appinfo_ =
-        std::make_shared<app_info::Desktop>(_keyfile, _basedir, app_info::DesktopFlags::ALLOW_NO_DISPLAY, _registry);
+    std::string rootDir = "";
+    auto rootenv = g_getenv("UBUNTU_APP_LAUNCH_LEGACY_ROOT");
+    if (rootenv != nullptr)
+        rootDir = rootenv;
+
+    appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, rootDir,
+                                                   app_info::DesktopFlags::ALLOW_NO_DISPLAY, _registry);
 
     if (!_keyfile)
     {

=== modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
--- libubuntu-app-launch/application-impl-libertine.cpp	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2016-09-14 15:32:40 +0000
@@ -27,7 +27,7 @@
 {
 namespace app_impls
 {
-    
+
 Libertine::Libertine(const AppID::Package& container,
                      const AppID::AppName& appname,
                      const std::shared_ptr<Registry>& registry)
@@ -35,13 +35,14 @@
     , _container(container)
     , _appname(appname)
 {
+    /** TODO: Handle nullptr */
+    _container_path = libertine_container_path(container.value().c_str());
+
     if (!_keyfile)
     {
-        auto container_path = libertine_container_path(container.value().c_str());
-        auto system_app_path = g_build_filename(container_path, "usr", "share", nullptr);
+        auto system_app_path = g_build_filename(_container_path.c_str(), "usr", "share", nullptr);
         _basedir = system_app_path;
         g_free(system_app_path);
-        g_free(container_path);
 
         _keyfile = findDesktopFile(_basedir, "applications", appname.value() + ".desktop");
     }
@@ -83,7 +84,9 @@
     return keyfile;
 }
 
-std::shared_ptr<GKeyFile> Libertine::findDesktopFile(const std::string& basepath, const std::string& subpath, const std::string& filename)
+std::shared_ptr<GKeyFile> Libertine::findDesktopFile(const std::string& basepath,
+                                                     const std::string& subpath,
+                                                     const std::string& filename)
 {
     auto fullpath = g_build_filename(basepath.c_str(), subpath.c_str(), filename.c_str(), nullptr);
     std::string sfullpath(fullpath);
@@ -97,7 +100,8 @@
     GError* error = nullptr;
     auto dirpath = g_build_filename(basepath.c_str(), subpath.c_str(), nullptr);
     GDir* dir = g_dir_open(dirpath, 0, &error);
-    if (error != NULL) {
+    if (error != NULL)
+    {
         g_error_free(error);
         g_free(dirpath);
         return {};
@@ -252,8 +256,8 @@
 {
     if (!appinfo_)
     {
-        appinfo_ =
-            std::make_shared<app_info::Desktop>(_keyfile, _basedir, app_info::DesktopFlags::XMIR_DEFAULT, _registry);
+        appinfo_ = std::make_shared<app_info::Desktop>(_keyfile, _basedir, _container_path,
+                                                       app_info::DesktopFlags::XMIR_DEFAULT, _registry);
     }
     return appinfo_;
 }

=== modified file 'libubuntu-app-launch/application-impl-libertine.h'
--- libubuntu-app-launch/application-impl-libertine.h	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/application-impl-libertine.h	2016-09-14 15:32:40 +0000
@@ -84,13 +84,16 @@
 private:
     AppID::Package _container;
     AppID::AppName _appname;
+    std::string _container_path;
     std::shared_ptr<GKeyFile> _keyfile;
     std::string _basedir;
     std::shared_ptr<app_info::Desktop> appinfo_;
 
     std::list<std::pair<std::string, std::string>> launchEnv();
     static std::shared_ptr<GKeyFile> keyfileFromPath(const std::string& pathname);
-    static std::shared_ptr<GKeyFile> findDesktopFile(const std::string& basepath, const std::string& subpath, const std::string& filename);
+    static std::shared_ptr<GKeyFile> findDesktopFile(const std::string& basepath,
+                                                     const std::string& subpath,
+                                                     const std::string& filename);
 };
 
 }  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-snap.cpp'
--- libubuntu-app-launch/application-impl-snap.cpp	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/application-impl-snap.cpp	2016-09-14 15:32:40 +0000
@@ -80,6 +80,7 @@
                   return keyfile;
               }(),
               snapDir,
+              snapDir,
               app_info::DesktopFlags::NONE,
               registry)
         , interface_(interface)

=== modified file 'libubuntu-app-launch/application-info-desktop.cpp'
--- libubuntu-app-launch/application-info-desktop.cpp	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/application-info-desktop.cpp	2016-09-14 15:32:40 +0000
@@ -67,7 +67,8 @@
 
 template <typename T>
 auto fileFromKeyfile(std::shared_ptr<GKeyFile> keyfile,
-                     const std::string basePath,
+                     const std::string& basePath,
+                     const std::string& rootDir,
                      const std::string& key,
                      const std::string& exceptionText = {}) -> T
 {
@@ -89,6 +90,14 @@
     if (keyval[0] == '/')
     {
         T retval = T::from_raw(keyval);
+
+        if (!rootDir.empty())
+        {
+            auto fullpath = g_build_filename(rootDir.c_str(), keyval, nullptr);
+            retval = T::from_raw(fullpath);
+            g_free(fullpath);
+        }
+
         g_free(keyval);
         return retval;
     }
@@ -187,6 +196,7 @@
 
 Desktop::Desktop(std::shared_ptr<GKeyFile> keyfile,
                  const std::string& basePath,
+                 const std::string& rootDir,
                  std::bitset<2> flags,
                  std::shared_ptr<Registry> registry)
     : _keyfile([keyfile, flags]() {
@@ -222,26 +232,28 @@
         return keyfile;
     }())
     , _basePath(basePath)
+    , _rootDir(rootDir)
     , _name(stringFromKeyfile<Application::Info::Name>(keyfile, "Name", "Unable to get name from keyfile"))
     , _description(stringFromKeyfile<Application::Info::Description>(keyfile, "Comment"))
-    , _iconPath([keyfile, basePath, registry]() {
+    , _iconPath([keyfile, basePath, rootDir, registry]() {
         if (registry != nullptr)
         {
             auto iconName =
                 stringFromKeyfile<Application::Info::IconPath>(keyfile, "Icon", "Missing icon for desktop file");
             return registry->impl->getIconFinder(basePath)->find(iconName);
         }
-        return fileFromKeyfile<Application::Info::IconPath>(keyfile, basePath, "Icon", "Missing icon for desktop file");
+        return fileFromKeyfile<Application::Info::IconPath>(keyfile, basePath, rootDir, "Icon",
+                                                            "Missing icon for desktop file");
     }())
     , _defaultDepartment(
           stringFromKeyfile<Application::Info::DefaultDepartment>(keyfile, "X-Ubuntu-Default-Department-ID"))
-    , _screenshotPath([keyfile, basePath]() {
-        return fileFromKeyfile<Application::Info::IconPath>(keyfile, basePath, "X-Screenshot");
+    , _screenshotPath([keyfile, basePath, rootDir]() {
+        return fileFromKeyfile<Application::Info::IconPath>(keyfile, basePath, rootDir, "X-Screenshot");
     }())
     , _keywords(stringlistFromKeyfile<Application::Info::Keywords>(keyfile, "Keywords"))
     , _splashInfo(
           {stringFromKeyfile<Application::Info::Splash::Title>(keyfile, "X-Ubuntu-Splash-Title"),
-           fileFromKeyfile<Application::Info::Splash::Image>(keyfile, basePath, "X-Ubuntu-Splash-Image"),
+           fileFromKeyfile<Application::Info::Splash::Image>(keyfile, basePath, rootDir, "X-Ubuntu-Splash-Image"),
            stringFromKeyfile<Application::Info::Splash::Color>(keyfile, "X-Ubuntu-Splash-Color"),
            stringFromKeyfile<Application::Info::Splash::Color>(keyfile, "X-Ubuntu-Splash-Color-Header"),
            stringFromKeyfile<Application::Info::Splash::Color>(keyfile, "X-Ubuntu-Splash-Color-Footer"),

=== modified file 'libubuntu-app-launch/application-info-desktop.h'
--- libubuntu-app-launch/application-info-desktop.h	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/application-info-desktop.h	2016-09-14 15:32:40 +0000
@@ -43,6 +43,7 @@
 public:
     Desktop(std::shared_ptr<GKeyFile> keyfile,
             const std::string& basePath,
+            const std::string& rootDir,
             std::bitset<2> flags,
             std::shared_ptr<Registry> registry);
 
@@ -108,6 +109,7 @@
 protected:
     std::shared_ptr<GKeyFile> _keyfile;
     std::string _basePath;
+    std::string _rootDir;
 
     Application::Info::Name _name;
     Application::Info::Description _description;

=== removed file 'libubuntu-app-launch/click-exec.c.THIS'
--- libubuntu-app-launch/click-exec.c.THIS	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/click-exec.c.THIS	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, int timeout_s)
-{
-	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, timeout_s);
-	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.THIS'
--- libubuntu-app-launch/click-exec.h.THIS	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/click-exec.h.THIS	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, int timeout_s);
-
-

=== removed file 'libubuntu-app-launch/desktop-exec.c.THIS'
--- libubuntu-app-launch/desktop-exec.c.THIS	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/desktop-exec.c.THIS	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, int timeout_s)
-{
-	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, timeout_s);
-	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.THIS'
--- libubuntu-app-launch/desktop-exec.h.THIS	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/desktop-exec.h.THIS	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, int timeout_s);
-

=== modified file 'libubuntu-app-launch/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2016-09-14 15:32:40 +0000
@@ -154,14 +154,7 @@
 
         auto retval = std::shared_ptr<JsonObject>(json_node_dup_object(node), json_object_unref);
 
-<<<<<<< TREE
-#if JSON_CHECK_VERSION(1, 1, 2)
-        // Not available in json-glib 1.0, so must leak there.
-        json_node_unref(node);
-#endif
-=======
         json_node_free(node);
->>>>>>> MERGE-SOURCE
 
         return retval;
     });

=== modified file 'libubuntu-app-launch/registry-impl.h'
--- libubuntu-app-launch/registry-impl.h	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/registry-impl.h	2016-09-14 15:32:40 +0000
@@ -79,18 +79,15 @@
     std::list<std::string> upstartInstancesForJob(const std::string& job);
     std::string upstartJobPath(const std::string& job);
 
-<<<<<<< TREE
+    static std::string printJson(std::shared_ptr<JsonObject> jsonobj);
+    static std::string printJson(std::shared_ptr<JsonNode> jsonnode);
+
     /* Signal Hints */
     /* NOTE: Static because we don't have registry instances in the C
        code right now. We want these to not be static in the future */
     static void watchingAppStarting(bool rWatching);
     static bool isWatchingAppStarting();
 
-=======
-    static std::string printJson(std::shared_ptr<JsonObject> jsonobj);
-    static std::string printJson(std::shared_ptr<JsonNode> jsonnode);
-
->>>>>>> MERGE-SOURCE
 private:
     Registry* _registry;
 #if 0

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.cpp'
--- libubuntu-app-launch/ubuntu-app-launch.cpp	2016-09-14 15:32:39 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.cpp	2016-09-14 15:32:40 +0000
@@ -110,187 +110,6 @@
 	return job_path;
 }
 
-<<<<<<< TREE
-/* 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"));
-	}
-
-	int timeout = 1;
-	if (ubuntu::app_launch::Registry::Impl::isWatchingAppStarting()) {
-		timeout = 0;
-	}
-
-	gboolean setup_complete = FALSE;
-	if (click) {
-		setup_complete = click_task_setup(con, appid, (EnvHandle*)&builder, timeout);
-	} else {
-		setup_complete = desktop_task_setup(con, appid, (EnvHandle*)&builder, libertine, timeout);
-	}
-
-	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;
-}
-
-=======
->>>>>>> MERGE-SOURCE
 gboolean
 ubuntu_app_launch_start_application (const gchar * appid, const gchar * const * uris)
 {

=== modified file 'tests/application-info-desktop.cpp'
--- tests/application-info-desktop.cpp	2016-09-14 15:32:39 +0000
+++ tests/application-info-desktop.cpp	2016-09-14 15:32:40 +0000
@@ -59,7 +59,7 @@
 
 TEST_F(ApplicationInfoDesktop, DefaultState)
 {
-    auto appinfo = ubuntu::app_launch::app_info::Desktop(defaultKeyfile(), "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr);
+    auto appinfo = ubuntu::app_launch::app_info::Desktop(defaultKeyfile(), "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr);
 
     EXPECT_EQ("Foo App", appinfo.name().value());
     EXPECT_EQ("", appinfo.description().value());
@@ -86,33 +86,33 @@
 TEST_F(ApplicationInfoDesktop, KeyfileErrors)
 {
     // empty
-    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop({}, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
+    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop({}, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
 
     // empty name
     auto noname = defaultKeyfile();
     g_key_file_remove_key(noname.get(), DESKTOP, "Name", nullptr);
-    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(noname, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
+    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(noname, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
 
     // empty icon
     auto noicon = defaultKeyfile();
     g_key_file_remove_key(noicon.get(), DESKTOP, "Icon", nullptr);
-    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(noicon, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
+    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(noicon, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
 
     // wrong type
     auto wrongtype = defaultKeyfile();
     g_key_file_set_string(wrongtype.get(), DESKTOP, "Type", "MimeType");
-    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(wrongtype, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
+    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(wrongtype, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
 
     // not displayable
     auto nodisplay = defaultKeyfile();
     g_key_file_set_boolean(nodisplay.get(), DESKTOP, "NoDisplay", TRUE);
-    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(nodisplay, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
-    EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(nodisplay, "/", ubuntu::app_launch::app_info::DesktopFlags::ALLOW_NO_DISPLAY, nullptr));
+    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(nodisplay, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
+    EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(nodisplay, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::ALLOW_NO_DISPLAY, nullptr));
 
     // hidden
     auto hidden = defaultKeyfile();
     g_key_file_set_string(hidden.get(), DESKTOP, "Hidden", "true");
-    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(hidden, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
+    EXPECT_THROW(ubuntu::app_launch::app_info::Desktop(hidden, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr), std::runtime_error);
 
     /* Disabling for OTA11 */
 #if 0
@@ -128,18 +128,33 @@
 #endif
 }
 
+TEST_F(ApplicationInfoDesktop, KeyfileIconPatterns)
+{
+    auto defkeyfile = defaultKeyfile();
+    std::string datadir = "/foo/usr/share";
+    std::string basedir = "/foo";
+
+    auto defappinfo = ubuntu::app_launch::app_info::Desktop(defkeyfile, datadir, basedir, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr);
+    EXPECT_EQ("/foo/usr/share/foo.png", defappinfo.iconPath().value());
+
+    auto rootkeyfile = defaultKeyfile();
+    g_key_file_set_string(rootkeyfile.get(), DESKTOP, "Icon", "/bar/foo.png");
+    auto rootappinfo = ubuntu::app_launch::app_info::Desktop(rootkeyfile, datadir, basedir, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr);
+    EXPECT_EQ("/foo/bar/foo.png", rootappinfo.iconPath().value());
+}
+
 TEST_F(ApplicationInfoDesktop, KeyfileDefaultDepartment)
 {
     auto keyfile = defaultKeyfile();
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Default-Department-ID", "foo");
-    EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr));
+    EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr));
 }
 
 TEST_F(ApplicationInfoDesktop, KeyfileScreenshotPath)
 {
     auto keyfile = defaultKeyfile();
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Screenshot", "foo.png");
-    EXPECT_EQ("/foo.png", ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).screenshotPath().value());
+    EXPECT_EQ("/foo.png", ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).screenshotPath().value());
 }
 
 TEST_F(ApplicationInfoDesktop, KeyfileKeywords)
@@ -148,7 +163,7 @@
 
     auto keyfile = defaultKeyfile();
     g_key_file_set_string(keyfile.get(), DESKTOP, "Keywords", "foo;bar;baz;");
-    EXPECT_EQ(expectedKeywords, ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).keywords().value());
+    EXPECT_EQ(expectedKeywords, ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).keywords().value());
 }
 
 TEST_F(ApplicationInfoDesktop, KeyfileShowListEdgeCases)
@@ -156,17 +171,17 @@
   // Not appearing in not show list
   auto notshowin = defaultKeyfile();
   g_key_file_set_string(notshowin.get(), DESKTOP, "NotShowIn", "Gnome;KDE;");
-  EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(notshowin, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr));
+  EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(notshowin, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr));
 
   // Appearing explicitly in only show list
   auto onlyshowin = defaultKeyfile();
   g_key_file_set_string(onlyshowin.get(), DESKTOP, "OnlyShowIn", (test_dekstop_env + ";Gnome;").c_str());
-  EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(onlyshowin, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr));
+  EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(onlyshowin, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr));
 
   // Appearing explicitly in only show list not first
   auto onlyshowinmiddle = defaultKeyfile();
   g_key_file_set_string(onlyshowinmiddle.get(), DESKTOP, "OnlyShowIn", ("Gnome;" + test_dekstop_env + ";KDE;").c_str());
-  EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(onlyshowinmiddle, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr));
+  EXPECT_NO_THROW(ubuntu::app_launch::app_info::Desktop(onlyshowinmiddle, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr));
 }
 
 TEST_F(ApplicationInfoDesktop, Orientations)
@@ -185,72 +200,72 @@
 
     auto keyfile = defaultKeyfile();
 
-    EXPECT_EQ(defaultOrientations, ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+    EXPECT_EQ(defaultOrientations, ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "this should not parse");
-    EXPECT_EQ(defaultOrientations, ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+    EXPECT_EQ(defaultOrientations, ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "this;should;not;parse;");
-    EXPECT_EQ(defaultOrientations, ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+    EXPECT_EQ(defaultOrientations, ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "portrait;");
     EXPECT_EQ((ubuntu::app_launch::Application::Info::Orientations {portrait: true, landscape: false, invertedPortrait: false, invertedLandscape: false}),
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "landscape;portrait;");
     EXPECT_EQ((ubuntu::app_launch::Application::Info::Orientations {portrait: true, landscape: true, invertedPortrait: false, invertedLandscape: false}),
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "landscape  ;  portrait;    invertedPortrait");
     EXPECT_EQ((ubuntu::app_launch::Application::Info::Orientations {portrait: true, landscape: true, invertedPortrait: true, invertedLandscape: false}),
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "portrait;landscape;");
     EXPECT_EQ((ubuntu::app_launch::Application::Info::Orientations {portrait: true, landscape: true, invertedPortrait: false, invertedLandscape: false}),
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "portrait;landscape;invertedportrait;invertedlandscape;");
     EXPECT_EQ((ubuntu::app_launch::Application::Info::Orientations {portrait: true, landscape: true, invertedPortrait: true, invertedLandscape: true}),
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "PORTRAIT;");
     EXPECT_EQ((ubuntu::app_launch::Application::Info::Orientations {portrait: true, landscape: false, invertedPortrait: false, invertedLandscape: false}),
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "pOrTraIt;lANDscApE;inVErtEDpORtrAit;iNVErtEDLAnDsCapE;");
     EXPECT_EQ((ubuntu::app_launch::Application::Info::Orientations {portrait: true, landscape: true, invertedPortrait: true, invertedLandscape: true}),
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "primary;");
     EXPECT_EQ((ubuntu::app_launch::Application::Info::Orientations {portrait: false, landscape: false, invertedPortrait: false, invertedLandscape: false}),
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 
     g_key_file_set_string(keyfile.get(), DESKTOP, "X-Ubuntu-Supported-Orientations", "foobar;primary;");
     EXPECT_EQ(defaultOrientations,
-              ubuntu::app_launch::app_info::Desktop(keyfile, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
+              ubuntu::app_launch::app_info::Desktop(keyfile, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).supportedOrientations());
 }
 
 TEST_F(ApplicationInfoDesktop, XMirCases)
 {
   auto xmirunset = defaultKeyfile();
   EXPECT_FALSE(
-              ubuntu::app_launch::app_info::Desktop(xmirunset, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).xMirEnable().value());
+              ubuntu::app_launch::app_info::Desktop(xmirunset, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).xMirEnable().value());
   EXPECT_TRUE(
-              ubuntu::app_launch::app_info::Desktop(xmirunset, "/", ubuntu::app_launch::app_info::DesktopFlags::XMIR_DEFAULT, nullptr).xMirEnable().value());
+              ubuntu::app_launch::app_info::Desktop(xmirunset, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::XMIR_DEFAULT, nullptr).xMirEnable().value());
 
   auto xmirtrue = defaultKeyfile();
   g_key_file_set_boolean(xmirtrue.get(), DESKTOP, "X-Ubuntu-XMir-Enable", TRUE);
   EXPECT_TRUE(
-              ubuntu::app_launch::app_info::Desktop(xmirtrue, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).xMirEnable().value());
+              ubuntu::app_launch::app_info::Desktop(xmirtrue, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).xMirEnable().value());
   EXPECT_TRUE(
-              ubuntu::app_launch::app_info::Desktop(xmirtrue, "/", ubuntu::app_launch::app_info::DesktopFlags::XMIR_DEFAULT, nullptr).xMirEnable().value());
+              ubuntu::app_launch::app_info::Desktop(xmirtrue, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::XMIR_DEFAULT, nullptr).xMirEnable().value());
 
   auto xmirfalse = defaultKeyfile();
   g_key_file_set_boolean(xmirfalse.get(), DESKTOP, "X-Ubuntu-XMir-Enable", FALSE);
   EXPECT_FALSE(
-              ubuntu::app_launch::app_info::Desktop(xmirfalse, "/", ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).xMirEnable().value());
+              ubuntu::app_launch::app_info::Desktop(xmirfalse, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::NONE, nullptr).xMirEnable().value());
   EXPECT_FALSE(
-              ubuntu::app_launch::app_info::Desktop(xmirfalse, "/", ubuntu::app_launch::app_info::DesktopFlags::XMIR_DEFAULT, nullptr).xMirEnable().value());
+              ubuntu::app_launch::app_info::Desktop(xmirfalse, "/", {}, ubuntu::app_launch::app_info::DesktopFlags::XMIR_DEFAULT, nullptr).xMirEnable().value());
 }
 
 } //anonymous namespace

=== modified file 'upstart-jobs/application-snap.conf.in'
--- upstart-jobs/application-snap.conf.in	2016-09-14 15:32:39 +0000
+++ upstart-jobs/application-snap.conf.in	2016-09-14 15:32:40 +0000
@@ -12,7 +12,7 @@
 env APP_DIR
 env APP_DESKTOP_FILE_PATH
 env APP_XMIR_ENABLE
-evn INSTANCE_ID=""
+env INSTANCE_ID=""
 
 env UBUNTU_APP_LAUNCH_ARCH="@ubuntu_app_launch_arch@"
 export UBUNTU_APP_LAUNCH_ARCH