Merge lp:~ricmm/unity-mir/extend_lifecycle_mir into lp:unity-mir

[Ricardo Mendoza]

* Add TaskController class for lower level process control
* Extend Application states to support the full lifecycle model
* Implement respawning applications (Stopped state) as part of the AppMgr
* Implement delayed process suspension
* Fix FTBFS due to Mir API change (SurfacePlacementStrategy)

[lp:~ricmm/unity-mir/extend_lifecycle_mir]

44. By Ricardo Mendoza on 2013-08-19

Set application to Running when it is actually focused, not when it has created its surfaces

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:43
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/20/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/20/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-i386-ci/20/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-mir-ci/20/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:44
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/21/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/21/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-i386-ci/21/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-mir-ci/21/rebuild

review: Needs Fixing (continuous-integration)

[lp:~ricmm/unity-mir/extend_lifecycle_mir]

45. By Ricardo Mendoza on 2013-08-20

merge trunk

46. By Ricardo Mendoza on 2013-08-20

Add missing files

47. By Ricardo Mendoza on 2013-08-20

Remove irrelevant file

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:47
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/33/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/33/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-i386-ci/33/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-mir-ci/33/rebuild

review: Needs Fixing (continuous-integration)

[Albert Astals Cid (aacid)]

src/unity-mir/initialsurfaceplacementstrategy.* seem to not merge cleanly

QTimer::singleShot(3000, this, SLOT(suspend()));
looks dangerous, what if the application gets back to Running state before those 3000 ms? You should stop the timer, in that case, shouldn't you?

the debug log in ApplicationListModel::indexOf is wrong

May make sense to abstract the qprocess code into a function so both startProcess and respawnProcess use it?

I don't understand why you moved m_mainStageApplications->remove(application); into the if, is it because now you can only stop the running app? Wouldn't it make sense to leave it out of the if as a safety mesure?

 QStringList arguments -> const QStringList &arguments

79 + }
80 + else if (m_state == Application::Stopped) {
looks like needs going one line up

Probably you don't need these includes in the header

454 +#include "application_manager.h"
455 +#include "mircommon/mir_toolkit/common.h"
456 +#include <mir/shell/application_session.h>

If you are going to ApplicationManager* appMgr = static_cast<ApplicationManager*>(parent()); in TaskController, i'd feel better if you changed the constructor from TaskController(QObject *parent) to TaskController(ApplicationManager *parent) :

review: Needs Fixing

[Gerry Boland (gerboland)]

QTimer::singleShot(3000, this, SLOT(suspend()));
Yep, it is risky. What if you switch to away from the app, then switch back to it, then switch away, all within 2900ms. Then app only gets 100ms before is frozen.

I would not bother abstracting the QProcess code just yet, as it will be replaced by upstart launch code soon, and that will provide the refactoring.

[lp:~ricmm/unity-mir/extend_lifecycle_mir]

48. By Ricardo Mendoza on 2013-08-26

Dont use a singleShot timer, instead keep track of the timer object

49. By Ricardo Mendoza on 2013-08-26

Merge trunk

50. By Ricardo Mendoza on 2013-08-26

Build errors

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:50
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/43/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/43
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/43/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-i386-ci/43

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-mir-ci/43/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

You're still not stopping the timer, if application is set to running again, or if application stops while timer is running. So add

m_suspendTimer->stop() inside the "case Application::Running" and Stopped.

Albert has a few comments too, can you address those please.

[lp:~ricmm/unity-mir/extend_lifecycle_mir]

51. By Ricardo Mendoza on 2013-08-27

* Fix logging in list model
* Make TaskController parent more explicitly typed
* Fix argument passing in application ctor

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:51
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/44/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/44
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/44/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-i386-ci/44

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-mir-ci/44/rebuild

review: Approve (continuous-integration)

[Albert Astals Cid (aacid)]

As Gerry says it seems that you never stop the timer, i.e. m_suspendTimer->stop() inside the "case Application::Running" and Stopped.

Also the timer should be probably set to singleshot not to suspend it every 3 seconds

review: Needs Fixing

[lp:~ricmm/unity-mir/extend_lifecycle_mir]

52. By Ricardo Mendoza on 2013-08-27

Stop timer if caught active when transitioning to the Stopped state

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:52
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/45/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/45
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/45/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-i386-ci/45

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-mir-ci/45/rebuild

review: Approve (continuous-integration)

[lp:~ricmm/unity-mir/extend_lifecycle_mir]

53. By Ricardo Mendoza on 2013-08-27

Make timer single shot

[Albert Astals Cid (aacid)]

Ok, looks good enough to me, it's a bit "brain hard" to realize we don't need the stop in Running because when the timer triggers it'll be ignored, it's also a bit of "a waste" of resources to have the timer running if we're not going to use it, but oh well :D

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:53
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/46/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/46
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-armhf-ci/46/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-saucy-i386-ci/46

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-mir-ci/46/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

Looks good to me, approving

review: Approve

=== modified file 'src/modules/Unity/ApplicationManager/ApplicationManager.pro'
--- src/modules/Unity/ApplicationManager/ApplicationManager.pro	2013-08-21 09:36:24 +0000
+++ src/modules/Unity/ApplicationManager/ApplicationManager.pro	2013-08-27 14:37:14 +0000
@@ -23,14 +23,16 @@
     desktopfilereader.cpp \
     plugin.cpp \
     applicationscreenshotprovider.cpp \
-    dbuswindowstack.cpp
+    dbuswindowstack.cpp \
+    taskcontroller.cpp
 
 HEADERS += application_manager.h \
     application.h \
     application_list_model.h \
     desktopfilereader.h \
     applicationscreenshotprovider.h \
-    dbuswindowstack.h
+    dbuswindowstack.h \
+    taskcontroller.h
 
 installPath = $$[QT_INSTALL_IMPORTS]/$$replace(uri, \\., /)
 

=== modified file 'src/modules/Unity/ApplicationManager/application.cpp'
--- src/modules/Unity/ApplicationManager/application.cpp	2013-08-16 15:54:51 +0000
+++ src/modules/Unity/ApplicationManager/application.cpp	2013-08-27 14:37:14 +0000
@@ -26,17 +26,24 @@
 #include <mir/shell/application_session.h>
 
 Application::Application(DesktopFileReader* desktopData, qint64 pid,
-                         Application::Stage stage, Application::State state)
+                         Application::Stage stage, Application::State state,
+                         const QStringList& arguments, TaskController* taskController)
     : m_desktopData(desktopData)
     , m_pid(pid)
     , m_stage(stage)
     , m_state(state)
     , m_focus(false)
     , m_fullscreen(false)
+    , m_arguments(arguments)
+    , m_taskController(taskController)
+    , m_suspendTimer(new QTimer(this))
 {
     DASSERT(desktopData != NULL);
     DLOG("Application::Application (this=%p, desktopData=%p, pid=%lld, stage=%d, state=%d",
          this, desktopData, pid, static_cast<int>(stage), static_cast<int>(state));
+
+    m_suspendTimer->setSingleShot(true);
+    connect(m_suspendTimer, SIGNAL(timeout()), this, SLOT(suspend()));
 }
 
 Application::~Application()
@@ -100,6 +107,16 @@
     return m_session;
 }
 
+pid_t Application::pid() const
+{
+    return m_pid;
+}
+
+void Application::setPid(pid_t pid)
+{
+    m_pid = pid;
+}
+
 void Application::setSession(const std::shared_ptr<mir::shell::ApplicationSession>& session)
 {
     // TODO(greyback) what if called with new surface?
@@ -129,7 +146,31 @@
 {
     DLOG("Application::setState (this=%p, state=%d)", this, static_cast<int>(state));
     if (m_state != state) {
-        m_state = state;
+        switch (state)
+        {
+        case Application::Suspended:
+            if (m_state == Application::Running) {
+                session()->set_lifecycle_state(mir_lifecycle_state_will_suspend);
+                m_suspendTimer->start(3000);
+            }
+            break;
+        case Application::Running:
+            if (m_state == Application::Suspended) {
+                resume();
+                session()->set_lifecycle_state(mir_lifecycle_state_resumed);
+            } else if (m_state == Application::Stopped) {
+                respawn();
+                state = Application::Starting;
+            }
+            break;
+        case Application::Stopped:
+            if (m_suspendTimer->isActive())
+                m_suspendTimer->stop();
+            break;
+        default:
+            break;
+        }
+        m_state = state;        
         emit stateChanged();
     }
 }
@@ -151,3 +192,24 @@
         emit fullscreenChanged();
     }
 }
+
+void Application::suspend()
+{
+    DLOG("Application::suspend (this=%p)", this);
+    
+    m_taskController->do_suspend(this);
+}
+
+void Application::resume()
+{
+    DLOG("Application::resume (this=%p)", this);
+    
+    m_taskController->do_resume(this);
+}
+
+void Application::respawn()
+{
+    DLOG("Application::respawn (this=%p)", this);
+    
+    m_taskController->do_respawn(this);
+}

=== modified file 'src/modules/Unity/ApplicationManager/application.h'
--- src/modules/Unity/ApplicationManager/application.h	2013-08-14 14:24:17 +0000
+++ src/modules/Unity/ApplicationManager/application.h	2013-08-27 14:37:14 +0000
@@ -29,6 +29,7 @@
 
 class QImage;
 class DesktopFileReader;
+class TaskController;
 namespace mir { namespace shell { class ApplicationSession; }}
 
 class Application : public QObject {
@@ -48,9 +49,9 @@
 
 public:
     enum Stage { MainStage, SideStage };
-    enum State { Starting, Running };
+    enum State { Starting, Running, Suspended, Stopped };
 
-    Application(DesktopFileReader* desktopData, qint64 pid, Stage stage, State state);
+    Application(DesktopFileReader* desktopData, qint64 pid, Stage stage, State state, const QStringList& arguments, TaskController* taskController);
     ~Application();
 
     QString desktopFile() const;
@@ -65,6 +66,11 @@
     bool fullscreen() const;
     std::shared_ptr<mir::shell::ApplicationSession> session() const;
 
+public slots:
+    void suspend();
+    void resume();
+    void respawn();
+
 Q_SIGNALS:
     void stageChanged();
     void stateChanged();
@@ -72,6 +78,8 @@
     void fullscreenChanged();
 
 private:
+    pid_t pid() const;
+    void setPid(pid_t pid);
     void setStage(Stage stage);
     void setState(State state);
     void setFocus(bool focus);
@@ -87,7 +95,11 @@
     bool m_fullscreen;
     std::shared_ptr<mir::shell::ApplicationSession> m_session;
     QString m_sessionName;
+    QStringList m_arguments;
+    TaskController* m_taskController;
+    QTimer* m_suspendTimer;
 
+    friend class TaskController;
     friend class ApplicationManager;
     friend class ApplicationListModel;
 };

=== modified file 'src/modules/Unity/ApplicationManager/application_list_model.cpp'
--- src/modules/Unity/ApplicationManager/application_list_model.cpp	2013-08-15 15:37:00 +0000
+++ src/modules/Unity/ApplicationManager/application_list_model.cpp	2013-08-27 14:37:14 +0000
@@ -64,6 +64,15 @@
     return data(index(row), 0);
 }
 
+int ApplicationListModel::indexOf(Application* application) const
+{
+    DASSERT(application != NULL);
+    DLOG("ApplicationListModel::indexOf (this=%p, application='%s')", this,
+         application->name().toLatin1().data());
+
+    return m_applications.indexOf(application);
+}
+
 void ApplicationListModel::move(int from, int to)
 {
     DLOG("ApplicationListModel::move (this=%p, from=%d, to=%d)", this, from, to);

=== modified file 'src/modules/Unity/ApplicationManager/application_list_model.h'
--- src/modules/Unity/ApplicationManager/application_list_model.h	2013-08-14 14:24:17 +0000
+++ src/modules/Unity/ApplicationManager/application_list_model.h	2013-08-27 14:37:14 +0000
@@ -37,6 +37,7 @@
     int rowCount(const QModelIndex& parent = QModelIndex()) const;
     QVariant data(const QModelIndex& index, int role) const;
     QHash<int,QByteArray> roleNames() const { return m_roleNames; }
+    int indexOf(Application* application) const;
     Q_INVOKABLE QVariant get(int index) const;
     Q_INVOKABLE void move(int from, int to);
 

=== modified file 'src/modules/Unity/ApplicationManager/application_manager.cpp'
--- src/modules/Unity/ApplicationManager/application_manager.cpp	2013-08-23 17:26:40 +0000
+++ src/modules/Unity/ApplicationManager/application_manager.cpp	2013-08-27 14:37:14 +0000
@@ -75,6 +75,7 @@
     qsrand(QTime::currentTime().msec());
 
     m_dbusWindowStack = new DBusWindowStack(this);
+    m_taskController = new TaskController(this);
 }
 
 ApplicationManager::~ApplicationManager()
@@ -120,6 +121,40 @@
     m_mirServer->the_session_manager()->set_focus_to(NULL); //FIXME(greyback)
 }
 
+Application* ApplicationManager::respawnApplication(Application* application)
+{
+    DLOG("ApplicationManager::respawnApplication(this=%p, application=%p)", this, application);
+
+    // Start process - set correct environment
+    setenv("QT_QPA_PLATFORM", "ubuntumirclient", 1);
+
+    bool result;
+    qint64 pid = 0;
+    struct passwd* passwd = getpwuid(getuid());
+    DLOG("current working directory: '%s' - args='%s'", passwd ? passwd->pw_dir : "/", application->m_arguments.join(' ').toLatin1().data());
+    QProcess builder;
+    builder.setProcessChannelMode(QProcess::ForwardedChannels);
+    QString exec(application->m_arguments[0]);
+    application->m_arguments.removeFirst();
+    result = builder.startDetached(exec, application->m_arguments, QString(passwd ? passwd->pw_dir : "/"), &pid);
+    application->m_arguments.prepend(exec);
+    DLOG_IF(result == false, "process failed to start");
+    if (result) {
+        // Set existing application's pid to new instance
+        application->setPid(pid);
+
+        // Push to front
+        if (m_mainStageApplications->rowCount() > 1)
+            m_mainStageApplications->move(m_mainStageApplications->indexOf(application), 0);
+
+        DLOG("builder '%s' respawned with pid %lld", application->name().toLatin1().data(), pid);
+        return application;
+    } else {
+        DLOG("builder '%s' failed to respawn", application->name().toLatin1().data());
+        return NULL;
+    }
+}
+
 Application* ApplicationManager::startProcess(QString desktopFile, ApplicationManager::ExecFlags flags,
                                            QStringList arguments)
 {
@@ -191,18 +226,23 @@
             path = passwd->pw_dir;
     }
     DLOG("current working directory: '%s'", path.toLatin1().data());
-    result = QProcess::startDetached(exec, arguments, path, &pid);
+        QProcess builder;
+    builder.setProcessChannelMode(QProcess::ForwardedChannels);
+    result = builder.startDetached(exec, arguments, path, &pid);
+    
     DLOG_IF(result == false, "process failed to start");
     if (result) {
 #endif
-
         DLOG("process started with pid %lld, adding '%s' to application lists", pid, desktopData->name().toLatin1().data());
+        arguments.prepend(exec);
         Application* application = new Application(
                     desktopData, pid,
                     (flags.testFlag(ApplicationManager::ForceMainStage)
                         || desktopData->stageHint() != "SideStage")
                         ? Application::MainStage : Application::SideStage,
-                    Application::Starting //FIXME(greyback): assuming running immediately
+                    Application::Starting, //FIXME(greyback): assuming running immediately
+                    arguments,
+                    m_taskController
                     );
 
         m_mainStageApplications->add(application);
@@ -319,7 +359,10 @@
     }
 
     DLOG("Existing process with pid %lld appeared, adding '%s' to application lists", pid, desktopData->name().toLatin1().data());
-    application = new Application(desktopData, pid, stage, Application::Starting);
+
+    QString argStr(command.data());
+    QStringList arguments(argStr.split(' '));
+    application = new Application(desktopData, pid, stage, Application::Starting, arguments, m_taskController);
     m_mainStageApplications->add(application);
     authorized = true;
 }
@@ -348,9 +391,10 @@
         if (application == m_mainStageFocusedApplication) {
             // TODO(greyback) What to do?? Focus next app, or unfocus everything??
             m_mainStageFocusedApplication = NULL;
+            m_mainStageApplications->remove(application);
             Q_EMIT mainStageFocusedApplicationChanged();
         }
-        m_mainStageApplications->remove(application);
+        application->setState(Application::Stopped);
         m_dbusWindowStack->WindowDestroyed(0, application->name());
     }
 }
@@ -359,7 +403,7 @@
 {
     DLOG("ApplicationManager::sessionFocused (this=%p, application=%s)", this, session->name().c_str());
     Application* application = m_mainStageApplications->getApplicationWithSession(session);
-
+    
     // Don't give application focus until it has created it's surface, when it is set as state "Running"
     if (application && application->state() != Application::Starting
             && application != m_mainStageFocusedApplication) {
@@ -372,6 +416,7 @@
     DLOG("ApplicationManager::sessionUnfocused (this=%p)", this);
     if (NULL != m_mainStageFocusedApplication) {
         m_mainStageFocusedApplication->setFocus(false);
+        m_mainStageFocusedApplication->setState(Application::Suspended);
         m_mainStageFocusedApplication = NULL;
         Q_EMIT mainStageFocusedApplicationChanged();
         m_dbusWindowStack->FocusedWindowChanged(0, QString(), 0);
@@ -386,10 +431,7 @@
 
     Application* application = m_mainStageApplications->getApplicationWithSession(session);
     if (application && application->state() == Application::Starting) {
-        application->setState(Application::Running);
-
         m_dbusWindowStack->WindowCreated(0, application->name());
-
         // only when Session creates a Surface will we actually mark it focused
         setFocused(application);
     }
@@ -399,6 +441,7 @@
 {
     m_mainStageFocusedApplication = application;
     m_mainStageFocusedApplication->setFocus(true);
+    m_mainStageFocusedApplication->setState(Application::Running);
     Q_EMIT mainStageFocusedApplicationChanged();
     m_dbusWindowStack->FocusedWindowChanged(0, application->name(), application->stage());
 }

=== modified file 'src/modules/Unity/ApplicationManager/application_manager.h'
--- src/modules/Unity/ApplicationManager/application_manager.h	2013-08-15 18:10:19 +0000
+++ src/modules/Unity/ApplicationManager/application_manager.h	2013-08-27 14:37:14 +0000
@@ -24,7 +24,7 @@
 #include <QObject>
 #include <QStringList>
 
-#include "application.h"
+#include "taskcontroller.h"
 #include "application_list_model.h"
 
 class ShellServerConfiguration;
@@ -102,13 +102,16 @@
 
 private:
     void setFocused(Application *application);
+    Application* respawnApplication(Application* application);
 
     ApplicationListModel* m_mainStageApplications;
     Application* m_mainStageFocusedApplication; // remove as Mir has API for this
     ShellServerConfiguration* m_mirServer;
     DBusWindowStack* m_dbusWindowStack;
+    TaskController* m_taskController;
 
     friend class DBusWindowStack;
+    friend class TaskController;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(ApplicationManager::ExecFlags)

=== added file 'src/modules/Unity/ApplicationManager/taskcontroller.cpp'
--- src/modules/Unity/ApplicationManager/taskcontroller.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/ApplicationManager/taskcontroller.cpp	2013-08-27 14:37:14 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ricardo Mendoza <[e-mail]>
+ */
+
+#include "logging.h"
+#include "taskcontroller.h"
+#include "application_manager.h"
+#include <signal.h>
+#include <unistd.h>
+
+TaskController::TaskController(ApplicationManager *parent) :
+    QObject(parent)
+{
+    DLOG("TaskController::TaskController (this=%p)", this);
+}
+
+TaskController::~TaskController()
+{
+    DLOG("TaskController::~TaskController (this=%p)", this);
+}
+
+void TaskController::do_suspend(Application* application)
+{
+    DLOG("TaskController::do_suspend (this=%p, application=%p)", this, application);
+    if (application->state() == Application::Suspended)
+        kill(application->pid(), SIGSTOP);
+}
+
+void TaskController::do_resume(Application* application)
+{
+    DLOG("TaskController::do_resume (this=%p, application=%p)", this, application);
+    if (application->state() == Application::Suspended)
+        kill(application->pid(), SIGCONT);
+}
+
+void TaskController::do_respawn(Application* application)
+{
+    DLOG("TaskController::do_respwn (this=%p, application=%p)", this, application);
+    if (application->state() == Application::Stopped) {
+        ApplicationManager *appMgr = static_cast<ApplicationManager*>(parent());
+        appMgr->respawnApplication(application);
+    }
+}

=== added file 'src/modules/Unity/ApplicationManager/taskcontroller.h'
--- src/modules/Unity/ApplicationManager/taskcontroller.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/ApplicationManager/taskcontroller.h	2013-08-27 14:37:14 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ricardo Mendoza <[e-mail]>
+ */
+
+#ifndef TASKCONTROLLER_H
+#define TASKCONTROLLER_H
+
+#include <QObject>
+
+#include "application.h"
+
+class ApplicationManager;
+class TaskController : public QObject
+{
+    Q_OBJECT
+public:
+    explicit TaskController(ApplicationManager* parent);
+    ~TaskController();
+
+    void do_resume(Application* application);
+    void do_suspend(Application* application);
+    void do_respawn(Application* application);
+};
+
+#endif // TASKCONTROLLER_H