Merge lp:~ted/ubuntu-app-launch/abstract-jobs into lp:ubuntu-app-launch/16.10

[Ted Gould]

Abstract out jobs backends and make Upstart one

[lp:~ted/ubuntu-app-launch/abstract-jobs]

272. By Ted Gould on 2016-10-27

Make sure to grab numeric header as well

273. By Ted Gould on 2016-11-07

Merge in the app object signals branch

274. By Ted Gould on 2016-11-11

Merging in app object changes

275. By Ted Gould on 2016-11-11

Merge fail

276. By Ted Gould on 2016-11-14

Updated tests

277. By Ted Gould on 2016-11-17

Merging through trunk

278. By Ted Gould on 2016-11-17

Migrate tests to use pause/resume c++ signals

279. By Ted Gould on 2017-01-11

Merging app signals branch

280. By Ted Gould on 2017-01-19

Update to trunk

Unmerged revisions

280. By Ted Gould on 2017-01-19

Update to trunk

279. By Ted Gould on 2017-01-11

Merging app signals branch

278. By Ted Gould on 2016-11-17

Migrate tests to use pause/resume c++ signals

277. By Ted Gould on 2016-11-17

Merging through trunk

276. By Ted Gould on 2016-11-14

Updated tests

275. By Ted Gould on 2016-11-11

Merge fail

274. By Ted Gould on 2016-11-11

Merging in app object changes

273. By Ted Gould on 2016-11-07

Merge in the app object signals branch

272. By Ted Gould on 2016-10-27

Make sure to grab numeric header as well

271. By Ted Gould on 2016-10-13

Merge trunk

=== modified file 'docs/index.rst'
--- docs/index.rst	2016-08-04 14:04:40 +0000
+++ docs/index.rst	2016-11-10 21:58:30 +0000
@@ -146,6 +146,46 @@
    :private-members:
    :undoc-members:
 
+Jobs Manager Base
+-----------------
+
+.. doxygenclass:: ubuntu::app_launch::jobs::manager::Base
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Jobs Instance Base
+------------------
+
+.. doxygenclass:: ubuntu::app_launch::jobs::instance::Base
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Jobs Manager Upstart
+--------------------
+
+.. doxygenclass:: ubuntu::app_launch::jobs::manager::Upstart
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
+Jobs Instance Upstart
+---------------------
+
+.. doxygenclass:: ubuntu::app_launch::jobs::instance::Upstart
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
 Registry Implementation
 -----------------------
 
@@ -176,16 +216,6 @@
    :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 'libubuntu-app-launch/CMakeLists.txt'
--- libubuntu-app-launch/CMakeLists.txt	2016-08-26 17:33:34 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2016-11-10 21:58:30 +0000
@@ -52,6 +52,10 @@
 helper-impl-click.cpp
 glib-thread.h
 glib-thread.cpp
+jobs-base.h
+jobs-base.cpp
+jobs-upstart.h
+jobs-upstart.cpp
 )
 
 set(LAUNCHER_SOURCES

=== modified file 'libubuntu-app-launch/application-impl-base.cpp'
--- libubuntu-app-launch/application-impl-base.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-base.cpp	2016-11-10 21:58:30 +0000
@@ -23,8 +23,6 @@
 #include <map>
 #include <numeric>
 
-#include <upstart.h>
-
 #include "application-impl-base.h"
 #include "helpers.h"
 #include "registry-impl.h"
@@ -97,770 +95,6 @@
     return retval;
 }
 
-/** Checks to see if we have a primary PID for the instance */
-bool UpstartInstance::isRunning()
-{
-    return primaryPid() != 0;
-}
-
-/** Uses Upstart to get the primary PID of the instance using Upstart's
-    DBus interface */
-pid_t UpstartInstance::primaryPid()
-{
-    auto jobpath = registry_->impl->upstartJobPath(job_);
-    if (jobpath.empty())
-    {
-        g_debug("Unable to get a valid job path");
-        return 0;
-    }
-
-    return registry_->impl->thread.executeOnThread<pid_t>([this, &jobpath]() -> pid_t {
-        GError* error = nullptr;
-
-        std::string instancename = std::string(appId_);
-        if (job_ != "application-click")
-        {
-            instancename += "-" + instance_;
-        }
-
-        g_debug("Getting instance by name: %s", instance_.c_str());
-        GVariant* vinstance_path =
-            g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                   /* connection */
-                                        DBUS_SERVICE_UPSTART,                           /* service */
-                                        jobpath.c_str(),                                /* object path */
-                                        DBUS_INTERFACE_UPSTART_JOB,                     /* iface */
-                                        "GetInstanceByName",                            /* method */
-                                        g_variant_new("(s)", instancename.c_str()),     /* params */
-                                        G_VARIANT_TYPE("(o)"),                          /* return type */
-                                        G_DBUS_CALL_FLAGS_NONE,                         /* flags */
-                                        -1,                                             /* timeout: default */
-                                        registry_->impl->thread.getCancellable().get(), /* cancellable */
-                                        &error);
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to get instance '%s' of job '%s': %s", instance_.c_str(), job_.c_str(), error->message);
-            g_error_free(error);
-            return 0;
-        }
-
-        /* Jump rope to make this into a C++ type */
-        std::string instance_path;
-        gchar* cinstance_path = nullptr;
-        g_variant_get(vinstance_path, "(o)", &cinstance_path);
-        g_variant_unref(vinstance_path);
-        if (cinstance_path != nullptr)
-        {
-            instance_path = cinstance_path;
-            g_free(cinstance_path);
-        }
-
-        if (instance_path.empty())
-        {
-            g_debug("No instance object for instance name: %s", instance_.c_str());
-            return 0;
-        }
-
-        GVariant* props_tuple =
-            g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                          /* connection */
-                                        DBUS_SERVICE_UPSTART,                                  /* service */
-                                        instance_path.c_str(),                                 /* object path */
-                                        "org.freedesktop.DBus.Properties",                     /* interface */
-                                        "GetAll",                                              /* method */
-                                        g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE), /* params */
-                                        G_VARIANT_TYPE("(a{sv})"),                             /* return type */
-                                        G_DBUS_CALL_FLAGS_NONE,                                /* flags */
-                                        -1,                                                    /* timeout: default */
-                                        registry_->impl->thread.getCancellable().get(),        /* cancellable */
-                                        &error);
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to name of properties '%s': %s", instance_path.c_str(), error->message);
-            g_error_free(error);
-            error = nullptr;
-            return 0;
-        }
-
-        GVariant* props_dict = g_variant_get_child_value(props_tuple, 0);
-
-        pid_t retval = 0;
-        GVariant* processes = g_variant_lookup_value(props_dict, "processes", G_VARIANT_TYPE("a(si)"));
-        if (processes != nullptr && g_variant_n_children(processes) > 0)
-        {
-
-            GVariant* first_entry = g_variant_get_child_value(processes, 0);
-            GVariant* pidv = g_variant_get_child_value(first_entry, 1);
-
-            retval = g_variant_get_int32(pidv);
-
-            g_variant_unref(pidv);
-            g_variant_unref(first_entry);
-        }
-        else
-        {
-            g_debug("Unable to get 'processes' from properties of instance at path: %s", instance_path.c_str());
-        }
-
-        g_variant_unref(props_dict);
-
-        return retval;
-    });
-}
-
-/** Generate the full name of the Upstart job for the job, the
-    instance and how all those fit together.
-
-    Handles the special case of application-click which isn't designed
-    to have multi-instance apps.
-*/
-std::string UpstartInstance::upstartJobPath()
-{
-    std::string path = job_ + "-" + std::string(appId_);
-    if (job_ != "application-click")
-    {
-        path += "-";
-    }
-    if (!instance_.empty())
-    {
-        path += instance_;
-    }
-
-    return path;
-}
-
-/** Looks at the PIDs in the instance cgroup and checks to see if @pid
-    is in the set.
-
-    @param pid PID to look for
-*/
-bool UpstartInstance::hasPid(pid_t pid)
-{
-    for (auto testpid : registry_->impl->pidsFromCgroup(upstartJobPath()))
-        if (pid == testpid)
-            return true;
-    return false;
-}
-
-/** Gets the path to the log file for this instance */
-std::string UpstartInstance::logPath()
-{
-    std::string logfile = upstartJobPath() + ".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;
-}
-
-/** Returns all the PIDs that are in the cgroup for this application */
-std::vector<pid_t> UpstartInstance::pids()
-{
-    auto pids = registry_->impl->pidsFromCgroup(upstartJobPath());
-    g_debug("Got %d PIDs for AppID '%s'", int(pids.size()), std::string(appId_).c_str());
-    return pids;
-}
-
-/** Pauses this application by sending SIGSTOP to all the PIDs in the
-    cgroup and tells Zeitgeist that we've left the application. */
-void UpstartInstance::pause()
-{
-    g_debug("Pausing application: %s", std::string(appId_).c_str());
-    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_LEAVE_EVENT);
-
-    auto pids = forAllPids([this](pid_t pid) {
-        auto oomval = oom::paused();
-        g_debug("Pausing PID: %d (%d)", pid, int(oomval));
-        signalToPid(pid, SIGSTOP);
-        oomValueToPid(pid, oomval);
-    });
-
-    pidListToDbus(pids, "ApplicationPaused");
-}
-
-/** Resumes this application by sending SIGCONT to all the PIDs in the
-    cgroup and tells Zeitgeist that we're accessing the application. */
-void UpstartInstance::resume()
-{
-    g_debug("Resuming application: %s", std::string(appId_).c_str());
-    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_ACCESS_EVENT);
-
-    auto pids = forAllPids([this](pid_t pid) {
-        auto oomval = oom::focused();
-        g_debug("Resuming PID: %d (%d)", pid, int(oomval));
-        signalToPid(pid, SIGCONT);
-        oomValueToPid(pid, oomval);
-    });
-
-    pidListToDbus(pids, "ApplicationResumed");
-}
-
-/** Stops this instance by asking Upstart to stop it. Upstart will then
-    send a SIGTERM and five seconds later start killing things. */
-void UpstartInstance::stop()
-{
-    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 = nullptr;
-            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 */
-                                            nullptr,                                        /* return */
-                                            G_DBUS_CALL_FLAGS_NONE,                         /* flags */
-                                            -1,                                             /* timeout: default */
-                                            registry_->impl->thread.getCancellable().get(), /* cancellable */
-                                            &error);                                        /* error (hopefully not) */
-
-            g_clear_pointer(&stop_variant, g_variant_unref);
-
-            if (error != nullptr)
-            {
-                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
-    the value to each of their files in proc
-
-    \param score OOM Score to set
-*/
-void UpstartInstance::setOomAdjustment(const oom::Score score)
-{
-    forAllPids([this, &score](pid_t pid) { oomValueToPid(pid, score); });
-}
-
-/** Figures out the path to the primary PID of the application and
-    then reads its OOM adjustment file. */
-const oom::Score UpstartInstance::getOomAdjustment()
-{
-    auto pid = primaryPid();
-    if (pid == 0)
-    {
-        throw std::runtime_error("No PID for application: " + std::string(appId_));
-    }
-
-    auto path = pidToOomPath(pid);
-    GError* error = nullptr;
-    gchar* content = nullptr;
-
-    g_file_get_contents(path.c_str(), /* path */
-                        &content,     /* data */
-                        nullptr,      /* size */
-                        &error);      /* error */
-
-    if (error != nullptr)
-    {
-        auto serror = std::shared_ptr<GError>(error, g_error_free);
-        throw std::runtime_error("Unable to access OOM value for '" + std::string(appId_) + "' primary PID '" +
-                                 std::to_string(pid) + "' because: " + serror->message);
-    }
-
-    auto score = static_cast<oom::Score>(std::atoi(content));
-    g_free(content);
-    return score;
-}
-
-/** Go through the list of PIDs calling a function and handling
-    the issue with getting PIDs being a racey condition.
-
-    \param eachPid Function to run on each PID
-*/
-std::vector<pid_t> UpstartInstance::forAllPids(std::function<void(pid_t)> eachPid)
-{
-    std::set<pid_t> seenPids;
-    bool added = true;
-
-    while (added)
-    {
-        added = false;
-        auto pidlist = pids();
-        for (auto pid : pidlist)
-        {
-            if (seenPids.insert(pid).second)
-            {
-                eachPid(pid);
-                added = true;
-            }
-        }
-    }
-
-    return std::vector<pid_t>(seenPids.begin(), seenPids.end());
-}
-
-/** Sends a signal to a PID with a warning if we can't send it.
-    We could throw an exception, but we can't handle it usefully anyway
-
-    \param pid PID to send the signal to
-    \param signal signal to send
-*/
-void UpstartInstance::signalToPid(pid_t pid, int signal)
-{
-    if (-1 == kill(pid, signal))
-    {
-        /* While that didn't work, we still want to try as many as we can */
-        g_warning("Unable to send signal %d to pid %d", signal, pid);
-    }
-}
-
-/** Get the path to the PID's OOM adjust path, with allowing for an
-    override for testing using the environment variable
-    UBUNTU_APP_LAUNCH_OOM_PROC_PATH
-
-    \param pid PID to build path for
-*/
-std::string UpstartInstance::pidToOomPath(pid_t pid)
-{
-    static std::string procpath;
-    if (G_UNLIKELY(procpath.empty()))
-    {
-        /* Set by the test suite, probably not anyone else */
-        auto envvar = g_getenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH");
-        if (G_LIKELY(envvar == nullptr))
-            procpath = "/proc";
-        else
-            procpath = envvar;
-    }
-
-    gchar* gpath = g_build_filename(procpath.c_str(), std::to_string(pid).c_str(), "oom_score_adj", nullptr);
-    std::string path = gpath;
-    g_free(gpath);
-    return path;
-}
-
-/** Writes an OOM value to proc, assuming we have a string
-    in the outer loop
-
-    \param pid PID to change the OOM value of
-    \param oomvalue OOM value to set
-*/
-void UpstartInstance::oomValueToPid(pid_t pid, const oom::Score oomvalue)
-{
-    auto oomstr = std::to_string(static_cast<std::int32_t>(oomvalue));
-    auto path = pidToOomPath(pid);
-    FILE* adj = fopen(path.c_str(), "w");
-    int openerr = errno;
-
-    if (adj == nullptr)
-    {
-        switch (openerr)
-        {
-            case ENOENT:
-                /* ENOENT happens a fair amount because of races, so it's not
-                   worth printing a warning about */
-                return;
-            case EACCES:
-            {
-                /* We can get this error when trying to set the OOM value on
-                   Oxide renderers because they're started by the sandbox and
-                   don't have their adjustment value available for us to write.
-                   We have a helper to deal with this, but it's kinda expensive
-                   so we only use it when we have to. */
-                oomValueToPidHelper(pid, oomvalue);
-                return;
-            }
-            default:
-                g_warning("Unable to set OOM value for '%d' to '%s': %s", int(pid), oomstr.c_str(),
-                          std::strerror(openerr));
-                return;
-        }
-    }
-
-    size_t writesize = fwrite(oomstr.c_str(), 1, oomstr.size(), adj);
-    int writeerr = errno;
-    fclose(adj);
-
-    if (writesize == oomstr.size())
-        return;
-
-    if (writeerr != 0)
-        g_warning("Unable to set OOM value for '%d' to '%s': %s", int(pid), oomstr.c_str(), strerror(writeerr));
-    else
-        /* No error, but yet, wrong size. Not sure, what could cause this. */
-        g_debug("Unable to set OOM value for '%d' to '%s': Wrote %d bytes", int(pid), oomstr.c_str(), int(writesize));
-}
-
-/** Use a setuid root helper for setting the oom value of
-    Chromium instances
-
-    \param pid PID to change the OOM value of
-    \param oomvalue OOM value to set
-*/
-void UpstartInstance::oomValueToPidHelper(pid_t pid, const oom::Score oomvalue)
-{
-    GError* error = nullptr;
-    std::string oomstr = std::to_string(static_cast<std::int32_t>(oomvalue));
-    std::string pidstr = std::to_string(pid);
-    std::array<const char*, 4> args = {OOM_HELPER, pidstr.c_str(), oomstr.c_str(), nullptr};
-
-    g_debug("Excuting OOM Helper (pid: %d, score: %d): %s", int(pid), int(oomvalue),
-            std::accumulate(args.begin(), args.end(), std::string{},
-                            [](const std::string& instr, const char* output) -> std::string {
-                                if (instr.empty())
-                                {
-                                    return output;
-                                }
-                                else if (output != nullptr)
-                                {
-                                    return instr + " " + std::string(output);
-                                }
-                                else
-                                {
-                                    return instr;
-                                }
-                            })
-                .c_str());
-
-    g_spawn_async(nullptr,               /* working dir */
-                  (char**)(args.data()), /* args */
-                  nullptr,               /* env */
-                  G_SPAWN_DEFAULT,       /* flags */
-                  nullptr,               /* child setup */
-                  nullptr,               /* child setup userdata*/
-                  nullptr,               /* pid */
-                  &error);               /* error */
-
-    if (error != nullptr)
-    {
-        g_warning("Unable to launch OOM helper '" OOM_HELPER "' on PID '%d': %s", pid, error->message);
-        g_error_free(error);
-        return;
-    }
-}
-
-/** Send a signal that we've change the application. Do this on the
-    registry thread in an idle so that we don't block anyone.
-
-    \param pids List of PIDs to turn into variants to send
-    \param signal Name of the DBus signal to send
-*/
-void UpstartInstance::pidListToDbus(const std::vector<pid_t>& pids, const std::string& signal)
-{
-    auto registry = registry_;
-    auto lappid = appId_;
-
-    registry_->impl->thread.executeOnThread([registry, lappid, pids, signal] {
-        auto vpids = std::shared_ptr<GVariant>(
-            [pids]() {
-                GVariant* pidarray = nullptr;
-
-                if (pids.empty())
-                {
-                    pidarray = g_variant_new_array(G_VARIANT_TYPE_UINT64, nullptr, 0);
-                    g_variant_ref_sink(pidarray);
-                    return pidarray;
-                }
-
-                GVariantBuilder builder;
-                g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
-                for (auto pid : pids)
-                {
-                    g_variant_builder_add_value(&builder, g_variant_new_uint64(pid));
-                }
-
-                pidarray = g_variant_builder_end(&builder);
-                g_variant_ref_sink(pidarray);
-                return pidarray;
-            }(),
-            [](GVariant* var) { g_variant_unref(var); });
-
-        GVariantBuilder params;
-        g_variant_builder_init(&params, G_VARIANT_TYPE_TUPLE);
-        g_variant_builder_add_value(&params, g_variant_new_string(std::string(lappid).c_str()));
-        g_variant_builder_add_value(&params, vpids.get());
-
-        GError* error = nullptr;
-        g_dbus_connection_emit_signal(registry->impl->_dbus.get(),     /* bus */
-                                      nullptr,                         /* destination */
-                                      "/",                             /* path */
-                                      "com.canonical.UbuntuAppLaunch", /* interface */
-                                      signal.c_str(),                  /* signal */
-                                      g_variant_builder_end(&params),  /* params, the same */
-                                      &error);                         /* error */
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to emit signal '%s' for appid '%s': %s", signal.c_str(), std::string(lappid).c_str(),
-                      error->message);
-            g_error_free(error);
-        }
-        else
-        {
-            g_debug("Emmitted '%s' to DBus", signal.c_str());
-        }
-    });
-}
-
-/** Create a new Upstart Instance object that can track the job and
-    get information about it.
-
-    \param appId Application ID
-    \param job Upstart job name
-    \param instance Upstart instance name
-    \param urls URLs sent to the application (only on launch today)
-    \param registry Registry of persistent connections to use
-*/
-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());
-}
-
-/** Reformat a C++ vector of URLs into a C GStrv of strings
-
-    \param urls Vector of URLs to make into C strings
-*/
-std::shared_ptr<gchar*> UpstartInstance::urlsToStrv(const std::vector<Application::URL>& urls)
-{
-    if (urls.empty())
-    {
-        return {};
-    }
-
-    auto array = g_array_new(TRUE, FALSE, sizeof(gchar*));
-
-    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);
-}
-
-/** 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.
-
-    \param obj The GDBusConnection object
-    \param res Async result object
-    \param user_data A pointer to a StartCHelper structure
-*/
-void UpstartInstance::application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data)
-{
-    auto data = static_cast<StartCHelper*>(user_data);
-    GError* error{nullptr};
-    GVariant* result{nullptr};
-
-    tracepoint(ubuntu_app_launch, libual_start_message_callback, std::string(data->ptr->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);
-
-    g_clear_pointer(&result, g_variant_unref);
-
-    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;
-}
-
-/** Launch an application and create a new UpstartInstance object to track
-    its progress.
-
-    \param appId Application ID
-    \param job Upstart job name
-    \param instance Upstart instance name
-    \param urls URLs sent to the application (only on launch today)
-    \param registry Registry of persistent connections to use
-    \param mode Whether or not to setup the environment for testing
-    \param getenv A function to get additional environment variable when appropriate
-*/
-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 registry->impl->thread.executeOnThread<std::shared_ptr<UpstartInstance>>(
-        [&]() -> std::shared_ptr<UpstartInstance> {
-            std::string appIdStr{appId};
-            g_debug("Initializing params for an new UpstartInstance for: %s", appIdStr.c_str());
-
-            tracepoint(ubuntu_app_launch, libual_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");
-            }
-
-            /* Figure out the DBus path for the job */
-            auto jobpath = registry->impl->upstartJobPath(job);
-
-            /* Build up our environment */
-            auto env = getenv();
-
-            env.emplace_back(std::make_pair("APP_ID", appIdStr));                           /* Application ID */
-            env.emplace_back(std::make_pair("APP_LAUNCHER_PID", std::to_string(getpid()))); /* Who we are, for bugs */
-
-            if (!urls.empty())
-            {
-                auto accumfunc = [](const std::string& prev, Application::URL thisurl) -> std::string {
-                    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;
-                    }
-                };
-                auto urlstring = std::accumulate(urls.begin(), urls.end(), std::string{}, accumfunc);
-                env.emplace_back(std::make_pair("APP_URIS", urlstring));
-            }
-
-            if (mode == launchMode::TEST)
-            {
-                env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
-            }
-
-            /* Convert to GVariant */
-            GVariantBuilder builder;
-            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
-
-            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
-
-            for (const 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;
-
-            tracepoint(ubuntu_app_launch, handshake_wait, appIdStr.c_str());
-            starting_handshake_wait(handshake);
-            tracepoint(ubuntu_app_launch, handshake_complete, appIdStr.c_str());
-
-            /* Call the job start function */
-            g_debug("Asking Upstart to start task for: %s", appIdStr.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 */
-                                   nullptr,                                       /* return */
-                                   G_DBUS_CALL_FLAGS_NONE,                        /* flags */
-                                   -1,                                            /* default timeout */
-                                   registry->impl->thread.getCancellable().get(), /* cancellable */
-                                   application_start_cb,                          /* callback */
-                                   chelper                                        /* object */
-                                   );
-
-            tracepoint(ubuntu_app_launch, libual_start_message_sent, appIdStr.c_str());
-
-            return retval;
-        });
-}
-
 }  // namespace app_impls
 }  // namespace app_launch
 }  // namespace ubuntu

=== modified file 'libubuntu-app-launch/application-impl-base.h'
--- libubuntu-app-launch/application-impl-base.h	2016-09-23 22:30:51 +0000
+++ libubuntu-app-launch/application-impl-base.h	2016-11-10 21:58:30 +0000
@@ -51,75 +51,6 @@
                                                                       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 */
-    bool isRunning() override;
-    pid_t primaryPid() override;
-    bool hasPid(pid_t pid) override;
-    std::string logPath() override;
-    std::vector<pid_t> pids() override;
-
-    /* Manage lifecycle */
-    void pause() override;
-    void resume() override;
-    void stop() override;
-
-    /* OOM Functions */
-    void setOomAdjustment(const oom::Score score) override;
-    const oom::Score getOomAdjustment() override;
-
-    /** Flag for whether we should include the testing environment variables */
-    enum class launchMode
-    {
-        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,
-        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);
-    void signalToPid(pid_t pid, int signal);
-    std::string pidToOomPath(pid_t pid);
-    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);
-    std::string upstartJobPath();
-
-    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
 }  // namespace app_launch
 }  // namespace ubuntu

=== modified file 'libubuntu-app-launch/application-impl-click.cpp'
--- libubuntu-app-launch/application-impl-click.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-click.cpp	2016-11-10 21:58:30 +0000
@@ -323,21 +323,8 @@
 
 std::vector<std::shared_ptr<Application::Instance>> Click::instances()
 {
-    std::vector<std::shared_ptr<Instance>> vect;
-    std::string sappid = appId();
-
-    for (auto instancename : _registry->impl->upstartInstancesForJob("application-click"))
-    {
-        /* There an be only one, but we want to make sure it is
-           there or return an empty vector */
-        if (sappid == instancename)
-        {
-            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-click", std::string{},
-                                                                std::vector<Application::URL>{}, _registry));
-            break;
-        }
-    }
-    return vect;
+    auto vbase = _registry->impl->jobs->instances(appId(), "application-click");
+    return std::vector<std::shared_ptr<Application::Instance>>(vbase.begin(), vbase.end());
 }
 
 /** Grabs all the environment variables for the application to
@@ -361,15 +348,15 @@
 std::shared_ptr<Application::Instance> Click::launch(const std::vector<Application::URL>& urls)
 {
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appId(), "application-click", {}, urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-click", {}, urls, jobs::manager::launchMode::STANDARD,
+                                         envfunc);
 }
 
 std::shared_ptr<Application::Instance> Click::launchTest(const std::vector<Application::URL>& urls)
 {
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appId(), "application-click", {}, urls, _registry, UpstartInstance::launchMode::TEST,
-                                   envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-click", {}, urls, jobs::manager::launchMode::TEST,
+                                         envfunc);
 }
 
 }  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-legacy.cpp'
--- libubuntu-app-launch/application-impl-legacy.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-legacy.cpp	2016-11-10 21:58:30 +0000
@@ -33,9 +33,6 @@
 /** Path that snapd puts desktop files, we don't want to read those directly
     in the Legacy backend. We want to use the snap backend. */
 const std::string snappyDesktopPath{"/var/lib/snapd"};
-/** Special characters that could be an application name that
-    would activate in a regex */
-const static std::regex regexCharacters("([\\.\\-])");
 
 /***********************************
    Prototypes
@@ -77,14 +74,6 @@
     {
         throw std::runtime_error{"Looking like a legacy app, but should be a Snap: " + appname.value()};
     }
-
-    /* Build a regex that'll match instances of the applications which
-       roughly looks like: $(appid)-2345345
-
-       It is important to filter out the special characters that are in
-       the appid.
-    */
-    instanceRegex_ = std::regex("^(?:" + std::regex_replace(_appname.value(), regexCharacters, "\\$&") + ")\\-(\\d*)$");
 }
 
 std::tuple<std::string, std::shared_ptr<GKeyFile>, std::string> keyfileForApp(const AppID::AppName& name)
@@ -291,23 +280,8 @@
 
 std::vector<std::shared_ptr<Application::Instance>> Legacy::instances()
 {
-    std::vector<std::shared_ptr<Instance>> vect;
-    auto startsWith = std::string(appId()) + "-";
-
-    for (auto instance : _registry->impl->upstartInstancesForJob("application-legacy"))
-    {
-        std::smatch instanceMatch;
-        g_debug("Looking at legacy instance: %s", instance.c_str());
-        if (std::regex_match(instance, instanceMatch, instanceRegex_))
-        {
-            vect.emplace_back(std::make_shared<UpstartInstance>(appId(), "application-legacy", instanceMatch[1].str(),
-                                                                std::vector<Application::URL>{}, _registry));
-        }
-    }
-
-    g_debug("Legacy app '%s' has %d instances", std::string(appId()).c_str(), int(vect.size()));
-
-    return vect;
+    auto vbase = _registry->impl->jobs->instances(appId(), "application-legacy");
+    return std::vector<std::shared_ptr<Application::Instance>>(vbase.begin(), vbase.end());
 }
 
 /** Grabs all the environment for a legacy app. Mostly this consists of
@@ -394,8 +368,8 @@
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this, instance]() {
         return launchEnv(instance);
     };
-    return UpstartInstance::launch(appId(), "application-legacy", instance, urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-legacy", instance, urls,
+                                         jobs::manager::launchMode::STANDARD, envfunc);
 }
 
 /** Create an UpstartInstance for this AppID using the UpstartInstance launch
@@ -409,8 +383,8 @@
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this, instance]() {
         return launchEnv(instance);
     };
-    return UpstartInstance::launch(appId(), "application-legacy", instance, urls, _registry,
-                                   UpstartInstance::launchMode::TEST, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-legacy", instance, urls, jobs::manager::launchMode::TEST,
+                                         envfunc);
 }
 
 }  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
--- libubuntu-app-launch/application-impl-libertine.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2016-11-10 21:58:30 +0000
@@ -255,8 +255,7 @@
             }
             catch (std::runtime_error& e)
             {
-                g_debug("Unable to create application for libertine appname '%s': %s",
-                        apps.get()[j], e.what());
+                g_debug("Unable to create application for libertine appname '%s': %s", apps.get()[j], e.what());
             }
         }
     }
@@ -276,17 +275,8 @@
 
 std::vector<std::shared_ptr<Application::Instance>> Libertine::instances()
 {
-    std::vector<std::shared_ptr<Instance>> vect;
-    std::string sappid = appId();
-
-    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", std::string{},
-                                                                std::vector<Application::URL>{}, _registry));
-    }
-
-    return vect;
+    auto vbase = _registry->impl->jobs->instances(appId(), "application-legacy");
+    return std::vector<std::shared_ptr<Application::Instance>>(vbase.begin(), vbase.end());
 }
 
 /** Grabs all the environment variables for the application to
@@ -328,15 +318,15 @@
 std::shared_ptr<Application::Instance> Libertine::launch(const std::vector<Application::URL>& urls)
 {
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appId(), "application-legacy", {}, urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-legacy", {}, urls, jobs::manager::launchMode::STANDARD,
+                                         envfunc);
 }
 
 std::shared_ptr<Application::Instance> Libertine::launchTest(const std::vector<Application::URL>& urls)
 {
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appId(), "application-legacy", {}, urls, _registry,
-                                   UpstartInstance::launchMode::TEST, envfunc);
+    return _registry->impl->jobs->launch(appId(), "application-legacy", {}, urls, jobs::manager::launchMode::TEST,
+                                         envfunc);
 }
 
 }  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-snap.cpp'
--- libubuntu-app-launch/application-impl-snap.cpp	2016-10-03 23:54:20 +0000
+++ libubuntu-app-launch/application-impl-snap.cpp	2016-11-10 21:58:30 +0000
@@ -396,19 +396,8 @@
 /** 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 (const auto& instance : _registry->impl->upstartInstancesForJob("application-snap"))
-    {
-        if (std::equal(startsWith.begin(), startsWith.end(), instance.begin()))
-        {
-            vect.emplace_back(std::make_shared<UpstartInstance>(appid_, "application-snap", std::string{},
-                                                                std::vector<Application::URL>{}, _registry));
-        }
-    }
-
-    return vect;
+    auto vbase = _registry->impl->jobs->instances(appId(), "application-snap");
+    return std::vector<std::shared_ptr<Application::Instance>>(vbase.begin(), vbase.end());
 }
 
 /** Return the launch environment for this snap. That includes whether
@@ -448,8 +437,8 @@
 std::shared_ptr<Application::Instance> Snap::launch(const std::vector<Application::URL>& urls)
 {
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appid_, "application-snap", {}, urls, _registry,
-                                   UpstartInstance::launchMode::STANDARD, envfunc);
+    return _registry->impl->jobs->launch(appid_, "application-snap", {}, urls, jobs::manager::launchMode::STANDARD,
+                                         envfunc);
 }
 
 /** Create a new instance of this Snap with a testing environment
@@ -460,8 +449,8 @@
 std::shared_ptr<Application::Instance> Snap::launchTest(const std::vector<Application::URL>& urls)
 {
     std::function<std::list<std::pair<std::string, std::string>>(void)> envfunc = [this]() { return launchEnv(); };
-    return UpstartInstance::launch(appid_, "application-snap", {}, urls, _registry, UpstartInstance::launchMode::TEST,
-                                   envfunc);
+    return _registry->impl->jobs->launch(appid_, "application-snap", {}, urls, jobs::manager::launchMode::TEST,
+                                         envfunc);
 }
 
 }  // namespace app_impls

=== modified file 'libubuntu-app-launch/application.cpp'
--- libubuntu-app-launch/application.cpp	2016-08-26 17:33:34 +0000
+++ libubuntu-app-launch/application.cpp	2016-11-10 21:58:30 +0000
@@ -28,6 +28,8 @@
 #include "application-impl-snap.h"
 #endif
 #include "application.h"
+#include "jobs-base.h"
+#include "registry-impl.h"
 #include "registry.h"
 
 #include <functional>
@@ -46,6 +48,11 @@
         throw std::runtime_error("AppID is empty");
     }
 
+    if (!registry->impl->jobs)
+    {
+        registry->impl->jobs = jobs::manager::Base::determineFactory(registry);
+    }
+
     if (app_impls::Click::hasAppId(appid, registry))
     {
         return std::make_shared<app_impls::Click>(appid, registry);

=== added file 'libubuntu-app-launch/jobs-base.cpp'
--- libubuntu-app-launch/jobs-base.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-base.cpp	2016-11-10 21:58:30 +0000
@@ -0,0 +1,392 @@
+/*
+ * 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 <algorithm>
+#include <cerrno>
+#include <cstring>
+#include <numeric>
+
+#include "jobs-base.h"
+#include "jobs-upstart.h"
+#include "registry-impl.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace manager
+{
+
+Base::Base(const std::shared_ptr<Registry>& registry)
+    : registry_(registry)
+{
+}
+
+std::shared_ptr<Base> Base::determineFactory(std::shared_ptr<Registry> registry)
+{
+    return std::make_shared<jobs::manager::Upstart>(registry);
+}
+
+}  // namespace manager
+
+namespace instance
+{
+
+Base::Base(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)
+{
+}
+
+/** Checks to see if we have a primary PID for the instance */
+bool Base::isRunning()
+{
+    return primaryPid() != 0;
+}
+
+/** Looks at the PIDs in the instance cgroup and checks to see if @pid
+    is in the set.
+
+    @param pid PID to look for
+*/
+bool Base::hasPid(pid_t pid)
+{
+    auto vpids = pids();
+    return std::find(vpids.begin(), vpids.end(), pid) != vpids.end();
+}
+
+/** Pauses this application by sending SIGSTOP to all the PIDs in the
+    cgroup and tells Zeitgeist that we've left the application. */
+void Base::pause()
+{
+    g_debug("Pausing application: %s", std::string(appId_).c_str());
+    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_LEAVE_EVENT);
+
+    auto pids = forAllPids([this](pid_t pid) {
+        auto oomval = oom::paused();
+        g_debug("Pausing PID: %d (%d)", pid, int(oomval));
+        signalToPid(pid, SIGSTOP);
+        oomValueToPid(pid, oomval);
+    });
+
+    pidListToDbus(pids, "ApplicationPaused");
+}
+
+/** Resumes this application by sending SIGCONT to all the PIDs in the
+    cgroup and tells Zeitgeist that we're accessing the application. */
+void Base::resume()
+{
+    g_debug("Resuming application: %s", std::string(appId_).c_str());
+    registry_->impl->zgSendEvent(appId_, ZEITGEIST_ZG_ACCESS_EVENT);
+
+    auto pids = forAllPids([this](pid_t pid) {
+        auto oomval = oom::focused();
+        g_debug("Resuming PID: %d (%d)", pid, int(oomval));
+        signalToPid(pid, SIGCONT);
+        oomValueToPid(pid, oomval);
+    });
+
+    pidListToDbus(pids, "ApplicationResumed");
+}
+
+/** Go through the list of PIDs calling a function and handling
+    the issue with getting PIDs being a racey condition.
+
+    \param eachPid Function to run on each PID
+*/
+std::vector<pid_t> Base::forAllPids(std::function<void(pid_t)> eachPid)
+{
+    std::set<pid_t> seenPids;
+    bool added = true;
+
+    while (added)
+    {
+        added = false;
+        auto pidlist = pids();
+        for (auto pid : pidlist)
+        {
+            if (seenPids.insert(pid).second)
+            {
+                eachPid(pid);
+                added = true;
+            }
+        }
+    }
+
+    return std::vector<pid_t>(seenPids.begin(), seenPids.end());
+}
+
+/** Send a signal that we've change the application. Do this on the
+    registry thread in an idle so that we don't block anyone.
+
+    \param pids List of PIDs to turn into variants to send
+    \param signal Name of the DBus signal to send
+*/
+void Base::pidListToDbus(const std::vector<pid_t>& pids, const std::string& signal)
+{
+    auto registry = registry_;
+    auto lappid = appId_;
+
+    registry_->impl->thread.executeOnThread([registry, lappid, pids, signal] {
+        auto vpids = std::shared_ptr<GVariant>(
+            [pids]() {
+                GVariant* pidarray = nullptr;
+
+                if (pids.empty())
+                {
+                    pidarray = g_variant_new_array(G_VARIANT_TYPE_UINT64, nullptr, 0);
+                    g_variant_ref_sink(pidarray);
+                    return pidarray;
+                }
+
+                GVariantBuilder builder;
+                g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
+                for (auto pid : pids)
+                {
+                    g_variant_builder_add_value(&builder, g_variant_new_uint64(pid));
+                }
+
+                pidarray = g_variant_builder_end(&builder);
+                g_variant_ref_sink(pidarray);
+                return pidarray;
+            }(),
+            [](GVariant* var) { g_variant_unref(var); });
+
+        GVariantBuilder params;
+        g_variant_builder_init(&params, G_VARIANT_TYPE_TUPLE);
+        g_variant_builder_add_value(&params, g_variant_new_string(std::string(lappid).c_str()));
+        g_variant_builder_add_value(&params, vpids.get());
+
+        GError* error = nullptr;
+        g_dbus_connection_emit_signal(registry->impl->_dbus.get(),     /* bus */
+                                      nullptr,                         /* destination */
+                                      "/",                             /* path */
+                                      "com.canonical.UbuntuAppLaunch", /* interface */
+                                      signal.c_str(),                  /* signal */
+                                      g_variant_builder_end(&params),  /* params, the same */
+                                      &error);                         /* error */
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to emit signal '%s' for appid '%s': %s", signal.c_str(), std::string(lappid).c_str(),
+                      error->message);
+            g_error_free(error);
+        }
+        else
+        {
+            g_debug("Emmitted '%s' to DBus", signal.c_str());
+        }
+    });
+}
+
+/** Sets the OOM adjustment by getting the list of PIDs and writing
+    the value to each of their files in proc
+
+    \param score OOM Score to set
+*/
+void Base::setOomAdjustment(const oom::Score score)
+{
+    forAllPids([this, &score](pid_t pid) { oomValueToPid(pid, score); });
+}
+
+/** Figures out the path to the primary PID of the application and
+    then reads its OOM adjustment file. */
+const oom::Score Base::getOomAdjustment()
+{
+    auto pid = primaryPid();
+    if (pid == 0)
+    {
+        throw std::runtime_error("No PID for application: " + std::string(appId_));
+    }
+
+    auto path = pidToOomPath(pid);
+    GError* error = nullptr;
+    gchar* content = nullptr;
+
+    g_file_get_contents(path.c_str(), /* path */
+                        &content,     /* data */
+                        nullptr,      /* size */
+                        &error);      /* error */
+
+    if (error != nullptr)
+    {
+        auto serror = std::shared_ptr<GError>(error, g_error_free);
+        throw std::runtime_error("Unable to access OOM value for '" + std::string(appId_) + "' primary PID '" +
+                                 std::to_string(pid) + "' because: " + serror->message);
+    }
+
+    auto score = static_cast<oom::Score>(std::atoi(content));
+    g_free(content);
+    return score;
+}
+
+/** Sends a signal to a PID with a warning if we can't send it.
+    We could throw an exception, but we can't handle it usefully anyway
+
+    \param pid PID to send the signal to
+    \param signal signal to send
+*/
+void Base::signalToPid(pid_t pid, int signal)
+{
+    if (-1 == kill(pid, signal))
+    {
+        /* While that didn't work, we still want to try as many as we can */
+        g_warning("Unable to send signal %d to pid %d", signal, pid);
+    }
+}
+
+/** Get the path to the PID's OOM adjust path, with allowing for an
+    override for testing using the environment variable
+    UBUNTU_APP_LAUNCH_OOM_PROC_PATH
+
+    \param pid PID to build path for
+*/
+std::string Base::pidToOomPath(pid_t pid)
+{
+    static std::string procpath;
+    if (G_UNLIKELY(procpath.empty()))
+    {
+        /* Set by the test suite, probably not anyone else */
+        auto envvar = g_getenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH");
+        if (G_LIKELY(envvar == nullptr))
+            procpath = "/proc";
+        else
+            procpath = envvar;
+    }
+
+    gchar* gpath = g_build_filename(procpath.c_str(), std::to_string(pid).c_str(), "oom_score_adj", nullptr);
+    std::string path = gpath;
+    g_free(gpath);
+    return path;
+}
+
+/** Writes an OOM value to proc, assuming we have a string
+    in the outer loop
+
+    \param pid PID to change the OOM value of
+    \param oomvalue OOM value to set
+*/
+void Base::oomValueToPid(pid_t pid, const oom::Score oomvalue)
+{
+    auto oomstr = std::to_string(static_cast<std::int32_t>(oomvalue));
+    auto path = pidToOomPath(pid);
+    FILE* adj = fopen(path.c_str(), "w");
+    int openerr = errno;
+
+    if (adj == nullptr)
+    {
+        switch (openerr)
+        {
+            case ENOENT:
+                /* ENOENT happens a fair amount because of races, so it's not
+                   worth printing a warning about */
+                return;
+            case EACCES:
+            {
+                /* We can get this error when trying to set the OOM value on
+                   Oxide renderers because they're started by the sandbox and
+                   don't have their adjustment value available for us to write.
+                   We have a helper to deal with this, but it's kinda expensive
+                   so we only use it when we have to. */
+                oomValueToPidHelper(pid, oomvalue);
+                return;
+            }
+            default:
+                g_warning("Unable to set OOM value for '%d' to '%s': %s", int(pid), oomstr.c_str(),
+                          std::strerror(openerr));
+                return;
+        }
+    }
+
+    size_t writesize = fwrite(oomstr.c_str(), 1, oomstr.size(), adj);
+    int writeerr = errno;
+    fclose(adj);
+
+    if (writesize == oomstr.size())
+        return;
+
+    if (writeerr != 0)
+        g_warning("Unable to set OOM value for '%d' to '%s': %s", int(pid), oomstr.c_str(), strerror(writeerr));
+    else
+        /* No error, but yet, wrong size. Not sure, what could cause this. */
+        g_debug("Unable to set OOM value for '%d' to '%s': Wrote %d bytes", int(pid), oomstr.c_str(), int(writesize));
+}
+
+/** Use a setuid root helper for setting the oom value of
+    Chromium instances
+
+    \param pid PID to change the OOM value of
+    \param oomvalue OOM value to set
+*/
+void Base::oomValueToPidHelper(pid_t pid, const oom::Score oomvalue)
+{
+    GError* error = nullptr;
+    std::string oomstr = std::to_string(static_cast<std::int32_t>(oomvalue));
+    std::string pidstr = std::to_string(pid);
+    std::array<const char*, 4> args = {OOM_HELPER, pidstr.c_str(), oomstr.c_str(), nullptr};
+
+    g_debug("Excuting OOM Helper (pid: %d, score: %d): %s", int(pid), int(oomvalue),
+            std::accumulate(args.begin(), args.end(), std::string{},
+                            [](const std::string& instr, const char* output) -> std::string {
+                                if (instr.empty())
+                                {
+                                    return output;
+                                }
+                                else if (output != nullptr)
+                                {
+                                    return instr + " " + std::string(output);
+                                }
+                                else
+                                {
+                                    return instr;
+                                }
+                            })
+                .c_str());
+
+    g_spawn_async(nullptr,               /* working dir */
+                  (char**)(args.data()), /* args */
+                  nullptr,               /* env */
+                  G_SPAWN_DEFAULT,       /* flags */
+                  nullptr,               /* child setup */
+                  nullptr,               /* child setup userdata*/
+                  nullptr,               /* pid */
+                  &error);               /* error */
+
+    if (error != nullptr)
+    {
+        g_warning("Unable to launch OOM helper '" OOM_HELPER "' on PID '%d': %s", pid, error->message);
+        g_error_free(error);
+        return;
+    }
+}
+
+}  // namespace instance
+
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/jobs-base.h'
--- libubuntu-app-launch/jobs-base.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-base.h	2016-11-10 21:58:30 +0000
@@ -0,0 +1,117 @@
+/*
+ * 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 "application.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace instance
+{
+
+class Base : public Application::Instance
+{
+public:
+    Base(const AppID& appId,
+         const std::string& job,
+         const std::string& instance,
+         const std::vector<Application::URL>& urls,
+         const std::shared_ptr<Registry>& registry);
+    virtual ~Base() = default;
+
+    bool isRunning() override;
+    bool hasPid(pid_t pid) override;
+    void pause() override;
+    void resume() override;
+
+    /* OOM Functions */
+    void setOomAdjustment(const oom::Score score) override;
+    const oom::Score getOomAdjustment() override;
+
+protected:
+    /** 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_;
+
+private:
+    std::vector<pid_t> forAllPids(std::function<void(pid_t)> eachPid);
+    void signalToPid(pid_t pid, int signal);
+    std::string pidToOomPath(pid_t pid);
+    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);
+};
+
+}  // namespace instance
+
+namespace manager
+{
+
+/** Flag for whether we should include the testing environment variables */
+enum class launchMode
+{
+    STANDARD, /**< Standard variable set */
+    TEST      /**< Include testing environment vars */
+};
+
+class Base
+{
+public:
+    Base(const std::shared_ptr<Registry>& registry);
+    virtual ~Base() = default;
+
+    virtual std::shared_ptr<Application::Instance> launch(
+        const AppID& appId,
+        const std::string& job,
+        const std::string& instance,
+        const std::vector<Application::URL>& urls,
+        launchMode mode,
+        std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv) = 0;
+
+    virtual std::shared_ptr<Application::Instance> existing(const AppID& appId,
+                                                            const std::string& job,
+                                                            const std::string& instance,
+                                                            const std::vector<Application::URL>& urls) = 0;
+
+    virtual std::list<std::shared_ptr<Application>> runningApps() = 0;
+
+    virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) = 0;
+
+    static std::shared_ptr<Base> determineFactory(std::shared_ptr<Registry> registry);
+
+protected:
+    std::weak_ptr<Registry> registry_;
+};
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/jobs-upstart.cpp'
--- libubuntu-app-launch/jobs-upstart.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-upstart.cpp	2016-11-10 21:58:30 +0000
@@ -0,0 +1,899 @@
+/*
+ * 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 <algorithm>
+#include <cerrno>
+#include <cstring>
+#include <map>
+#include <numeric>
+#include <regex>
+
+#include <cgmanager/cgmanager.h>
+#include <upstart.h>
+
+#include "helpers.h"
+#include "registry-impl.h"
+#include "second-exec-core.h"
+
+extern "C" {
+#include "ubuntu-app-launch-trace.h"
+}
+
+#include "jobs-upstart.h"
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace instance
+{
+
+/** 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 Upstart : public Base
+{
+public:
+    explicit Upstart(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 */
+    pid_t primaryPid() override;
+    std::string logPath() override;
+    std::vector<pid_t> pids() override;
+
+    /* Manage lifecycle */
+    void stop() override;
+
+    /* C Callback */
+    static void application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data);
+
+private:
+    std::string upstartJobPath(const std::string& job);
+    std::string upstartName();
+
+    static std::shared_ptr<gchar*> urlsToStrv(const std::vector<Application::URL>& urls);
+};
+
+/** Uses Upstart to get the primary PID of the instance using Upstart's
+    DBus interface */
+pid_t Upstart::primaryPid()
+{
+    auto jobpath = upstartJobPath(job_);
+    if (jobpath.empty())
+    {
+        g_debug("Unable to get a valid job path");
+        return 0;
+    }
+
+    return registry_->impl->thread.executeOnThread<pid_t>([this, &jobpath]() -> pid_t {
+        GError* error = nullptr;
+
+        std::string instancename = std::string(appId_);
+        if (job_ != "application-click")
+        {
+            instancename += "-" + instance_;
+        }
+
+        g_debug("Getting instance by name: %s", instance_.c_str());
+        GVariant* vinstance_path =
+            g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                   /* connection */
+                                        DBUS_SERVICE_UPSTART,                           /* service */
+                                        jobpath.c_str(),                                /* object path */
+                                        DBUS_INTERFACE_UPSTART_JOB,                     /* iface */
+                                        "GetInstanceByName",                            /* method */
+                                        g_variant_new("(s)", instancename.c_str()),     /* params */
+                                        G_VARIANT_TYPE("(o)"),                          /* return type */
+                                        G_DBUS_CALL_FLAGS_NONE,                         /* flags */
+                                        -1,                                             /* timeout: default */
+                                        registry_->impl->thread.getCancellable().get(), /* cancellable */
+                                        &error);
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to get instance '%s' of job '%s': %s", instance_.c_str(), job_.c_str(), error->message);
+            g_error_free(error);
+            return 0;
+        }
+
+        /* Jump rope to make this into a C++ type */
+        std::string instance_path;
+        gchar* cinstance_path = nullptr;
+        g_variant_get(vinstance_path, "(o)", &cinstance_path);
+        g_variant_unref(vinstance_path);
+        if (cinstance_path != nullptr)
+        {
+            instance_path = cinstance_path;
+            g_free(cinstance_path);
+        }
+
+        if (instance_path.empty())
+        {
+            g_debug("No instance object for instance name: %s", instance_.c_str());
+            return 0;
+        }
+
+        GVariant* props_tuple =
+            g_dbus_connection_call_sync(registry_->impl->_dbus.get(),                          /* connection */
+                                        DBUS_SERVICE_UPSTART,                                  /* service */
+                                        instance_path.c_str(),                                 /* object path */
+                                        "org.freedesktop.DBus.Properties",                     /* interface */
+                                        "GetAll",                                              /* method */
+                                        g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE), /* params */
+                                        G_VARIANT_TYPE("(a{sv})"),                             /* return type */
+                                        G_DBUS_CALL_FLAGS_NONE,                                /* flags */
+                                        -1,                                                    /* timeout: default */
+                                        registry_->impl->thread.getCancellable().get(),        /* cancellable */
+                                        &error);
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to name of properties '%s': %s", instance_path.c_str(), error->message);
+            g_error_free(error);
+            error = nullptr;
+            return 0;
+        }
+
+        GVariant* props_dict = g_variant_get_child_value(props_tuple, 0);
+
+        pid_t retval = 0;
+        GVariant* processes = g_variant_lookup_value(props_dict, "processes", G_VARIANT_TYPE("a(si)"));
+        if (processes != nullptr && g_variant_n_children(processes) > 0)
+        {
+
+            GVariant* first_entry = g_variant_get_child_value(processes, 0);
+            GVariant* pidv = g_variant_get_child_value(first_entry, 1);
+
+            retval = g_variant_get_int32(pidv);
+
+            g_variant_unref(pidv);
+            g_variant_unref(first_entry);
+        }
+        else
+        {
+            g_debug("Unable to get 'processes' from properties of instance at path: %s", instance_path.c_str());
+        }
+
+        g_variant_unref(props_dict);
+
+        return retval;
+    });
+}
+
+/** Generate the full name of the Upstart job for the job, the
+    instance and how all those fit together.
+
+    Handles the special case of application-click which isn't designed
+    to have multi-instance apps.
+*/
+std::string Upstart::upstartName()
+{
+    std::string path = job_ + "-" + std::string(appId_);
+    if (job_ != "application-click")
+    {
+        path += "-";
+    }
+    if (!instance_.empty())
+    {
+        path += instance_;
+    }
+
+    return path;
+}
+
+/** Gets the path to the log file for this instance */
+std::string Upstart::logPath()
+{
+    std::string logfile = upstartName() + ".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;
+}
+
+/** Returns all the PIDs that are in the cgroup for this application */
+std::vector<pid_t> Upstart::pids()
+{
+    auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry_->impl->jobs);
+    auto pids = manager->pidsFromCgroup(upstartName());
+    g_debug("Got %d PIDs for AppID '%s'", int(pids.size()), std::string(appId_).c_str());
+    return pids;
+}
+
+/** Stops this instance by asking Upstart to stop it. Upstart will then
+    send a SIGTERM and five seconds later start killing things. */
+void Upstart::stop()
+{
+    if (!registry_->impl->thread.executeOnThread<bool>([this]() {
+            auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry_->impl->jobs);
+
+            g_debug("Stopping job %s app_id %s instance_id %s", job_.c_str(), std::string(appId_).c_str(),
+                    instance_.c_str());
+
+            auto jobpath = manager->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 = nullptr;
+            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 */
+                                            nullptr,                                        /* return */
+                                            G_DBUS_CALL_FLAGS_NONE,                         /* flags */
+                                            -1,                                             /* timeout: default */
+                                            registry_->impl->thread.getCancellable().get(), /* cancellable */
+                                            &error);                                        /* error (hopefully not) */
+
+            g_clear_pointer(&stop_variant, g_variant_unref);
+
+            if (error != nullptr)
+            {
+                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");
+    }
+}
+
+/** Create a new Upstart Instance object that can track the job and
+    get information about it.
+
+    \param appId Application ID
+    \param job Upstart job name
+    \param instance Upstart instance name
+    \param urls URLs sent to the application (only on launch today)
+    \param registry Registry of persistent connections to use
+*/
+Upstart::Upstart(const AppID& appId,
+                 const std::string& job,
+                 const std::string& instance,
+                 const std::vector<Application::URL>& urls,
+                 const std::shared_ptr<Registry>& registry)
+    : Base(appId, job, instance, urls, registry)
+{
+    g_debug("Creating a new Upstart for '%s' instance '%s'", std::string(appId).c_str(), instance.c_str());
+}
+
+/** Reformat a C++ vector of URLs into a C GStrv of strings
+
+    \param urls Vector of URLs to make into C strings
+*/
+std::shared_ptr<gchar*> Upstart::urlsToStrv(const std::vector<Application::URL>& urls)
+{
+    if (urls.empty())
+    {
+        return {};
+    }
+
+    auto array = g_array_new(TRUE, FALSE, sizeof(gchar*));
+
+    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);
+}
+
+/** Small helper that we can new/delete to work better with C stuff */
+struct StartCHelper
+{
+    std::shared_ptr<Upstart> 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.
+
+    \param obj The GDBusConnection object
+    \param res Async result object
+    \param user_data A pointer to a StartCHelper structure
+*/
+void Upstart::application_start_cb(GObject* obj, GAsyncResult* res, gpointer user_data)
+{
+    auto data = static_cast<StartCHelper*>(user_data);
+    GError* error{nullptr};
+    GVariant* result{nullptr};
+
+    tracepoint(ubuntu_app_launch, libual_start_message_callback, std::string(data->ptr->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);
+
+    g_clear_pointer(&result, g_variant_unref);
+
+    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::string Upstart::upstartJobPath(const std::string& job)
+{
+    auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry_->impl->jobs);
+    return manager->upstartJobPath(job);
+}
+
+}  // namespace instances
+
+namespace manager
+{
+
+Upstart::Upstart(std::shared_ptr<Registry> registry)
+    : Base(registry)
+{
+}
+
+Upstart::~Upstart()
+{
+}
+
+/** Launch an application and create a new Upstart instance object to track
+    its progress.
+
+    \param appId Application ID
+    \param job Upstart job name
+    \param instance Upstart instance name
+    \param urls URLs sent to the application (only on launch today)
+    \param mode Whether or not to setup the environment for testing
+    \param getenv A function to get additional environment variable when appropriate
+*/
+std::shared_ptr<Application::Instance> Upstart::launch(
+    const AppID& appId,
+    const std::string& job,
+    const std::string& instance,
+    const std::vector<Application::URL>& urls,
+    launchMode mode,
+    std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv)
+{
+    if (appId.empty())
+        return {};
+
+    auto registry = registry_.lock();
+    return registry->impl->thread.executeOnThread<std::shared_ptr<instance::Upstart>>(
+        [&]() -> std::shared_ptr<instance::Upstart> {
+            auto manager = std::dynamic_pointer_cast<manager::Upstart>(registry->impl->jobs);
+            std::string appIdStr{appId};
+            g_debug("Initializing params for an new instance::Upstart for: %s", appIdStr.c_str());
+
+            tracepoint(ubuntu_app_launch, libual_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");
+            }
+
+            /* Figure out the DBus path for the job */
+            auto jobpath = manager->upstartJobPath(job);
+
+            /* Build up our environment */
+            auto env = getenv();
+
+            env.emplace_back(std::make_pair("APP_ID", appIdStr));                           /* Application ID */
+            env.emplace_back(std::make_pair("APP_LAUNCHER_PID", std::to_string(getpid()))); /* Who we are, for bugs */
+
+            if (!urls.empty())
+            {
+                auto accumfunc = [](const std::string& prev, Application::URL thisurl) -> std::string {
+                    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;
+                    }
+                };
+                auto urlstring = std::accumulate(urls.begin(), urls.end(), std::string{}, accumfunc);
+                env.emplace_back(std::make_pair("APP_URIS", urlstring));
+            }
+
+            if (mode == launchMode::TEST)
+            {
+                env.emplace_back(std::make_pair("QT_LOAD_TESTABILITY", "1"));
+            }
+
+            /* Convert to GVariant */
+            GVariantBuilder builder;
+            g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+
+            g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+
+            for (const 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<instance::Upstart>(appId, job, instance, urls, registry);
+            auto chelper = new instance::StartCHelper{};
+            chelper->ptr = retval;
+
+            tracepoint(ubuntu_app_launch, handshake_wait, appIdStr.c_str());
+            starting_handshake_wait(handshake);
+            tracepoint(ubuntu_app_launch, handshake_complete, appIdStr.c_str());
+
+            /* Call the job start function */
+            g_debug("Asking Upstart to start task for: %s", appIdStr.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 */
+                                   nullptr,                                       /* return */
+                                   G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                   -1,                                            /* default timeout */
+                                   registry->impl->thread.getCancellable().get(), /* cancellable */
+                                   instance::Upstart::application_start_cb,       /* callback */
+                                   chelper                                        /* object */
+                                   );
+
+            tracepoint(ubuntu_app_launch, libual_start_message_sent, appIdStr.c_str());
+
+            return retval;
+        });
+}
+
+/** Special characters that could be an application name that
+    would activate in a regex */
+const static std::regex regexCharacters("([\\.\\-])");
+
+std::shared_ptr<Application::Instance> Upstart::existing(const AppID& appId,
+                                                         const std::string& job,
+                                                         const std::string& instance,
+                                                         const std::vector<Application::URL>& urls)
+{
+    return std::make_shared<instance::Upstart>(appId, job, instance, urls, registry_.lock());
+}
+
+std::vector<std::shared_ptr<instance::Base>> Upstart::instances(const AppID& appID, const std::string& job)
+{
+    std::vector<std::shared_ptr<instance::Base>> vect;
+    auto startsWith = std::string(appID);
+    if (job != "application-click")
+    {
+        startsWith += "-";
+    }
+
+    auto regexstr =
+        std::string{"^(?:"} + std::regex_replace(startsWith, regexCharacters, "\\$&") + std::string{")(\\d*)$"};
+    auto instanceRegex = std::regex(regexstr);
+
+    for (auto instance : upstartInstancesForJob(job))
+    {
+        std::smatch instanceMatch;
+        g_debug("Looking at job '%s' instance: %s", job.c_str(), instance.c_str());
+        if (std::regex_match(instance, instanceMatch, instanceRegex))
+        {
+            auto app = existing(appID, job, instanceMatch[1].str(), {});
+            vect.emplace_back(std::dynamic_pointer_cast<instance::Base>(app));
+        }
+    }
+
+    g_debug("App '%s' has %d instances", std::string(appID).c_str(), int(vect.size()));
+
+    return vect;
+}
+
+/** Initialize the CGManager connection, including a timeout to disconnect
+    as CGManager doesn't free resources entirely well. So it's better if
+    we connect and disconnect occationally */
+void Upstart::initCGManager()
+{
+    if (cgManager_)
+        return;
+
+    std::promise<std::shared_ptr<GDBusConnection>> promise;
+    auto future = promise.get_future();
+    auto registry = registry_.lock();
+
+    registry->impl->thread.executeOnThread([this, &promise, &registry]() {
+        bool use_session_bus = g_getenv("UBUNTU_APP_LAUNCH_CG_MANAGER_SESSION_BUS") != nullptr;
+        if (use_session_bus)
+        {
+            /* For working dbusmock */
+            g_debug("Connecting to CG Manager on session bus");
+            promise.set_value(registry->impl->_dbus);
+            return;
+        }
+
+        auto cancel =
+            std::shared_ptr<GCancellable>(g_cancellable_new(), [](GCancellable* cancel) { g_clear_object(&cancel); });
+
+        /* Ensure that we do not wait for more than a second */
+        registry->impl->thread.timeoutSeconds(std::chrono::seconds{1},
+                                              [cancel]() { g_cancellable_cancel(cancel.get()); });
+
+        g_dbus_connection_new_for_address(
+            CGMANAGER_DBUS_PATH,                           /* cgmanager path */
+            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, /* flags */
+            nullptr,                                       /* Auth Observer */
+            cancel.get(),                                  /* Cancellable */
+            [](GObject* obj, GAsyncResult* res, gpointer data) -> void {
+                GError* error = nullptr;
+                auto promise = reinterpret_cast<std::promise<std::shared_ptr<GDBusConnection>>*>(data);
+
+                auto gcon = g_dbus_connection_new_for_address_finish(res, &error);
+                if (error != nullptr)
+                {
+                    g_error_free(error);
+                }
+
+                auto con = std::shared_ptr<GDBusConnection>(gcon, [](GDBusConnection* con) { g_clear_object(&con); });
+                promise->set_value(con);
+            },
+            &promise);
+    });
+
+    cgManager_ = future.get();
+    registry->impl->thread.timeoutSeconds(std::chrono::seconds{10}, [this]() { cgManager_.reset(); });
+}
+
+/** Get a list of PIDs from a CGroup, uses the CGManager connection to list
+    all of the PIDs. It is important to note that this is an IPC call, so it can
+    by its nature, be racy. Once the message has been sent the group can change.
+    You should take that into account in your usage of it. */
+std::vector<pid_t> Upstart::pidsFromCgroup(const std::string& jobpath)
+{
+    initCGManager();
+    auto lmanager = cgManager_; /* Grab a local copy so we ensure it lasts through our lifetime */
+    auto registry = registry_.lock();
+
+    return registry->impl->thread.executeOnThread<std::vector<pid_t>>([&jobpath, lmanager]() -> std::vector<pid_t> {
+        GError* error = nullptr;
+        const gchar* name = g_getenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME");
+        std::string groupname;
+        if (!jobpath.empty())
+        {
+            groupname = "upstart/" + jobpath;
+        }
+
+        g_debug("Looking for cg manager '%s' group '%s'", name, groupname.c_str());
+
+        GVariant* vtpids = g_dbus_connection_call_sync(
+            lmanager.get(),                     /* connection */
+            name,                               /* bus name for direct connection is NULL */
+            "/org/linuxcontainers/cgmanager",   /* object */
+            "org.linuxcontainers.cgmanager0_0", /* interface */
+            "GetTasksRecursive",                /* method */
+            g_variant_new("(ss)", "freezer", groupname.empty() ? "" : groupname.c_str()), /* params */
+            G_VARIANT_TYPE("(ai)"),                                                       /* output */
+            G_DBUS_CALL_FLAGS_NONE,                                                       /* flags */
+            -1,                                                                           /* default timeout */
+            nullptr,                                                                      /* cancellable */
+            &error);                                                                      /* error */
+
+        if (error != nullptr)
+        {
+            g_warning("Unable to get PID list from cgroup manager: %s", error->message);
+            g_error_free(error);
+            return {};
+        }
+
+        GVariant* vpids = g_variant_get_child_value(vtpids, 0);
+        GVariantIter iter;
+        g_variant_iter_init(&iter, vpids);
+        gint32 pid;
+        std::vector<pid_t> pids;
+
+        while (g_variant_iter_loop(&iter, "i", &pid))
+        {
+            pids.push_back(pid);
+        }
+
+        g_variant_unref(vpids);
+        g_variant_unref(vtpids);
+
+        return pids;
+    });
+}
+
+/** Looks to find the Upstart object path for a specific Upstart job. This first
+    checks the cache, and otherwise does the lookup on DBus. */
+std::string Upstart::upstartJobPath(const std::string& job)
+{
+    try
+    {
+        return upstartJobPathCache_.at(job);
+    }
+    catch (std::out_of_range& e)
+    {
+        auto registry = registry_.lock();
+        auto path = registry->impl->thread.executeOnThread<std::string>([this, &job, &registry]() -> std::string {
+            GError* error = nullptr;
+            GVariant* job_path_variant =
+                g_dbus_connection_call_sync(registry->impl->_dbus.get(),                   /* connection */
+                                            DBUS_SERVICE_UPSTART,                          /* service */
+                                            DBUS_PATH_UPSTART,                             /* path */
+                                            DBUS_INTERFACE_UPSTART,                        /* iface */
+                                            "GetJobByName",                                /* method */
+                                            g_variant_new("(s)", job.c_str()),             /* params */
+                                            G_VARIANT_TYPE("(o)"),                         /* return */
+                                            G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                            -1,                                            /* timeout: default */
+                                            registry->impl->thread.getCancellable().get(), /* cancellable */
+                                            &error);                                       /* error */
+
+            if (error != nullptr)
+            {
+                g_warning("Unable to find job '%s': %s", job.c_str(), error->message);
+                g_error_free(error);
+                return {};
+            }
+
+            gchar* job_path = nullptr;
+            g_variant_get(job_path_variant, "(o)", &job_path);
+            g_variant_unref(job_path_variant);
+
+            if (job_path != nullptr)
+            {
+                std::string path(job_path);
+                g_free(job_path);
+                return path;
+            }
+            else
+            {
+                return {};
+            }
+        });
+
+        upstartJobPathCache_[job] = path;
+        return path;
+    }
+}
+
+/** Queries Upstart to get all the instances of a given job. This
+    can take a while as the number of dbus calls is n+1. It is
+    rare that apps have many instances though. */
+std::list<std::string> Upstart::upstartInstancesForJob(const std::string& job)
+{
+    std::string jobpath = upstartJobPath(job);
+    if (jobpath.empty())
+    {
+        return {};
+    }
+
+    auto registry = registry_.lock();
+    return registry->impl->thread.executeOnThread<std::list<std::string>>(
+        [this, &job, &jobpath, &registry]() -> std::list<std::string> {
+            GError* error = nullptr;
+            GVariant* instance_tuple =
+                g_dbus_connection_call_sync(registry->impl->_dbus.get(),                   /* connection */
+                                            DBUS_SERVICE_UPSTART,                          /* service */
+                                            jobpath.c_str(),                               /* object path */
+                                            DBUS_INTERFACE_UPSTART_JOB,                    /* iface */
+                                            "GetAllInstances",                             /* method */
+                                            nullptr,                                       /* params */
+                                            G_VARIANT_TYPE("(ao)"),                        /* return type */
+                                            G_DBUS_CALL_FLAGS_NONE,                        /* flags */
+                                            -1,                                            /* timeout: default */
+                                            registry->impl->thread.getCancellable().get(), /* cancellable */
+                                            &error);
+
+            if (error != nullptr)
+            {
+                g_warning("Unable to get instances of job '%s': %s", job.c_str(), error->message);
+                g_error_free(error);
+                return {};
+            }
+
+            if (instance_tuple == nullptr)
+            {
+                return {};
+            }
+
+            GVariant* instance_list = g_variant_get_child_value(instance_tuple, 0);
+            g_variant_unref(instance_tuple);
+
+            GVariantIter instance_iter;
+            g_variant_iter_init(&instance_iter, instance_list);
+            const gchar* instance_path = nullptr;
+            std::list<std::string> instances;
+
+            while (g_variant_iter_loop(&instance_iter, "&o", &instance_path))
+            {
+                GVariant* props_tuple =
+                    g_dbus_connection_call_sync(registry->impl->_dbus.get(),                           /* connection */
+                                                DBUS_SERVICE_UPSTART,                                  /* service */
+                                                instance_path,                                         /* object path */
+                                                "org.freedesktop.DBus.Properties",                     /* interface */
+                                                "GetAll",                                              /* method */
+                                                g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE), /* params */
+                                                G_VARIANT_TYPE("(a{sv})"),                             /* return type */
+                                                G_DBUS_CALL_FLAGS_NONE,                                /* flags */
+                                                -1,                                            /* timeout: default */
+                                                registry->impl->thread.getCancellable().get(), /* cancellable */
+                                                &error);
+
+                if (error != nullptr)
+                {
+                    g_warning("Unable to name of instance '%s': %s", instance_path, error->message);
+                    g_error_free(error);
+                    error = nullptr;
+                    continue;
+                }
+
+                GVariant* props_dict = g_variant_get_child_value(props_tuple, 0);
+
+                GVariant* namev = g_variant_lookup_value(props_dict, "name", G_VARIANT_TYPE_STRING);
+                if (namev != nullptr)
+                {
+                    auto name = g_variant_get_string(namev, NULL);
+                    g_debug("Adding instance for job '%s': %s", job.c_str(), name);
+                    instances.push_back(name);
+                    g_variant_unref(namev);
+                }
+
+                g_variant_unref(props_dict);
+                g_variant_unref(props_tuple);
+            }
+
+            g_variant_unref(instance_list);
+
+            return instances;
+        });
+}
+
+std::list<std::shared_ptr<Application>> Upstart::runningApps()
+{
+    std::list<std::string> instances;
+
+    /* Get all the legacy instances */
+    instances.splice(instances.begin(), upstartInstancesForJob("application-legacy"));
+    /* Get all the snap instances */
+    instances.splice(instances.begin(), upstartInstancesForJob("application-snap"));
+
+    /* Remove the instance ID */
+    std::transform(instances.begin(), instances.end(), instances.begin(), [](std::string& instancename) -> std::string {
+        static const std::regex instanceregex("^(.*)-[0-9]*$");
+        std::smatch match;
+        if (std::regex_match(instancename, match, instanceregex))
+        {
+            return match[1].str();
+        }
+        else
+        {
+            g_warning("Unable to match instance name: %s", instancename.c_str());
+            return {};
+        }
+    });
+
+    /* Deduplicate Set */
+    std::set<std::string> instanceset;
+    for (auto instance : instances)
+    {
+        if (!instance.empty())
+            instanceset.insert(instance);
+    }
+
+    /* Add in the click instances */
+    for (auto instance : upstartInstancesForJob("application-click"))
+    {
+        instanceset.insert(instance);
+    }
+
+    g_debug("Overall there are %d instances: %s", int(instanceset.size()),
+            std::accumulate(instanceset.begin(), instanceset.end(), std::string{},
+                            [](const std::string& instr, std::string instance) {
+                                return instr.empty() ? instance : instr + ", " + instance;
+                            })
+                .c_str());
+
+    /* Convert to Applications */
+    auto registry = registry_.lock();
+    std::list<std::shared_ptr<Application>> apps;
+    for (auto instance : instanceset)
+    {
+        auto appid = AppID::find(registry, instance);
+        auto app = Application::create(appid, registry);
+        apps.push_back(app);
+    }
+
+    return apps;
+}
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/jobs-upstart.h'
--- libubuntu-app-launch/jobs-upstart.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/jobs-upstart.h	2016-11-10 21:58:30 +0000
@@ -0,0 +1,75 @@
+/*
+ * 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 "jobs-base.h"
+#include <gio/gio.h>
+#include <map>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace jobs
+{
+namespace manager
+{
+
+class Upstart : public Base
+{
+public:
+    Upstart(std::shared_ptr<Registry> registry);
+    virtual ~Upstart();
+
+    virtual std::shared_ptr<Application::Instance> launch(
+        const AppID& appId,
+        const std::string& job,
+        const std::string& instance,
+        const std::vector<Application::URL>& urls,
+        launchMode mode,
+        std::function<std::list<std::pair<std::string, std::string>>(void)>& getenv) override;
+    virtual std::shared_ptr<Application::Instance> existing(const AppID& appId,
+                                                            const std::string& job,
+                                                            const std::string& instance,
+                                                            const std::vector<Application::URL>& urls) override;
+
+    virtual std::list<std::shared_ptr<Application>> runningApps() override;
+
+    virtual std::vector<std::shared_ptr<instance::Base>> instances(const AppID& appID, const std::string& job) override;
+
+    std::vector<pid_t> pidsFromCgroup(const std::string& jobpath);
+
+    std::list<std::string> upstartInstancesForJob(const std::string& job);
+    std::string upstartJobPath(const std::string& job);
+
+private:
+    void initCGManager();
+
+    std::shared_ptr<GDBusConnection> cgManager_;
+
+    /** Getting the Upstart job path is relatively expensive in
+        that it requires a DBus call. Worth keeping a cache of. */
+    std::map<std::string, std::string> upstartJobPathCache_;
+};
+
+}  // namespace manager
+}  // namespace jobs
+}  // namespace app_launch
+}  // namespace ubuntu

=== modified file 'libubuntu-app-launch/libubuntu-app-launch.map'
--- libubuntu-app-launch/libubuntu-app-launch.map	2016-05-19 16:24:11 +0000
+++ libubuntu-app-launch/libubuntu-app-launch.map	2016-11-10 21:58:30 +0000
@@ -14,6 +14,7 @@
 		ubuntu::app_launch::Helper::*;
 		typeinfo?for?ubuntu::app_launch::Helper;
 		typeinfo?name?for?ubuntu::app_launch::Helper;
+		ubuntu::app_launch::operator*;
 		ubuntu::app_launch::oom::*;
 	};
 local:

=== modified file 'libubuntu-app-launch/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2016-09-23 22:30:51 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2016-11-10 21:58:30 +0000
@@ -19,7 +19,7 @@
 
 #include "registry-impl.h"
 #include "application-icon-finder.h"
-#include <cgmanager/cgmanager.h>
+#include <regex>
 #include <upstart.h>
 
 namespace ubuntu
@@ -34,7 +34,24 @@
                  _clickDB.reset();
 
                  zgLog_.reset();
-                 cgManager_.reset();
+                 jobs.reset();
+
+                 auto dohandle = [&](guint& handle) {
+                     if (handle != 0)
+                     {
+                         g_dbus_connection_signal_unsubscribe(_dbus.get(), handle);
+                         handle = 0;
+                     }
+                 };
+
+                 dohandle(handle_appStarted);
+                 dohandle(handle_appStopped);
+                 dohandle(handle_appFailed);
+                 dohandle(handle_appPaused);
+                 dohandle(handle_appResumed);
+                 dohandle(handle_managerSignalFocus);
+                 dohandle(handle_managerSignalResume);
+                 dohandle(handle_managerSignalStarting);
 
                  if (_dbus)
                      g_dbus_connection_flush_sync(_dbus.get(), nullptr, nullptr);
@@ -42,7 +59,6 @@
              })
     , _registry(registry)
     , _iconFinders()
-// _manager(nullptr)
 {
     auto cancel = thread.getCancellable();
     _dbus = thread.executeOnThread<std::shared_ptr<GDBusConnection>>([cancel]() {
@@ -214,257 +230,6 @@
     });
 }
 
-/** Initialize the CGManager connection, including a timeout to disconnect
-    as CGManager doesn't free resources entirely well. So it's better if
-    we connect and disconnect occationally */
-void Registry::Impl::initCGManager()
-{
-    if (cgManager_)
-        return;
-
-    std::promise<std::shared_ptr<GDBusConnection>> promise;
-    auto future = promise.get_future();
-
-    thread.executeOnThread([this, &promise]() {
-        bool use_session_bus = g_getenv("UBUNTU_APP_LAUNCH_CG_MANAGER_SESSION_BUS") != nullptr;
-        if (use_session_bus)
-        {
-            /* For working dbusmock */
-            g_debug("Connecting to CG Manager on session bus");
-            promise.set_value(_dbus);
-            return;
-        }
-
-        auto cancel =
-            std::shared_ptr<GCancellable>(g_cancellable_new(), [](GCancellable* cancel) { g_clear_object(&cancel); });
-
-        /* Ensure that we do not wait for more than a second */
-        thread.timeoutSeconds(std::chrono::seconds{1}, [cancel]() { g_cancellable_cancel(cancel.get()); });
-
-        g_dbus_connection_new_for_address(
-            CGMANAGER_DBUS_PATH,                           /* cgmanager path */
-            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, /* flags */
-            nullptr,                                       /* Auth Observer */
-            cancel.get(),                                  /* Cancellable */
-            [](GObject* obj, GAsyncResult* res, gpointer data) -> void {
-                GError* error = nullptr;
-                auto promise = reinterpret_cast<std::promise<std::shared_ptr<GDBusConnection>>*>(data);
-
-                auto gcon = g_dbus_connection_new_for_address_finish(res, &error);
-                if (error != nullptr)
-                {
-                    g_error_free(error);
-                }
-
-                auto con = std::shared_ptr<GDBusConnection>(gcon, [](GDBusConnection* con) { g_clear_object(&con); });
-                promise->set_value(con);
-            },
-            &promise);
-    });
-
-    cgManager_ = future.get();
-    thread.timeoutSeconds(std::chrono::seconds{10}, [this]() { cgManager_.reset(); });
-}
-
-/** Get a list of PIDs from a CGroup, uses the CGManager connection to list
-    all of the PIDs. It is important to note that this is an IPC call, so it can
-    by its nature, be racy. Once the message has been sent the group can change.
-    You should take that into account in your usage of it. */
-std::vector<pid_t> Registry::Impl::pidsFromCgroup(const std::string& jobpath)
-{
-    initCGManager();
-    auto lmanager = cgManager_; /* Grab a local copy so we ensure it lasts through our lifetime */
-
-    return thread.executeOnThread<std::vector<pid_t>>([&jobpath, lmanager]() -> std::vector<pid_t> {
-        GError* error = nullptr;
-        const gchar* name = g_getenv("UBUNTU_APP_LAUNCH_CG_MANAGER_NAME");
-        std::string groupname;
-        if (!jobpath.empty())
-        {
-            groupname = "upstart/" + jobpath;
-        }
-
-        g_debug("Looking for cg manager '%s' group '%s'", name, groupname.c_str());
-
-        GVariant* vtpids = g_dbus_connection_call_sync(
-            lmanager.get(),                     /* connection */
-            name,                               /* bus name for direct connection is NULL */
-            "/org/linuxcontainers/cgmanager",   /* object */
-            "org.linuxcontainers.cgmanager0_0", /* interface */
-            "GetTasksRecursive",                /* method */
-            g_variant_new("(ss)", "freezer", groupname.empty() ? "" : groupname.c_str()), /* params */
-            G_VARIANT_TYPE("(ai)"),                                                       /* output */
-            G_DBUS_CALL_FLAGS_NONE,                                                       /* flags */
-            -1,                                                                           /* default timeout */
-            nullptr,                                                                      /* cancellable */
-            &error);                                                                      /* error */
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to get PID list from cgroup manager: %s", error->message);
-            g_error_free(error);
-            return {};
-        }
-
-        GVariant* vpids = g_variant_get_child_value(vtpids, 0);
-        GVariantIter iter;
-        g_variant_iter_init(&iter, vpids);
-        gint32 pid;
-        std::vector<pid_t> pids;
-
-        while (g_variant_iter_loop(&iter, "i", &pid))
-        {
-            pids.push_back(pid);
-        }
-
-        g_variant_unref(vpids);
-        g_variant_unref(vtpids);
-
-        return pids;
-    });
-}
-
-/** Looks to find the Upstart object path for a specific Upstart job. This first
-    checks the cache, and otherwise does the lookup on DBus. */
-std::string Registry::Impl::upstartJobPath(const std::string& job)
-{
-    try
-    {
-        return upstartJobPathCache_.at(job);
-    }
-    catch (std::out_of_range& e)
-    {
-        auto path = thread.executeOnThread<std::string>([this, &job]() -> std::string {
-            GError* error = nullptr;
-            GVariant* job_path_variant = g_dbus_connection_call_sync(_dbus.get(),                       /* connection */
-                                                                     DBUS_SERVICE_UPSTART,              /* service */
-                                                                     DBUS_PATH_UPSTART,                 /* path */
-                                                                     DBUS_INTERFACE_UPSTART,            /* iface */
-                                                                     "GetJobByName",                    /* method */
-                                                                     g_variant_new("(s)", job.c_str()), /* params */
-                                                                     G_VARIANT_TYPE("(o)"),             /* return */
-                                                                     G_DBUS_CALL_FLAGS_NONE,            /* flags */
-                                                                     -1, /* timeout: default */
-                                                                     thread.getCancellable().get(), /* cancellable */
-                                                                     &error);                       /* error */
-
-            if (error != nullptr)
-            {
-                g_warning("Unable to find job '%s': %s", job.c_str(), error->message);
-                g_error_free(error);
-                return {};
-            }
-
-            gchar* job_path = nullptr;
-            g_variant_get(job_path_variant, "(o)", &job_path);
-            g_variant_unref(job_path_variant);
-
-            if (job_path != nullptr)
-            {
-                std::string path(job_path);
-                g_free(job_path);
-                return path;
-            }
-            else
-            {
-                return {};
-            }
-        });
-
-        upstartJobPathCache_[job] = path;
-        return path;
-    }
-}
-
-/** Queries Upstart to get all the instances of a given job. This
-    can take a while as the number of dbus calls is n+1. It is
-    rare that apps have many instances though. */
-std::list<std::string> Registry::Impl::upstartInstancesForJob(const std::string& job)
-{
-    std::string jobpath = upstartJobPath(job);
-    if (jobpath.empty())
-    {
-        return {};
-    }
-
-    return thread.executeOnThread<std::list<std::string>>([this, &job, &jobpath]() -> std::list<std::string> {
-        GError* error = nullptr;
-        GVariant* instance_tuple = g_dbus_connection_call_sync(_dbus.get(),                   /* connection */
-                                                               DBUS_SERVICE_UPSTART,          /* service */
-                                                               jobpath.c_str(),               /* object path */
-                                                               DBUS_INTERFACE_UPSTART_JOB,    /* iface */
-                                                               "GetAllInstances",             /* method */
-                                                               nullptr,                       /* params */
-                                                               G_VARIANT_TYPE("(ao)"),        /* return type */
-                                                               G_DBUS_CALL_FLAGS_NONE,        /* flags */
-                                                               -1,                            /* timeout: default */
-                                                               thread.getCancellable().get(), /* cancellable */
-                                                               &error);
-
-        if (error != nullptr)
-        {
-            g_warning("Unable to get instances of job '%s': %s", job.c_str(), error->message);
-            g_error_free(error);
-            return {};
-        }
-
-        if (instance_tuple == nullptr)
-        {
-            return {};
-        }
-
-        GVariant* instance_list = g_variant_get_child_value(instance_tuple, 0);
-        g_variant_unref(instance_tuple);
-
-        GVariantIter instance_iter;
-        g_variant_iter_init(&instance_iter, instance_list);
-        const gchar* instance_path = nullptr;
-        std::list<std::string> instances;
-
-        while (g_variant_iter_loop(&instance_iter, "&o", &instance_path))
-        {
-            GVariant* props_tuple =
-                g_dbus_connection_call_sync(_dbus.get(),                                           /* connection */
-                                            DBUS_SERVICE_UPSTART,                                  /* service */
-                                            instance_path,                                         /* object path */
-                                            "org.freedesktop.DBus.Properties",                     /* interface */
-                                            "GetAll",                                              /* method */
-                                            g_variant_new("(s)", DBUS_INTERFACE_UPSTART_INSTANCE), /* params */
-                                            G_VARIANT_TYPE("(a{sv})"),                             /* return type */
-                                            G_DBUS_CALL_FLAGS_NONE,                                /* flags */
-                                            -1,                            /* timeout: default */
-                                            thread.getCancellable().get(), /* cancellable */
-                                            &error);
-
-            if (error != nullptr)
-            {
-                g_warning("Unable to name of instance '%s': %s", instance_path, error->message);
-                g_error_free(error);
-                error = nullptr;
-                continue;
-            }
-
-            GVariant* props_dict = g_variant_get_child_value(props_tuple, 0);
-
-            GVariant* namev = g_variant_lookup_value(props_dict, "name", G_VARIANT_TYPE_STRING);
-            if (namev != nullptr)
-            {
-                auto name = g_variant_get_string(namev, NULL);
-                g_debug("Adding instance for job '%s': %s", job.c_str(), name);
-                instances.push_back(name);
-                g_variant_unref(namev);
-            }
-
-            g_variant_unref(props_dict);
-            g_variant_unref(props_tuple);
-        }
-
-        g_variant_unref(instance_list);
-
-        return instances;
-    });
-}
-
 /** Send an event to Zietgeist using the registry thread so that
         the callback comes back in the right place. */
 void Registry::Impl::zgSendEvent(AppID appid, const std::string& eventtype)
@@ -536,24 +301,193 @@
     return _iconFinders[basePath];
 }
 
-#if 0
-void
-Registry::Impl::setManager (Registry::Manager* manager)
-{
-    if (_manager != nullptr)
+/** Structure to track the data needed for upstart events. This cleans
+    up the lifecycle as we're passing this as a pointer through the
+    GLib calls. */
+struct upstartEventData
+{
+    /** Keeping a weak pointer because the handle is held by
+        the registry implementation. */
+    std::weak_ptr<Registry> weakReg;
+};
+
+/** Take the GVariant of parameters and turn them into an application and
+    and instance. Easier to read in the smaller function */
+std::tuple<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> Registry::Impl::managerParams(
+    const std::shared_ptr<GVariant>& params, const std::shared_ptr<Registry>& reg)
+{
+    std::shared_ptr<Application> app;
+    std::shared_ptr<Application::Instance> instance;
+
+    const gchar* cappid = nullptr;
+    g_variant_get(params.get(), "(&s)", &cappid);
+
+    auto appid = ubuntu::app_launch::AppID::find(reg, cappid);
+    app = ubuntu::app_launch::Application::create(appid, reg);
+
+    return std::make_tuple(app, instance);
+}
+
+/** Used to store data for manager based signal handlers. Has a link to the
+    registry and the callback to use in a C++ style. */
+struct managerEventData
+{
+    /* Keeping a weak pointer because the handle is held by
+       the registry implementation. */
+    std::weak_ptr<Registry> weakReg;
+    std::function<void(const std::shared_ptr<Registry>& reg,
+                       const std::shared_ptr<Application>& app,
+                       const std::shared_ptr<Application::Instance>& instance,
+                       const std::shared_ptr<GDBusConnection>&,
+                       const std::string&,
+                       const std::shared_ptr<GVariant>&)>
+        func;
+};
+
+/** Register for a signal for the manager. All of the signals needed this same
+    code so it got pulled out into a function. Takes the same of the signal, the registry
+    that we're using and a function to call after we've messaged all the parameters
+    into being something C++-ish. */
+guint Registry::Impl::managerSignalHelper(const std::shared_ptr<Registry>& reg,
+                                          const std::string& signalname,
+                                          std::function<void(const std::shared_ptr<Registry>& reg,
+                                                             const std::shared_ptr<Application>& app,
+                                                             const std::shared_ptr<Application::Instance>& instance,
+                                                             const std::shared_ptr<GDBusConnection>&,
+                                                             const std::string&,
+                                                             const std::shared_ptr<GVariant>&)> responsefunc)
+{
+    managerEventData* focusdata = new managerEventData{reg, responsefunc};
+
+    return g_dbus_connection_signal_subscribe(
+        reg->impl->_dbus.get(),          /* bus */
+        nullptr,                         /* sender */
+        "com.canonical.UbuntuAppLaunch", /* interface */
+        signalname.c_str(),              /* signal */
+        "/",                             /* path */
+        nullptr,                         /* arg0 */
+        G_DBUS_SIGNAL_FLAGS_NONE,
+        [](GDBusConnection* cconn, const gchar* csender, const gchar*, const gchar*, const gchar*, GVariant* params,
+           gpointer user_data) -> void {
+            auto data = reinterpret_cast<managerEventData*>(user_data);
+            auto reg = data->weakReg.lock();
+
+            /* If we're still conneted and the manager has been cleared
+               we'll just be a no-op */
+            if (!reg->impl->manager_)
+            {
+                return;
+            }
+
+            auto vparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+            auto conn = std::shared_ptr<GDBusConnection>(reinterpret_cast<GDBusConnection*>(g_object_ref(cconn)),
+                                                         [](GDBusConnection* con) { g_clear_object(&con); });
+            std::string sender = csender;
+            std::shared_ptr<Application> app;
+            std::shared_ptr<Application::Instance> instance;
+
+            std::tie(app, instance) = managerParams(vparams, reg);
+
+            data->func(reg, app, instance, conn, sender, vparams);
+        },
+        focusdata,
+        [](gpointer user_data) {
+            auto data = reinterpret_cast<managerEventData*>(user_data);
+            delete data;
+        }); /* user data destroy */
+}
+
+/** Set the manager for the registry. This includes tracking the pointer
+    as well as setting up the signals to call back into the manager. The
+    signals are only setup once per registry even if the manager is cleared
+    and changed again. They will just be no-op's in those cases.
+*/
+void Registry::Impl::setManager(std::shared_ptr<Registry::Manager> manager, std::shared_ptr<Registry> reg)
+{
+    if (reg->impl->manager_)
     {
         throw std::runtime_error("Already have a manager and trying to set another");
     }
 
-    _manager = manager;
+    g_debug("Setting a new manager");
+    reg->impl->manager_ = manager;
+
+    std::call_once(reg->impl->flag_managerSignals, [reg]() {
+        if (!reg->impl->thread.executeOnThread<bool>([reg]() {
+                reg->impl->handle_managerSignalFocus = managerSignalHelper(
+                    reg, "UnityFocusRequest",
+                    [](const std::shared_ptr<Registry>& reg, const std::shared_ptr<Application>& app,
+                       const std::shared_ptr<Application::Instance>& instance,
+                       const std::shared_ptr<GDBusConnection>& conn, const std::string& sender,
+                       const std::shared_ptr<GVariant>& params) {
+                        /* Nothing to do today */
+                        reg->impl->manager_->focusRequest(app, instance, [](bool response) {
+                            /* NOTE: We have no clue what thread this is gonna be
+                               executed on, but since we're just talking to the GDBus
+                               thread it isn't an issue today. Be careful in changing
+                               this code. */
+                        });
+                    });
+                reg->impl->handle_managerSignalStarting = managerSignalHelper(
+                    reg, "UnityStartingBroadcast",
+                    [](const std::shared_ptr<Registry>& reg, const std::shared_ptr<Application>& app,
+                       const std::shared_ptr<Application::Instance>& instance,
+                       const std::shared_ptr<GDBusConnection>& conn, const std::string& sender,
+                       const std::shared_ptr<GVariant>& params) {
+
+                        reg->impl->manager_->startingRequest(app, instance, [conn, sender, params](bool response) {
+                            /* NOTE: We have no clue what thread this is gonna be
+                               executed on, but since we're just talking to the GDBus
+                               thread it isn't an issue today. Be careful in changing
+                               this code. */
+                            if (response)
+                            {
+                                g_dbus_connection_emit_signal(conn.get(), sender.c_str(),      /* destination */
+                                                              "/",                             /* path */
+                                                              "com.canonical.UbuntuAppLaunch", /* interface */
+                                                              "UnityStartingSignal",           /* signal */
+                                                              params.get(),                    /* params, the same */
+                                                              nullptr);                        /* error */
+                            }
+                        });
+                    });
+                reg->impl->handle_managerSignalResume = managerSignalHelper(
+                    reg, "UnityResumeRequest",
+                    [](const std::shared_ptr<Registry>& reg, const std::shared_ptr<Application>& app,
+                       const std::shared_ptr<Application::Instance>& instance,
+                       const std::shared_ptr<GDBusConnection>& conn, const std::string& sender,
+                       const std::shared_ptr<GVariant>& params) {
+                        reg->impl->manager_->resumeRequest(app, instance, [conn, sender, params](bool response) {
+                            /* NOTE: We have no clue what thread this is gonna be
+                               executed on, but since we're just talking to the GDBus
+                               thread it isn't an issue today. Be careful in changing
+                               this code. */
+                            if (response)
+                            {
+                                g_dbus_connection_emit_signal(conn.get(), sender.c_str(),      /* destination */
+                                                              "/",                             /* path */
+                                                              "com.canonical.UbuntuAppLaunch", /* interface */
+                                                              "UnityResumeResponse",           /* signal */
+                                                              params.get(),                    /* params, the same */
+                                                              nullptr);                        /* error */
+                            }
+                        });
+                    });
+
+                return true;
+            }))
+        {
+            g_warning("Unable to install manager signals");
+        }
+    });
 }
 
-void
-Registry::Impl::clearManager ()
+/** Clear the manager pointer */
+void Registry::Impl::clearManager()
 {
-    _manager = nullptr;
+    g_debug("Clearing the manager");
+    manager_.reset();
 }
-#endif
 
 /** App start watching, if we're registered for the signal we
     can't wait on it. We are making this static right now because
@@ -576,5 +510,301 @@
     return watchingAppStarting_;
 }
 
+/** Regex to parse the JOB environment variable from Upstart */
+std::regex jobenv_regex{"^JOB=(application\\-(?:click|snap|legacy))$"};
+/** Regex to parse the INSTANCE environment variable from Upstart */
+std::regex instanceenv_regex{"^INSTANCE=(.*?)(?:\\-([0-9]*))?+$"};
+
+/** Core of most of the events that come from Upstart directly. Includes parsing of the
+    Upstart event environment and calling the appropriate signal with the right Application
+    object and eventually its instance */
+void Registry::Impl::upstartEventEmitted(
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& signal,
+    std::shared_ptr<GVariant> params,
+    const std::shared_ptr<Registry>& reg)
+{
+    std::string jobname;
+    std::string sappid;
+    std::string instance;
+
+    gchar* env = nullptr;
+    GVariant* envs = g_variant_get_child_value(params.get(), 1);
+    GVariantIter iter;
+    g_variant_iter_init(&iter, envs);
+
+    while (g_variant_iter_loop(&iter, "s", &env))
+    {
+        std::smatch match;
+        std::string senv = env;
+
+        if (std::regex_match(senv, match, jobenv_regex))
+        {
+            jobname = match[1].str();
+        }
+        else if (std::regex_match(senv, match, instanceenv_regex))
+        {
+            sappid = match[1].str();
+            instance = match[2].str();
+        }
+    }
+
+    g_variant_unref(envs);
+
+    if (jobname.empty())
+    {
+        return;
+    }
+
+    g_debug("Upstart Event for job '%s' appid '%s' instance '%s'", jobname.c_str(), sappid.c_str(), instance.c_str());
+
+    auto appid = AppID::find(reg, sappid);
+    auto app = Application::create(appid, reg);
+
+    // TODO: Figure otu creating instances
+
+    signal(app, {});
+}
+
+/** Grab the signal object for application startup. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& Registry::Impl::appStarted(
+    const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appStarted, [reg]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appStarted = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(), /* bus */
+                nullptr,                /* sender */
+                DBUS_INTERFACE_UPSTART, /* interface */
+                "EventEmitted",         /* signal */
+                DBUS_PATH_UPSTART,      /* path */
+                "started",              /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+                    reg->impl->upstartEventEmitted(reg->impl->sig_appStarted, sparams, reg);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appStarted;
+}
+
+/** Grab the signal object for application stopping. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& Registry::Impl::appStopped(
+    const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appStopped, [reg]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appStopped = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(), /* bus */
+                nullptr,                /* sender */
+                DBUS_INTERFACE_UPSTART, /* interface */
+                "EventEmitted",         /* signal */
+                DBUS_PATH_UPSTART,      /* path */
+                "stopped",              /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+                    reg->impl->upstartEventEmitted(reg->impl->sig_appStopped, sparams, reg);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appStopped;
+}
+
+/** Grab the signal object for application failing. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, Registry::FailureType>&
+    Registry::Impl::appFailed(const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appFailed, [reg]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appFailed = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(),          /* bus */
+                nullptr,                         /* sender */
+                "com.canonical.UbuntuAppLaunch", /* interface */
+                "ApplicationFailed",             /* signal */
+                "/",                             /* path */
+                nullptr,                         /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+
+                    const gchar* sappid = NULL;
+                    const gchar* typestr = NULL;
+
+                    Registry::FailureType type = Registry::FailureType::CRASH;
+                    g_variant_get(params, "(&s&s)", &sappid, &typestr);
+
+                    if (g_strcmp0("crash", typestr) == 0)
+                    {
+                        type = Registry::FailureType::CRASH;
+                    }
+                    else if (g_strcmp0("start-failure", typestr) == 0)
+                    {
+                        type = Registry::FailureType::START_FAILURE;
+                    }
+                    else
+                    {
+                        g_warning("Application failure type '%s' unknown, reporting as a crash", typestr);
+                    }
+
+                    auto appid = AppID::find(reg, sappid);
+                    auto app = Application::create(appid, reg);
+
+                    /* TODO: Instance issues */
+
+                    reg->impl->sig_appFailed(app, {}, type);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appFailed;
+}
+
+/** Core handler for pause and resume events. Includes turning the GVariant
+    pid list into a std::vector and getting the application object. */
+void Registry::Impl::pauseEventEmitted(
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>& signal,
+    const std::shared_ptr<GVariant>& params,
+    const std::shared_ptr<Registry>& reg)
+{
+    std::vector<pid_t> pids;
+    GVariant* vappid = g_variant_get_child_value(params.get(), 0);
+    GVariant* vpids = g_variant_get_child_value(params.get(), 1);
+    guint64 pid;
+    GVariantIter thispid;
+    g_variant_iter_init(&thispid, vpids);
+
+    while (g_variant_iter_loop(&thispid, "t", &pid))
+    {
+        pids.emplace_back(pid);
+    }
+
+    auto cappid = g_variant_get_string(vappid, NULL);
+    auto appid = ubuntu::app_launch::AppID::find(reg, cappid);
+    auto app = Application::create(appid, reg);
+
+    /* TODO: Instance */
+    signal(app, {}, pids);
+
+    g_variant_unref(vappid);
+    g_variant_unref(vpids);
+
+    return;
+}
+
+/** Grab the signal object for application paused. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    Registry::Impl::appPaused(const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appPaused, [&]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appPaused = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(),          /* bus */
+                nullptr,                         /* sender */
+                "com.canonical.UbuntuAppLaunch", /* interface */
+                "ApplicationPaused",             /* signal */
+                "/",                             /* path */
+                nullptr,                         /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+                    reg->impl->pauseEventEmitted(reg->impl->sig_appPaused, sparams, reg);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appPaused;
+}
+
+/** Grab the signal object for application resumed. If we're not already listing for
+    those signals this sets up a listener for them. */
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    Registry::Impl::appResumed(const std::shared_ptr<Registry>& reg)
+{
+    std::call_once(flag_appResumed, [&]() {
+        reg->impl->thread.executeOnThread<bool>([reg]() {
+            upstartEventData* data = new upstartEventData{reg};
+
+            reg->impl->handle_appResumed = g_dbus_connection_signal_subscribe(
+                reg->impl->_dbus.get(),          /* bus */
+                nullptr,                         /* sender */
+                "com.canonical.UbuntuAppLaunch", /* interface */
+                "ApplicationResumed",            /* signal */
+                "/",                             /* path */
+                nullptr,                         /* arg0 */
+                G_DBUS_SIGNAL_FLAGS_NONE,
+                [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* params,
+                   gpointer user_data) -> void {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    auto reg = data->weakReg.lock();
+                    auto sparams = std::shared_ptr<GVariant>(g_variant_ref(params), g_variant_unref);
+                    reg->impl->pauseEventEmitted(reg->impl->sig_appResumed, sparams, reg);
+                },    /* callback */
+                data, /* user data */
+                [](gpointer user_data) {
+                    auto data = reinterpret_cast<upstartEventData*>(user_data);
+                    delete data;
+                }); /* user data destroy */
+
+            return true;
+        });
+    });
+
+    return sig_appResumed;
+}
+
 }  // namespace app_launch
 }  // namespace ubuntu

=== modified file 'libubuntu-app-launch/registry-impl.h'
--- libubuntu-app-launch/registry-impl.h	2016-09-23 22:30:51 +0000
+++ libubuntu-app-launch/registry-impl.h	2016-11-10 21:58:30 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "glib-thread.h"
+#include "jobs-base.h"
 #include "registry.h"
 #include "snapd-info.h"
 #include <click.h>
@@ -53,10 +54,8 @@
     std::list<AppID::Package> getClickPackages();
     std::string getClickDir(const std::string& package);
 
-#if 0
-    void setManager (Registry::Manager* manager);
-    void clearManager ();
-#endif
+    static void setManager(std::shared_ptr<Registry::Manager> manager, std::shared_ptr<Registry> registry);
+    void clearManager();
 
     /** Shared context thread for events and background tasks
         that UAL subtasks are doing */
@@ -69,19 +68,27 @@
     snapd::Info snapdInfo;
 #endif
 
+    std::shared_ptr<jobs::manager::Base> jobs;
+
     std::shared_ptr<IconFinder> getIconFinder(std::string basePath);
 
     void zgSendEvent(AppID appid, const std::string& eventtype);
 
-    std::vector<pid_t> pidsFromCgroup(const std::string& jobpath);
-
-    /* Upstart Jobs */
-    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);
 
+    /* Signals to discover what is happening to apps */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStarted(
+        const std::shared_ptr<Registry>& reg);
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStopped(
+        const std::shared_ptr<Registry>& reg);
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, FailureType>& appFailed(
+        const std::shared_ptr<Registry>& reg);
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>& appPaused(
+        const std::shared_ptr<Registry>& reg);
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>& appResumed(
+        const std::shared_ptr<Registry>& reg);
+
     /* 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 */
@@ -89,27 +96,73 @@
     static bool isWatchingAppStarting();
 
 private:
-    Registry* _registry;
-#if 0
-    Registry::Manager* _manager;
-#endif
-
-    std::shared_ptr<ClickDB> _clickDB;
-    std::shared_ptr<ClickUser> _clickUser;
+    Registry* _registry;                         /**< The Registry that we're spawned from */
+    std::shared_ptr<Registry::Manager> manager_; /**< Application manager if registered */
+
+    std::shared_ptr<ClickDB> _clickDB;     /**< Shared instance of the Click Database */
+    std::shared_ptr<ClickUser> _clickUser; /**< Click database filtered by the current user */
+
+    /** Signal object for applications started */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> sig_appStarted;
+    /** Signal object for applications stopped */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> sig_appStopped;
+    /** Signal object for applications failed */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, FailureType> sig_appFailed;
+    /** Signal object for applications paused */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>
+        sig_appPaused;
+    /** Signal object for applications resumed */
+    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>
+        sig_appResumed;
+
+    guint handle_appStarted{0};            /**< GDBus signal watcher handle for app started signal */
+    guint handle_appStopped{0};            /**< GDBus signal watcher handle for app stopped signal */
+    guint handle_appFailed{0};             /**< GDBus signal watcher handle for app failed signal */
+    guint handle_appPaused{0};             /**< GDBus signal watcher handle for app paused signal */
+    guint handle_appResumed{0};            /**< GDBus signal watcher handle for app resumed signal */
+    guint handle_managerSignalFocus{0};    /**< GDBus signal watcher handle for app focused signal */
+    guint handle_managerSignalResume{0};   /**< GDBus signal watcher handle for app resumed signal */
+    guint handle_managerSignalStarting{0}; /**< GDBus signal watcher handle for app starting signal */
+
+    std::once_flag flag_appStarted; /**< Variable to track to see if signal handlers are installed for application
+                                       started */
+    std::once_flag flag_appStopped; /**< Variable to track to see if signal handlers are installed for application
+                                       stopped */
+    std::once_flag
+        flag_appFailed; /**< Variable to track to see if signal handlers are installed for application failed */
+    std::once_flag
+        flag_appPaused; /**< Variable to track to see if signal handlers are installed for application paused */
+    std::once_flag flag_appResumed;     /**< Variable to track to see if signal handlers are installed for application
+                                           resumed */
+    std::once_flag flag_managerSignals; /**< Variable to track to see if signal handlers are installed for the manager
+                                           signals of focused, resumed and starting */
+
+    void upstartEventEmitted(core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& signal,
+                             std::shared_ptr<GVariant> params,
+                             const std::shared_ptr<Registry>& reg);
+    void pauseEventEmitted(
+        core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>& signal,
+        const std::shared_ptr<GVariant>& params,
+        const std::shared_ptr<Registry>& reg);
+    static std::tuple<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> managerParams(
+        const std::shared_ptr<GVariant>& params, const std::shared_ptr<Registry>& reg);
+    static guint managerSignalHelper(const std::shared_ptr<Registry>& reg,
+                                     const std::string& signalname,
+                                     std::function<void(const std::shared_ptr<Registry>& reg,
+                                                        const std::shared_ptr<Application>& app,
+                                                        const std::shared_ptr<Application::Instance>& instance,
+                                                        const std::shared_ptr<GDBusConnection>&,
+                                                        const std::string&,
+                                                        const std::shared_ptr<GVariant>&)> responsefunc);
 
     void initClick();
 
+    /** Shared instance of the Zeitgeist Log */
     std::shared_ptr<ZeitgeistLog> zgLog_;
 
-    std::shared_ptr<GDBusConnection> cgManager_;
-
-    void initCGManager();
-
+    /** All of our icon finders based on the path that they're looking
+        into */
     std::unordered_map<std::string, std::shared_ptr<IconFinder>> _iconFinders;
-
-    /** Getting the Upstart job path is relatively expensive in
-        that it requires a DBus call. Worth keeping a cache of. */
-    std::map<std::string, std::string> upstartJobPathCache_;
 };
 
 }  // namespace app_launch

=== modified file 'libubuntu-app-launch/registry.cpp'
--- libubuntu-app-launch/registry.cpp	2016-08-26 17:33:34 +0000
+++ libubuntu-app-launch/registry.cpp	2016-11-10 21:58:30 +0000
@@ -47,61 +47,14 @@
 {
 }
 
-std::list<std::shared_ptr<Application>> Registry::runningApps(std::shared_ptr<Registry> connection)
+std::list<std::shared_ptr<Application>> Registry::runningApps(std::shared_ptr<Registry> registry)
 {
-    std::list<std::string> instances;
-
-    /* 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 {
-        static const std::regex instanceregex("^(.*)-[0-9]*$");
-        std::smatch match;
-        if (std::regex_match(instancename, match, instanceregex))
-        {
-            return match[1].str();
-        }
-        else
-        {
-            g_warning("Unable to match instance name: %s", instancename.c_str());
-            return {};
-        }
-    });
-
-    /* Deduplicate Set */
-    std::set<std::string> instanceset;
-    for (auto instance : instances)
-    {
-        if (!instance.empty())
-            instanceset.insert(instance);
-    }
-
-    /* Add in the click instances */
-    for (auto instance : connection->impl->upstartInstancesForJob("application-click"))
-    {
-        instanceset.insert(instance);
-    }
-
-    g_debug("Overall there are %d instances: %s", int(instanceset.size()),
-            std::accumulate(instanceset.begin(), instanceset.end(), std::string{},
-                            [](const std::string &instr, std::string instance) {
-                                return instr.empty() ? instance : instr + ", " + instance;
-                            })
-                .c_str());
-
-    /* Convert to Applications */
-    std::list<std::shared_ptr<Application>> apps;
-    for (auto instance : instanceset)
-    {
-        auto appid = AppID::find(connection, instance);
-        auto app = Application::create(appid, connection);
-        apps.push_back(app);
-    }
-
-    return apps;
+    if (!registry->impl->jobs)
+    {
+        registry->impl->jobs = jobs::manager::Base::determineFactory(registry);
+    }
+
+    return registry->impl->jobs->runningApps();
 }
 
 std::list<std::shared_ptr<Application>> Registry::installedApps(std::shared_ptr<Registry> connection)
@@ -127,6 +80,16 @@
     return list;
 }
 
+void Registry::setManager(std::shared_ptr<Manager> manager, std::shared_ptr<Registry> registry)
+{
+    Registry::Impl::setManager(manager, registry);
+}
+
+void Registry::clearManager()
+{
+    impl->clearManager();
+}
+
 std::shared_ptr<Registry> defaultRegistry;
 std::shared_ptr<Registry> Registry::getDefault()
 {
@@ -143,5 +106,35 @@
     defaultRegistry.reset();
 }
 
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& Registry::appStarted(
+    const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appStarted(reg);
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& Registry::appStopped(
+    const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appStopped(reg);
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, Registry::FailureType>&
+    Registry::appFailed(const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appFailed(reg);
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    Registry::appPaused(const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appPaused(reg);
+}
+
+core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+    Registry::appResumed(const std::shared_ptr<Registry>& reg)
+{
+    return reg->impl->appResumed(reg);
+}
+
 }  // namespace app_launch
 }  // namespace ubuntu

=== modified file 'libubuntu-app-launch/registry.h'
--- libubuntu-app-launch/registry.h	2016-06-09 14:55:34 +0000
+++ libubuntu-app-launch/registry.h	2016-11-10 21:58:30 +0000
@@ -73,28 +73,134 @@
     */
     static std::list<std::shared_ptr<Application>> installedApps(std::shared_ptr<Registry> registry = getDefault());
 
-#if 0 /* TODO -- In next MR */
     /* Signals to discover what is happening to apps */
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> appStarted;
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> appStopped;
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, FailureType> appFailed;
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> appPaused;
-    core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>> appResumed;
-
-    /* The Application Manager, almost always if you're not Unity8, don't
-       use this API. Testing is a special case. */
+    /** Get the signal object that is signaled when an application has been
+        started.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStarted(
+        const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** Get the signal object that is signaled when an application has stopped.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>>& appStopped(
+        const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** Get the signal object that is signaled when an application has failed.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, FailureType>& appFailed(
+        const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** Get the signal object that is signaled when an application has been
+        paused.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+        appPaused(const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** Get the signal object that is signaled when an application has been
+        resumed.
+
+        \note This singal handler is activated on the UAL thread, if you want
+            to execute on a different thread you'll need to move the work.
+
+        \param reg Registry to get the handler from
+    */
+    static core::Signal<std::shared_ptr<Application>, std::shared_ptr<Application::Instance>, std::vector<pid_t>&>&
+        appResumed(const std::shared_ptr<Registry>& reg = getDefault());
+
+    /** The Application Manager, almost always if you're not Unity8, don't
+        use this API. Testing is a special case. Subclass this interface and
+        implement these functions.
+
+        Each function here is being passed a function object that takes a boolean
+        to reply. This will accept or reject the request. The function object
+        can be copied to another thread and executed if needed.
+    */
     class Manager
     {
-        virtual bool focusRequest (std::shared_ptr<Application> app, std::shared_ptr<Application::Instance> instance) = 0;
-        virtual bool startingRequest (std::shared_ptr<Application> app, std::shared_ptr<Application::Instance> instance) = 0;
+    public:
+        /** Application wishes to startup
+
+            \note This singal handler is activated on the UAL thread, if you want
+                to execute on a different thread you'll need to move the work.
+
+            \param app Application requesting startup
+            \param instance Instance of the app, always valid but not useful
+                        unless mulit-instance app.
+            \param reply Function object to reply if it is allowed to start
+        */
+        virtual void startingRequest(std::shared_ptr<Application> app,
+                                     std::shared_ptr<Application::Instance> instance,
+                                     std::function<void(bool)> reply) = 0;
+
+        /** Application wishes to have focus. Usually this occurs when
+            a URL for the application is activated and the running app is
+            requested.
+
+            \note This singal handler is activated on the UAL thread, if you want
+                to execute on a different thread you'll need to move the work.
+
+            \param app Application requesting focus
+            \param instance Instance of the app, always valid but not useful
+                        unless mulit-instance app.
+            \param reply Function object to reply if it is allowed to focus
+        */
+        virtual void focusRequest(std::shared_ptr<Application> app,
+                                  std::shared_ptr<Application::Instance> instance,
+                                  std::function<void(bool)> reply) = 0;
+
+        /** Application wishes to resume. Usually this occurs when
+            a URL for the application is activated and the running app is
+            requested.
+
+            \note This singal handler is activated on the UAL thread, if you want
+                to execute on a different thread you'll need to move the work.
+
+            \param app Application requesting resume
+            \param instance Instance of the app, always valid but not useful
+                        unless mulit-instance app.
+            \param reply Function object to reply if it is allowed to resume
+        */
+        virtual void resumeRequest(std::shared_ptr<Application> app,
+                                   std::shared_ptr<Application::Instance> instance,
+                                   std::function<void(bool)> reply) = 0;
 
     protected:
         Manager() = default;
     };
 
-    void setManager (Manager* manager);
-    void clearManager ();
-#endif
+    /** Set the manager of applications, which gives permissions for them to
+        start and gain focus. In almost all cases this should be Unity8 as it
+        will be controlling applications.
+
+        This function will failure if there is already a manager set.
+
+        \param manager A reference to the Manager object to call
+        \param registry Registry to register the manager on
+    */
+    static void setManager(std::shared_ptr<Manager> manager, std::shared_ptr<Registry> registry);
+
+    /** Remove the current manager on the registry */
+    void clearManager();
 
     /* Helper Lists */
     /** Get a list of all the helpers for a given helper type

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.cpp'
--- libubuntu-app-launch/ubuntu-app-launch.cpp	2016-09-14 21:58:39 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.cpp	2016-11-10 21:58:30 +0000
@@ -39,6 +39,7 @@
 #include "appid.h"
 #include "registry.h"
 #include "registry-impl.h"
+#include <algorithm>
 
 static void free_helper (gpointer value);
 int kill (pid_t pid, int signal) noexcept;
@@ -271,155 +272,210 @@
 	gpointer user_data;
 };
 
-/* The data we keep for each failed observer */
-typedef struct _paused_resumed_observer_t paused_resumed_observer_t;
-struct _paused_resumed_observer_t {
-	GDBusConnection * conn;
-	guint sighandle;
-	UbuntuAppLaunchAppPausedResumedObserver func;
-	gpointer user_data;
-	const gchar * lttng_signal;
-};
-
-/* The lists of Observers */
-static GList * starting_array = NULL;
-static GList * started_array = NULL;
-static GList * stop_array = NULL;
-static GList * focus_array = NULL;
-static GList * resume_array = NULL;
-static GList * failed_array = NULL;
-static GList * paused_array = NULL;
-static GList * resumed_array = NULL;
-
-static void
-observer_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	observer_t * observer = (observer_t *)user_data;
-
-	const gchar * signalname = NULL;
-	g_variant_get_child(params, 0, "&s", &signalname);
-
-	ual_tracepoint(observer_start, signalname);
-
-	gchar * env = NULL;
-	GVariant * envs = g_variant_get_child_value(params, 1);
-	GVariantIter iter;
-	g_variant_iter_init(&iter, envs);
-
-	gboolean job_found = FALSE;
-	gboolean job_legacy = FALSE;
-	gchar * instance = NULL;
-
-	while (g_variant_iter_loop(&iter, "s", &env)) {
-		if (g_strcmp0(env, "JOB=application-click") == 0) {
-			job_found = TRUE;
-		} 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="));
-		}
-	}
-
-	g_variant_unref(envs);
-
-	if (job_legacy && instance != NULL) {
-		gchar * dash = g_strrstr(instance, "-");
-		if (dash != NULL) {
-			dash[0] = '\0';
-		}
-	}
-
-	if (job_found && instance != NULL) {
-		observer->func(instance, observer->user_data);
-	}
-
-	ual_tracepoint(observer_finish, signalname);
-
-	g_free(instance);
-}
-
-/* Creates the observer structure and registers for the signal with
-   GDBus so that we can get a callback */
-static gboolean
-add_app_generic (UbuntuAppLaunchAppObserver observer, gpointer user_data, const gchar * signal, GList ** list)
-{
-	GDBusConnection * conn = gdbus_upstart_ref();
-
-	if (conn == NULL) {
-		return FALSE;
-	}
-
-	observer_t * observert = g_new0(observer_t, 1);
-
-	observert->conn = conn;
-	observert->func = observer;
-	observert->user_data = user_data;
-
-	*list = g_list_prepend(*list, observert);
-
-	observert->sighandle = g_dbus_connection_signal_subscribe(conn,
-		NULL, /* sender */
-		DBUS_INTERFACE_UPSTART, /* interface */
-		"EventEmitted", /* signal */
-		DBUS_PATH_UPSTART, /* path */
-		signal, /* arg0 */
-		G_DBUS_SIGNAL_FLAGS_NONE,
-		observer_cb,
-		observert,
-		NULL); /* user data destroy */
-
-	return TRUE;
-}
+/* Function to take a work function and have it execute on a given
+   GMainContext */
+static void executeOnContext (std::shared_ptr<GMainContext> context, std::function<void()> work)
+{
+	if (!context) {
+		work();
+		return;
+	}
+
+    auto heapWork = new std::function<void()>(work);
+
+    auto source = std::shared_ptr<GSource>(g_idle_source_new(), [](GSource* src) { g_clear_pointer(&src, g_source_unref); });
+    g_source_set_callback(source.get(),
+                          [](gpointer data) {
+                              auto heapWork = static_cast<std::function<void()>*>(data);
+                              (*heapWork)();
+                              return G_SOURCE_REMOVE;
+                          },
+                          heapWork,
+                          [](gpointer data) {
+                              auto heapWork = static_cast<std::function<void()>*>(data);
+                              delete heapWork;
+                          });
+
+    g_source_attach(source.get(), context.get());
+}
+
+/* Map of all the observers listening for app started */
+static std::map<std::pair<UbuntuAppLaunchAppObserver, gpointer>, core::ScopedConnection> appStartedObservers;
 
 gboolean
 ubuntu_app_launch_observer_add_app_started (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	return add_app_generic(observer, user_data, "started", &started_array);
-}
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appStartedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appStarted().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+					std::string appid = app->appId();
+					executeOnContext(context, [appid, observer, user_data]() {
+						observer(appid.c_str(), user_data);
+					});
+				})
+			)
+		));
+
+	return TRUE;
+}
+
+gboolean
+ubuntu_app_launch_observer_delete_app_started (UbuntuAppLaunchAppObserver observer, gpointer user_data)
+{
+	auto iter = appStartedObservers.find(std::make_pair(observer, user_data));
+
+	if (iter == appStartedObservers.end()) {
+		return FALSE;
+	}
+
+	appStartedObservers.erase(iter);
+	return TRUE;
+}
+
+/* Map of all the observers listening for app stopped */
+static std::map<std::pair<UbuntuAppLaunchAppObserver, gpointer>, core::ScopedConnection> appStoppedObservers;
 
 gboolean
 ubuntu_app_launch_observer_add_app_stop (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	return add_app_generic(observer, user_data, "stopped", &stop_array);
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appStoppedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appStopped().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance) {
+					std::string appid = app->appId();
+					executeOnContext(context, [appid, observer, user_data]() {
+						observer(appid.c_str(), user_data);
+					});
+				})
+			)
+		));
+
+	return TRUE;
 }
 
-/* Creates the observer structure and registers for the signal with
-   GDBus so that we can get a callback */
-static gboolean
-add_session_generic (UbuntuAppLaunchAppObserver observer, gpointer user_data, const gchar * signal, GList ** list, GDBusSignalCallback session_cb)
+gboolean
+ubuntu_app_launch_observer_delete_app_stop (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	GDBusConnection * conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	auto iter = appStoppedObservers.find(std::make_pair(observer, user_data));
 
-	if (conn == NULL) {
+	if (iter == appStoppedObservers.end()) {
 		return FALSE;
 	}
 
-	observer_t * observert = g_new0(observer_t, 1);
-
-	observert->conn = conn;
-	observert->func = observer;
-	observert->user_data = user_data;
-
-	*list = g_list_prepend(*list, observert);
-
-	observert->sighandle = g_dbus_connection_signal_subscribe(conn,
-		NULL, /* sender */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		signal, /* signal */
-		"/", /* path */
-		NULL, /* arg0 */
-		G_DBUS_SIGNAL_FLAGS_NONE,
-		session_cb,
-		observert,
-		NULL); /* user data destroy */
-
+	appStoppedObservers.erase(iter);
 	return TRUE;
 }
 
+class CManager : public ubuntu::app_launch::Registry::Manager
+{
+public:
+	CManager () {
+		g_debug("Creating the CManager object");
+	}
+
+	void startingRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                                     std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                     std::function<void(bool)> reply) override {
+		std::string sappid = app->appId();
+		g_debug("CManager starting: %s", sappid.c_str());
+
+		for (const auto &data : startingList) {
+			executeOnContext(data.context, [data, sappid]() {
+				data.observer(sappid.c_str(), data.user_data);
+			});
+		}
+
+		reply(true);
+	}
+
+	void focusRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                                  std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                  std::function<void(bool)> reply) override {
+		std::string sappid = app->appId();
+		g_debug("CManager focus: %s", sappid.c_str());
+
+		for (const auto &data : focusList) {
+			executeOnContext(data.context, [data, sappid]() {
+				data.observer(sappid.c_str(), data.user_data);
+			});
+		}
+
+		reply(true);
+	}
+
+	void resumeRequest(std::shared_ptr<ubuntu::app_launch::Application> app,
+                                   std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                                   std::function<void(bool)> reply) override {
+		std::string sappid = app->appId();
+		g_debug("CManager resume: %s", sappid.c_str());
+
+		for (const auto &data : resumeList) {
+			executeOnContext(data.context, [data, sappid]() {
+				data.observer(sappid.c_str(), data.user_data);
+			});
+		}
+
+		reply(true);
+	}
+
+private:
+	struct ObserverData {
+		UbuntuAppLaunchAppObserver observer;
+		gpointer user_data;
+		std::shared_ptr<GMainContext> context;
+
+		ObserverData(UbuntuAppLaunchAppObserver obs, gpointer ud)
+			: observer(obs)
+			, user_data(ud) {
+			context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+		}
+	};
+
+	std::list<ObserverData> focusList;
+	std::list<ObserverData> resumeList;
+	std::list<ObserverData> startingList;
+
+	bool removeList (std::list<ObserverData> &list, UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		auto iter = std::find_if(list.begin(), list.end(), [observer, user_data](const ObserverData &data) {
+			return data.observer == observer && data.user_data == user_data;
+		});
+
+		if (iter == list.end()) {
+			return false;
+		}
+
+		list.erase(iter);
+		return true;
+	}
+
+public:
+	void addFocus (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		focusList.emplace_back(ObserverData(observer, user_data));
+	}
+	void addResume (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		resumeList.emplace_back(ObserverData(observer, user_data));
+	}
+	void addStarting (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		startingList.emplace_back(ObserverData(observer, user_data));
+	}
+	bool deleteFocus (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		return removeList(focusList, observer, user_data);
+	}
+	bool deleteResume (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		return removeList(resumeList, observer, user_data);
+	}
+	bool deleteStarting (UbuntuAppLaunchAppObserver observer, gpointer user_data) {
+		return removeList(startingList, observer, user_data);
+	}
+};
+
+static std::weak_ptr<CManager> cmanager;
+
 /* Generic handler for a bunch of our signals */
 static inline void
 generic_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
@@ -433,328 +489,158 @@
 	}
 }
 
-/* Handle the focus signal when it occurs, call the observer */
-static void
-focus_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	ual_tracepoint(observer_start, "focus");
-
-	generic_signal_cb(conn, sender, object, interface, signal, params, user_data);
-
-	ual_tracepoint(observer_finish, "focus");
-}
-
 gboolean
 ubuntu_app_launch_observer_add_app_focus (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	return add_session_generic(observer, user_data, "UnityFocusRequest", &focus_array, focus_signal_cb);
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		manager = std::make_shared<CManager>();
+		ubuntu::app_launch::Registry::setManager(manager, ubuntu::app_launch::Registry::getDefault());
+		cmanager = manager;
+	}
+
+	manager->addFocus(observer, user_data);
+	return TRUE;
 }
 
-/* Handle the resume signal when it occurs, call the observer, then send a signal back when we're done */
-static void
-resume_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
+gboolean
+ubuntu_app_launch_observer_delete_app_focus (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	ual_tracepoint(observer_start, "resume");
-
-	generic_signal_cb(conn, sender, object, interface, signal, params, user_data);
-
-	GError * error = NULL;
-	g_dbus_connection_emit_signal(conn,
-		sender, /* destination */
-		"/", /* path */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		"UnityResumeResponse", /* signal */
-		params, /* params, the same */
-		&error);
-
-	if (error != NULL) {
-		g_warning("Unable to emit response signal: %s", error->message);
-		g_error_free(error);
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		return FALSE;
 	}
 
-	ual_tracepoint(observer_finish, "resume");
+	return manager->deleteFocus(observer, user_data) ? TRUE : FALSE;
 }
 
 gboolean
 ubuntu_app_launch_observer_add_app_resume (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	return add_session_generic(observer, user_data, "UnityResumeRequest", &resume_array, resume_signal_cb);
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		manager = std::make_shared<CManager>();
+		ubuntu::app_launch::Registry::setManager(manager, ubuntu::app_launch::Registry::getDefault());
+		cmanager = manager;
+	}
+
+	manager->addResume(observer, user_data);
+	return TRUE;
 }
 
-/* Handle the starting signal when it occurs, call the observer, then send a signal back when we're done */
-static void
-starting_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
+gboolean
+ubuntu_app_launch_observer_delete_app_resume (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
-	ual_tracepoint(observer_start, "starting");
-
-	generic_signal_cb(conn, sender, object, interface, signal, params, user_data);
-
-	GError * error = NULL;
-	g_dbus_connection_emit_signal(conn,
-		sender, /* destination */
-		"/", /* path */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		"UnityStartingSignal", /* signal */
-		params, /* params, the same */
-		&error);
-
-	if (error != NULL) {
-		g_warning("Unable to emit response signal: %s", error->message);
-		g_error_free(error);
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		return FALSE;
 	}
 
-	ual_tracepoint(observer_finish, "starting");
+	return manager->deleteResume(observer, user_data) ? TRUE : FALSE;
 }
 
 gboolean
 ubuntu_app_launch_observer_add_app_starting (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		manager = std::make_shared<CManager>();
+		ubuntu::app_launch::Registry::setManager(manager, ubuntu::app_launch::Registry::getDefault());
+		cmanager = manager;
+	}
+
 	ubuntu::app_launch::Registry::Impl::watchingAppStarting(true);
-	return add_session_generic(observer, user_data, "UnityStartingBroadcast", &starting_array, starting_signal_cb);
-}
-
-/* Handle the failed signal when it occurs, call the observer */
-static void
-failed_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	failed_observer_t * observer = (failed_observer_t *)user_data;
-	const gchar * appid = NULL;
-	const gchar * typestr = NULL;
-
-	ual_tracepoint(observer_start, "failed");
-
-	if (observer->func != NULL) {
-		UbuntuAppLaunchAppFailed type = UBUNTU_APP_LAUNCH_APP_FAILED_CRASH;
-		g_variant_get(params, "(&s&s)", &appid, &typestr);
-
-		if (g_strcmp0("crash", typestr) == 0) {
-			type = UBUNTU_APP_LAUNCH_APP_FAILED_CRASH;
-		} else if (g_strcmp0("start-failure", typestr) == 0) {
-			type = UBUNTU_APP_LAUNCH_APP_FAILED_START_FAILURE;
-		} else {
-			g_warning("Application failure type '%s' unknown, reporting as a crash", typestr);
-		}
-
-		observer->func(appid, type, observer->user_data);
-	}
-
-	ual_tracepoint(observer_finish, "failed");
-}
-
-gboolean
-ubuntu_app_launch_observer_add_app_failed (UbuntuAppLaunchAppFailedObserver observer, gpointer user_data)
-{
-	GDBusConnection * conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-
-	if (conn == NULL) {
-		return FALSE;
-	}
-
-	failed_observer_t * observert = g_new0(failed_observer_t, 1);
-
-	observert->conn = conn;
-	observert->func = observer;
-	observert->user_data = user_data;
-
-	failed_array = g_list_prepend(failed_array, observert);
-
-	observert->sighandle = g_dbus_connection_signal_subscribe(conn,
-		NULL, /* sender */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		"ApplicationFailed", /* signal */
-		"/", /* path */
-		NULL, /* arg0 */
-		G_DBUS_SIGNAL_FLAGS_NONE,
-		failed_signal_cb,
-		observert,
-		NULL); /* user data destroy */
-
-	return TRUE;
-}
-
-/* Handle the paused signal when it occurs, call the observer */
-static void
-paused_signal_cb (GDBusConnection * conn, const gchar * sender, const gchar * object, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
-{
-	paused_resumed_observer_t * observer = (paused_resumed_observer_t *)user_data;
-
-	ual_tracepoint(observer_start, observer->lttng_signal);
-
-	if (observer->func != NULL) {
-		GArray * pidarray = g_array_new(TRUE, TRUE, sizeof(GPid));
-		GVariant * appid = g_variant_get_child_value(params, 0);
-		GVariant * pids = g_variant_get_child_value(params, 1);
-		guint64 pid;
-		GVariantIter thispid;
-		g_variant_iter_init(&thispid, pids);
-
-		while (g_variant_iter_loop(&thispid, "t", &pid)) {
-			GPid gpid = (GPid)pid; /* Should be a no-op for most architectures, but just in case */
-			g_array_append_val(pidarray, gpid);
-		}
-
-		observer->func(g_variant_get_string(appid, NULL), (GPid *)pidarray->data, observer->user_data);
-
-		g_array_free(pidarray, TRUE);
-		g_variant_unref(appid);
-		g_variant_unref(pids);
-	}
-
-	ual_tracepoint(observer_finish, observer->lttng_signal);
-}
-
-static gboolean
-paused_resumed_generic (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data, GList ** queue, const gchar * signal_name, const gchar * lttng_signal)
-{
-	GDBusConnection * conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-
-	if (conn == NULL) {
-		return FALSE;
-	}
-
-	paused_resumed_observer_t * observert = g_new0(paused_resumed_observer_t, 1);
-
-	observert->conn = conn;
-	observert->func = observer;
-	observert->user_data = user_data;
-	observert->lttng_signal = lttng_signal;
-
-	*queue = g_list_prepend(*queue, observert);
-
-	observert->sighandle = g_dbus_connection_signal_subscribe(conn,
-		NULL, /* sender */
-		"com.canonical.UbuntuAppLaunch", /* interface */
-		signal_name, /* signal */
-		"/", /* path */
-		NULL, /* arg0 */
-		G_DBUS_SIGNAL_FLAGS_NONE,
-		paused_signal_cb,
-		observert,
-		NULL); /* user data destroy */
-
-	return TRUE;
-}
-
-gboolean
-ubuntu_app_launch_observer_add_app_paused (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
-{
-	return paused_resumed_generic(observer, user_data, &paused_array, "ApplicationPaused", "paused");
-}
-
-gboolean
-ubuntu_app_launch_observer_add_app_resumed (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
-{
-	return paused_resumed_generic(observer, user_data, &resumed_array, "ApplicationResumed", "resumed");
-}
-
-static gboolean
-delete_app_generic (UbuntuAppLaunchAppObserver observer, gpointer user_data, GList ** list)
-{
-	observer_t * observert = NULL;
-	GList * look;
-
-	for (look = *list; look != NULL; look = g_list_next(look)) {
-		observert = (observer_t *)look->data;
-
-		if (observert->func == observer && observert->user_data == user_data) {
-			break;
-		}
-	}
-
-	if (look == NULL) {
-		return FALSE;
-	}
-
-	g_dbus_connection_signal_unsubscribe(observert->conn, observert->sighandle);
-	g_object_unref(observert->conn);
-
-	g_free(observert);
-	*list = g_list_delete_link(*list, look);
-
-	return TRUE;
-}
-
-gboolean
-ubuntu_app_launch_observer_delete_app_started (UbuntuAppLaunchAppObserver observer, gpointer user_data)
-{
-	return delete_app_generic(observer, user_data, &started_array);
-}
-
-gboolean
-ubuntu_app_launch_observer_delete_app_stop (UbuntuAppLaunchAppObserver observer, gpointer user_data)
-{
-	return delete_app_generic(observer, user_data, &stop_array);
-}
-
-gboolean
-ubuntu_app_launch_observer_delete_app_resume (UbuntuAppLaunchAppObserver observer, gpointer user_data)
-{
-	return delete_app_generic(observer, user_data, &resume_array);
-}
-
-gboolean
-ubuntu_app_launch_observer_delete_app_focus (UbuntuAppLaunchAppObserver observer, gpointer user_data)
-{
-	return delete_app_generic(observer, user_data, &focus_array);
+	manager->addStarting(observer, user_data);
+	return TRUE;
 }
 
 gboolean
 ubuntu_app_launch_observer_delete_app_starting (UbuntuAppLaunchAppObserver observer, gpointer user_data)
 {
+	auto manager = cmanager.lock();
+
+	if (!manager) {
+		return FALSE;
+	}
+
 	ubuntu::app_launch::Registry::Impl::watchingAppStarting(false);
-	return delete_app_generic(observer, user_data, &starting_array);
+	return manager->deleteStarting(observer, user_data) ? TRUE : FALSE;
+}
+
+/* Map of all the observers listening for app stopped */
+static std::map<std::pair<UbuntuAppLaunchAppFailedObserver, gpointer>, core::ScopedConnection> appFailedObservers;
+
+gboolean
+ubuntu_app_launch_observer_add_app_failed (UbuntuAppLaunchAppFailedObserver observer, gpointer user_data)
+{
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appFailedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appFailed().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance, ubuntu::app_launch::Registry::FailureType type) {
+					std::string appid = app->appId();
+					executeOnContext(context, [appid, type, observer, user_data]() {
+						UbuntuAppLaunchAppFailed ctype;
+
+						switch (type) {
+						case ubuntu::app_launch::Registry::FailureType::CRASH:
+							ctype = UBUNTU_APP_LAUNCH_APP_FAILED_CRASH;
+							break;
+						case ubuntu::app_launch::Registry::FailureType::START_FAILURE:
+							ctype = UBUNTU_APP_LAUNCH_APP_FAILED_START_FAILURE;
+							break;
+						}
+
+						observer(appid.c_str(), ctype, user_data);
+					});
+				})
+			)
+		));
+
+	return TRUE;
 }
 
 gboolean
 ubuntu_app_launch_observer_delete_app_failed (UbuntuAppLaunchAppFailedObserver observer, gpointer user_data)
 {
-	failed_observer_t * observert = NULL;
-	GList * look;
-
-	for (look = failed_array; look != NULL; look = g_list_next(look)) {
-		observert = (failed_observer_t *)look->data;
-
-		if (observert->func == observer && observert->user_data == user_data) {
-			break;
-		}
-	}
-
-	if (look == NULL) {
+	auto iter = appFailedObservers.find(std::make_pair(observer, user_data));
+
+	if (iter == appFailedObservers.end()) {
 		return FALSE;
 	}
 
-	g_dbus_connection_signal_unsubscribe(observert->conn, observert->sighandle);
-	g_object_unref(observert->conn);
-
-	g_free(observert);
-	failed_array = g_list_delete_link(failed_array, look);
-
+	appFailedObservers.erase(iter);
 	return TRUE;
 }
 
-static gboolean
-paused_resumed_delete (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data, GList ** list)
+static std::map<std::pair<UbuntuAppLaunchAppPausedResumedObserver, gpointer>, core::ScopedConnection> appPausedObservers;
+
+gboolean
+ubuntu_app_launch_observer_add_app_paused (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
 {
-	paused_resumed_observer_t * observert = NULL;
-	GList * look;
-
-	for (look = *list; look != NULL; look = g_list_next(look)) {
-		observert = (paused_resumed_observer_t *)look->data;
-
-		if (observert->func == observer && observert->user_data == user_data) {
-			break;
-		}
-	}
-
-	if (look == NULL) {
-		return FALSE;
-	}
-
-	g_dbus_connection_signal_unsubscribe(observert->conn, observert->sighandle);
-	g_object_unref(observert->conn);
-
-	g_free(observert);
-	*list = g_list_delete_link(*list, look);
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appPausedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appPaused().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance, std::vector<pid_t> &pids) {
+					std::vector<pid_t> lpids = pids;
+					lpids.emplace_back(0);
+
+					std::string appid = app->appId();
+
+					executeOnContext(context, [appid, observer, user_data, lpids]() {
+						observer(appid.c_str(), (int *)(lpids.data()), user_data);
+					});
+				})
+			)
+		));
 
 	return TRUE;
 }
@@ -762,13 +648,53 @@
 gboolean
 ubuntu_app_launch_observer_delete_app_paused (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
 {
-	return paused_resumed_delete(observer, user_data, &paused_array);
+	auto iter = appPausedObservers.find(std::make_pair(observer, user_data));
+
+	if (iter == appPausedObservers.end()) {
+		return FALSE;
+	}
+
+	appPausedObservers.erase(iter);
+	return TRUE;
+}
+
+static std::map<std::pair<UbuntuAppLaunchAppPausedResumedObserver, gpointer>, core::ScopedConnection> appResumedObservers;
+
+gboolean
+ubuntu_app_launch_observer_add_app_resumed (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
+{
+	auto context = std::shared_ptr<GMainContext>(g_main_context_ref_thread_default(), [](GMainContext * context) { g_clear_pointer(&context, g_main_context_unref); });
+
+	appResumedObservers.emplace(std::make_pair(
+		std::make_pair(observer, user_data),
+			core::ScopedConnection(
+				ubuntu::app_launch::Registry::appResumed().connect([context, observer, user_data](std::shared_ptr<ubuntu::app_launch::Application> app, std::shared_ptr<ubuntu::app_launch::Application::Instance> instance, std::vector<pid_t>& pids) {
+					std::vector<pid_t> lpids = pids;
+					lpids.emplace_back(0);
+
+					std::string appid = app->appId();
+
+					executeOnContext(context, [appid, observer, user_data, lpids]() {
+						observer(appid.c_str(), (int *)(lpids.data()), user_data);
+					});
+				})
+			)
+		));
+
+	return TRUE;
 }
 
 gboolean
 ubuntu_app_launch_observer_delete_app_resumed (UbuntuAppLaunchAppPausedResumedObserver observer, gpointer user_data)
 {
-	return paused_resumed_delete(observer, user_data, &resumed_array);
+	auto iter = appResumedObservers.find(std::make_pair(observer, user_data));
+
+	if (iter == appResumedObservers.end()) {
+		return FALSE;
+	}
+
+	appResumedObservers.erase(iter);
+	return TRUE;
 }
 
 typedef void (*per_instance_func_t) (GDBusConnection * con, GVariant * prop_dict, gpointer user_data);

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-09-14 16:43:36 +0000
+++ tests/CMakeLists.txt	2016-11-10 21:58:30 +0000
@@ -157,6 +157,7 @@
 
 add_custom_target(format-tests
 	COMMAND clang-format -i -style=file
+	failure-test.cc
 	application-info-desktop.cpp
 	libual-cpp-test.cc
 	list-apps.cpp

=== modified file 'tests/failure-test.cc'
--- tests/failure-test.cc	2016-08-25 18:13:44 +0000
+++ tests/failure-test.cc	2016-11-10 21:58:30 +0000
@@ -17,120 +17,147 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "eventually-fixture.h"
+#include "registry.h"
+#include <gio/gio.h>
+#include <glib/gstdio.h>
 #include <gtest/gtest.h>
-#include <glib/gstdio.h>
-#include <gio/gio.h>
-#include <ubuntu-app-launch.h>
-#include "eventually-fixture.h"
 
 class FailureTest : public EventuallyFixture
 {
-	private:
-		GTestDBus * testbus = NULL;
-
-	protected:
-		virtual void SetUp() {
-			testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
-			g_test_dbus_up(testbus);
-		}
-
-		virtual void TearDown() {
-			g_test_dbus_down(testbus);
-			g_clear_object(&testbus);
-		}
+private:
+    GTestDBus* testbus = NULL;
+
+protected:
+    std::shared_ptr<ubuntu::app_launch::Registry> registry;
+
+    virtual void SetUp()
+    {
+        /* Click DB test mode */
+        g_setenv("TEST_CLICK_DB", "click-db-dir", TRUE);
+        g_setenv("TEST_CLICK_USER", "test-user", TRUE);
+
+        gchar* linkfarmpath = g_build_filename(CMAKE_SOURCE_DIR, "link-farm", NULL);
+        g_setenv("UBUNTU_APP_LAUNCH_LINK_FARM", linkfarmpath, TRUE);
+        g_free(linkfarmpath);
+
+        g_setenv("XDG_DATA_DIRS", CMAKE_SOURCE_DIR, TRUE);
+        g_setenv("XDG_CACHE_HOME", CMAKE_SOURCE_DIR "/libertine-data", TRUE);
+        g_setenv("XDG_DATA_HOME", CMAKE_SOURCE_DIR "/libertine-home", TRUE);
+
+        testbus = g_test_dbus_new(G_TEST_DBUS_NONE);
+        g_test_dbus_up(testbus);
+
+        registry = std::make_shared<ubuntu::app_launch::Registry>();
+    }
+
+    virtual void TearDown()
+    {
+        registry.reset();
+
+        g_test_dbus_down(testbus);
+        g_clear_object(&testbus);
+    }
 };
 
-static void
-failed_observer (const gchar * appid, UbuntuAppLaunchAppFailed reason, gpointer user_data)
-{
-	if (reason == UBUNTU_APP_LAUNCH_APP_FAILED_CRASH) {
-		std::string * last = static_cast<std::string *>(user_data);
-		*last = appid;
-	}
-}
-
 TEST_F(FailureTest, CrashTest)
 {
-	g_setenv("EXIT_STATUS", "-100", TRUE);
-	g_setenv("JOB", "application-click", TRUE);
-	g_setenv("INSTANCE", "foo", TRUE);
-
-	std::string last_observer;
-	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_observer, &last_observer));
-
-	/* Status based */
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo", last_observer);
-
-	last_observer.clear();
-	g_unsetenv("EXIT_STATUS");
-	g_setenv("EXIT_SIGNAL", "KILL", TRUE);
-
-	/* Signal based */
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo", last_observer);
-
-	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
+    g_setenv("EXIT_STATUS", "-100", TRUE);
+    g_setenv("JOB", "application-click", TRUE);
+    g_setenv("INSTANCE", "foo", TRUE);
+
+    std::string last_observer;
+    ubuntu::app_launch::Registry::appFailed(registry).connect(
+        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
+                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                         ubuntu::app_launch::Registry::FailureType type) {
+            if (type == ubuntu::app_launch::Registry::FailureType::CRASH)
+            {
+                last_observer = app->appId();
+            }
+        });
+
+    /* Status based */
+    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
+
+    EXPECT_EVENTUALLY_EQ("foo", last_observer);
+
+    last_observer.clear();
+    g_unsetenv("EXIT_STATUS");
+    g_setenv("EXIT_SIGNAL", "KILL", TRUE);
+
+    /* Signal based */
+    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
+
+    EXPECT_EVENTUALLY_EQ("foo", last_observer);
 }
 
 TEST_F(FailureTest, LegacyTest)
 {
-	g_setenv("EXIT_STATUS", "-100", TRUE);
-	g_setenv("JOB", "application-legacy", TRUE);
-	g_setenv("INSTANCE", "foo-1234", TRUE);
-
-	std::string last_observer;
-	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_observer, &last_observer));
-
-	/* Status based */
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo", last_observer);
-
-	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
+    g_setenv("EXIT_STATUS", "-100", TRUE);
+    g_setenv("JOB", "application-legacy", TRUE);
+    g_setenv("INSTANCE", "foo-1234", TRUE);
+
+    std::string last_observer;
+    ubuntu::app_launch::Registry::appFailed(registry).connect(
+        [&last_observer](std::shared_ptr<ubuntu::app_launch::Application> app,
+                         std::shared_ptr<ubuntu::app_launch::Application::Instance> instance,
+                         ubuntu::app_launch::Registry::FailureType type) {
+            g_debug("Signal handler called");
+            if (type == ubuntu::app_launch::Registry::FailureType::CRASH)
+            {
+                last_observer = app->appId();
+            }
+        });
+
+    /* Status based */
+    ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
+
+    EXPECT_EVENTUALLY_EQ("foo", last_observer);
 }
 
 TEST_F(FailureTest, SnapTest)
 {
-	g_setenv("EXIT_STATUS", "-100", TRUE);
-	g_setenv("JOB", "application-snap", TRUE);
-	g_setenv("INSTANCE", "foo_bar_x123-1234", TRUE);
-
-	std::string last_observer;
-	ASSERT_TRUE(ubuntu_app_launch_observer_add_app_failed(failed_observer, &last_observer));
-
-	/* Status based */
-	ASSERT_TRUE(g_spawn_command_line_sync(APP_FAILED_TOOL, NULL, NULL, NULL, NULL));
-
-	EXPECT_EVENTUALLY_EQ("foo_bar_x123", last_observer);
-
-	ASSERT_TRUE(ubuntu_app_launch_observer_delete_app_failed(failed_observer, &last_observer));
-}
-
-static void
-failed_start_observer (const gchar * appid, UbuntuAppLaunchAppFailed reason, gpointer user_data)
-{