1
=== modified file 'src/modules/Unity/Application/Application.pro'
2
--- src/modules/Unity/Application/Application.pro	2014-09-17 17:29:42 +0000
3
+++ src/modules/Unity/Application/Application.pro	2014-10-24 15:59:35 +0000
4
@@ -36,7 +36,6 @@
5
36
    ubuntukeyboardinfo.cpp \
36
    ubuntukeyboardinfo.cpp \
6
37
    mirsurfaceitem.cpp \
37
    mirsurfaceitem.cpp \
7
38
    mirbuffersgtexture.cpp \
38
    mirbuffersgtexture.cpp \
8
39
    processcontroller.cpp \
9
40
    proc_info.cpp \
39
    proc_info.cpp \
10
41
    session.cpp \
40
    session.cpp \
11
42
    sessionmanager.cpp \
41
    sessionmanager.cpp \
12
@@ -60,7 +59,6 @@
13
60
    mirsurfaceitemmodel.h \
59
    mirsurfaceitemmodel.h \
14
61
    mirbuffersgtexture.h \
60
    mirbuffersgtexture.h \
15
62
    objectlistmodel.h \
61
    objectlistmodel.h \
16
63
    processcontroller.h \
17
64
    proc_info.h \
62
    proc_info.h \
18
65
    session.h \
63
    session.h \
19
66
    session_interface.h \
64
    session_interface.h \
20
67
65
21
=== modified file 'src/modules/Unity/Application/application.cpp'
22
--- src/modules/Unity/Application/application.cpp	2014-10-13 10:07:10 +0000
23
+++ src/modules/Unity/Application/application.cpp	2014-10-24 15:59:35 +0000
24
@@ -325,13 +325,13 @@
25
325
void Application::onSessionSuspended()
325
void Application::onSessionSuspended()
26
326
{
326
{
27
327
    qCDebug(QTMIR_APPLICATIONS) << "Application::onSessionSuspended - appId=" << appId();
327
    qCDebug(QTMIR_APPLICATIONS) << "Application::onSessionSuspended - appId=" << appId();
29
328
    m_taskController->suspend(this);
328
    m_taskController->suspend(longAppId());
30
329
}
329
}
31
330
330
32
331
void Application::onSessionResumed()
331
void Application::onSessionResumed()
33
332
{
332
{
34
333
    qCDebug(QTMIR_APPLICATIONS) << "Application::onSessionResumed - appId=" << appId();
333
    qCDebug(QTMIR_APPLICATIONS) << "Application::onSessionResumed - appId=" << appId();
36
334
    m_taskController->resume(this);
334
    m_taskController->resume(longAppId());
37
335
}
335
}
38
336
336
39
337
void Application::respawn()
337
void Application::respawn()
40
338
338
41
=== modified file 'src/modules/Unity/Application/applicationcontroller.h'
42
--- src/modules/Unity/Application/applicationcontroller.h	2014-07-02 22:56:08 +0000
43
+++ src/modules/Unity/Application/applicationcontroller.h	2014-10-24 15:59:35 +0000
44
@@ -48,6 +48,9 @@
45
48
    virtual bool stopApplicationWithAppId(const QString &appId) = 0;
48
    virtual bool stopApplicationWithAppId(const QString &appId) = 0;
46
49
    virtual bool startApplicationWithAppIdAndArgs(const QString &appId, const QStringList &arguments) = 0;
49
    virtual bool startApplicationWithAppIdAndArgs(const QString &appId, const QStringList &arguments) = 0;
47
50
50
48
51
    virtual bool pauseApplicationWithAppId(const QString &appId) = 0;
49
52
    virtual bool resumeApplicationWithAppId(const QString &appId) = 0;
50
53
51
51
    virtual QFileInfo findDesktopFileForAppId(const QString &appId) const = 0;
54
    virtual QFileInfo findDesktopFileForAppId(const QString &appId) const = 0;
52
52
55
53
53
Q_SIGNALS:
56
Q_SIGNALS:
54
54
57
55
=== removed file 'src/modules/Unity/Application/processcontroller.cpp'
56
--- src/modules/Unity/Application/processcontroller.cpp	2014-10-10 08:38:30 +0000
57
+++ src/modules/Unity/Application/processcontroller.cpp	1970-01-01 00:00:00 +0000
58
@@ -1,231 +0,0 @@
59
1
/*
60
2
 * Copyright (C) 2014 Canonical, Ltd.
61
3
 *
62
4
 * This program is free software: you can redistribute it and/or modify it under
63
5
 * the terms of the GNU Lesser General Public License version 3, as published by
64
6
 * the Free Software Foundation.
65
7
 *
66
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
67
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
68
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
69
11
 * Lesser General Public License for more details.
70
12
 *
71
13
 * You should have received a copy of the GNU Lesser General Public License
72
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
73
15
 *
74
16
 */
75
17
76
18
#include "processcontroller.h"
77
19
78
20
#include "logging.h"
79
21
80
22
// Process C++
81
23
#include <core/posix/process.h>
82
24
#include <core/posix/this_process.h>
83
25
#include <core/posix/linux/proc/process/oom_adj.h>
84
26
#include <core/posix/linux/proc/process/oom_score_adj.h>
85
27
86
28
// std
87
29
#include <signal.h>
88
30
#include <unistd.h>
89
31
90
32
/*
91
33
 * ProcessController
92
34
 * This class manages individual processes during their lifetime. It allows one to pause
93
35
 * and resume processes.
94
36
 *
95
37
 * It also has methods to set a score on processes which is used by the Out of Memory (OOM)
96
38
 * process killer to decide what process gets killed in a low memory situation.
97
39
 */
98
40
99
41
namespace plpp = core::posix::linux::proc::process;
100
42
101
43
namespace qtmir
102
44
{
103
45
104
46
ProcessController::OomController::OomController()
105
47
{
106
48
}
107
49
108
50
/*!
109
51
 * \brief ProcessController::OomController::ensureProcessLikelyToBeKilled
110
52
 * \param pid
111
53
 * Set the process OOM-killer score so that the process is _more_ likely to be killed
112
54
 * in a low memory situation
113
55
 */
114
56
115
57
/*
116
58
 * Useful information about these OOM-weighting methods
117
59
 *
118
60
 * the "Process C++" library wraps some APIs exported by the kernel in the the /proc filesystem.
119
61
 * The OOM score is one of these, but the APIs for it changed from Linux 2.6.36 onward.
120
62
 *
121
63
 * === Up to Linux 2.6.36 ===
122
64
 * /proc/[pid]/oom_adj (wrapped by plpp::OomAdj) was used up to 2.6.36 (is deprecated now)
123
65
 * Valid values are in the range -16 to +15, plus the special value -17, which disables
124
66
 * OOM-killing altogether for this process.  A positive score increases the likelihood
125
67
 * of this process being killed by the OOM-killer; a negative score decreases the likelihood.
126
68
 *
127
69
 * The default value for this file is 0; a new process inherits its parent's oom_adj setting.
128
70
 *
129
71
 * === Linux 2.6.36 and later ===
130
72
 * /proc/[pid]/oom_score_adj (wrapped by plpp::OomScoreAdj) is the recommended API.  Valid
131
73
 * values are in the range -1000 (never kill) to 1000 (always kill).
132
74
 *
133
75
 * For backward compatibility with previous kernels, /proc/[pid]/oom_adj can still be used to
134
76
 * tune the badness score.  Its value is scaled linearly with oom_score_adj. So writing to
135
77
 * /proc/[pid]/oom_score_adj or /proc/[pid]/oom_adj will change the other with its scaled value.
136
78
 *
137
79
 * === How OOM score changing is implemented ===
138
80
 * To support all available kernels, we thus perform the following for any OOM score change:
139
81
 *  1. Attempt to use the newer kernel API (plpp::OomScoreAdj). Fetch the min & max possible
140
82
 *     values and calculate a desired score for the process.
141
83
 *  2. If that fails, fall back to the older kernel API (plpp::OomSAdj), again fetching min
142
84
 *     & max possible values and calculating a desired score for the process.
143
85
 */
144
86
void ProcessController::OomController::ensureProcessLikelyToBeKilled(pid_t pid)
145
87
{
146
88
    // We avoid boundary values for oom_score_adj. For that, we
147
89
    // set it to 80% of the total available range.
148
90
    static const float defaultPercentage = 0.8;
149
91
150
92
    core::posix::Process process(pid);
151
93
152
94
    try {
153
95
        plpp::OomScoreAdj shellScore;
154
96
        core::posix::this_process::instance() >> shellScore;
155
97
156
98
        plpp::OomScoreAdj processScore
157
99
        {
158
100
            static_cast<int>((plpp::OomScoreAdj::max_value() - shellScore.value) * defaultPercentage) + shellScore.value
159
101
        };
160
102
161
103
        process << processScore;
162
104
    } catch(...) {
163
105
        // Accessing OomScoreAdj resulted in an exception being thrown.
164
106
        // Trying with the deprecated OomAdj now as a last resort.
165
107
        try
166
108
        {
167
109
            process << plpp::OomAdj{plpp::OomAdj::max_value()};
168
110
        } catch(...)
169
111
        {
170
112
            qDebug() << "ensureProcessIsLikelyToBeKilled failed for pid=" << pid;
171
113
        }
172
114
    }
173
115
}
174
116
175
117
/*!
176
118
 * \brief ProcessController::OomController::ensureProcessLessLikelyToBeKilled
177
119
 * \param pid
178
120
 * Set the process OOM-killer score so that, in a low memory situation, the process
179
121
 * is _more_ likely to be killed than the foreground application, but less likely
180
122
 * than the background applications
181
123
 */
182
124
void ProcessController::OomController::ensureProcessLessLikelyToBeKilled(pid_t pid)
183
125
{
184
126
    // Set it to 50% of the total available range.
185
127
    static const float defaultPercentage = 0.5;
186
128
187
129
    core::posix::Process process(pid);
188
130
189
131
    try {
190
132
        plpp::OomScoreAdj shellScore;
191
133
        core::posix::this_process::instance() >> shellScore;
192
134
193
135
        plpp::OomScoreAdj processScore
194
136
        {
195
137
            static_cast<int>((plpp::OomScoreAdj::max_value() - shellScore.value) * defaultPercentage) + shellScore.value
196
138
        };
197
139
198
140
        process << processScore;
199
141
    } catch(...) {
200
142
        // Accessing OomScoreAdj resulted in an exception being thrown.
201
143
        // Trying with the deprecated OomAdj now as a last resort.
202
144
        try
203
145
        {
204
146
            process << plpp::OomAdj{plpp::OomAdj::max_value()};
205
147
        } catch(...)
206
148
        {
207
149
            qDebug() << "ensureProcessIsLessLikelyToBeKilled failed for pid=" << pid;
208
150
        }
209
151
    }
210
152
}
211
153
212
154
/*!
213
155
 * \brief ProcessController::OomController::ensureProcessUnlikelyToBeKilled
214
156
 * \param pid
215
157
 * Set the process OOM-killer weighting so that the process is _less_ likely to be killed
216
158
 * in a low memory situation
217
159
 */
218
160
void ProcessController::OomController::ensureProcessUnlikelyToBeKilled(pid_t pid)
219
161
{
220
162
    // By system default, we set the oom_score_adj of Unity8 to -10 (via lightdm).
221
163
    // As we want to avoid that any app's oom_score_adj is <= Unity8's oom_score_adj,
222
164
    // (i.e. Unity8 would be killed before that app is) we choose a default increase of +1.
223
165
    static const int default_increase = 1;
224
166
225
167
    core::posix::Process process(pid);
226
168
227
169
    try {
228
170
        plpp::OomScoreAdj shellScore;
229
171
        core::posix::this_process::instance() >> shellScore;
230
172
231
173
        plpp::OomScoreAdj processScore
232
174
        {
233
175
            shellScore.value + default_increase
234
176
        };
235
177
236
178
        process << processScore;
237
179
    } catch(...) {
238
180
        // Accessing OomScoreAdj resulted in an exception being thrown.
239
181
        // Trying with the deprecated OomAdj now as a last resort.
240
182
        // By system default, we set the oom_score_adj of Unity8 to -10 (via lightdm).
241
183
        // As we want to avoid that any app's oom_score_adj or oom_adj is <= Unity8's oom_score_adj,
242
184
        // we choose a default value of -9 for oom_score_adj and 0 for oom_adj.
243
185
        static const int defaultValue = 0;
244
186
245
187
        try
246
188
        {
247
189
            process << plpp::OomAdj{defaultValue};
248
190
        } catch(...)
249
191
        {
250
192
            qDebug() << "ensureProcessIsUnlikelyToBeKilled failed for pid" << pid;
251
193
        }
252
194
    }
253
195
}
254
196
255
197
ProcessController::ProcessController()
256
198
    : m_oomController(new ProcessController::OomController())
257
199
{
258
200
}
259
201
260
202
ProcessController::~ProcessController()
261
203
{
262
204
}
263
205
264
206
const QSharedPointer<ProcessController::OomController>& ProcessController::oomController() const
265
207
{
266
208
    return m_oomController;
267
209
}
268
210
269
211
/*!
270
212
 * \brief ProcessController::sigStopProcessGroupForPid
271
213
 * \param pid
272
214
 * \return True if process was stopped successfully, false otherwise
273
215
 */
274
216
bool ProcessController::sigStopProcessGroupForPid(pid_t pid) const
275
217
{
276
218
    return -1 != kill(-pid, SIGSTOP);
277
219
}
278
220
279
221
/*!
280
222
 * \brief ProcessController::sigContinueProcessGroupForPid
281
223
 * \param pid
282
224
 * \return True of process was resumed successfully, false otherwise
283
225
 */
284
226
bool ProcessController::sigContinueProcessGroupForPid(pid_t pid) const
285
227
{
286
228
    return -1 != kill(-pid, SIGCONT);
287
229
}
288
230
289
231
} // namespace qtmir
290
232
0
291
=== removed file 'src/modules/Unity/Application/processcontroller.h'
292
--- src/modules/Unity/Application/processcontroller.h	2014-10-10 08:38:30 +0000
293
+++ src/modules/Unity/Application/processcontroller.h	1970-01-01 00:00:00 +0000
294
@@ -1,62 +0,0 @@
295
1
/*
296
2
 * Copyright (C) 2014 Canonical, Ltd.
297
3
 *
298
4
 * This program is free software: you can redistribute it and/or modify it under
299
5
 * the terms of the GNU Lesser General Public License version 3, as published by
300
6
 * the Free Software Foundation.
301
7
 *
302
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
303
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
304
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
305
11
 * Lesser General Public License for more details.
306
12
 *
307
13
 * You should have received a copy of the GNU Lesser General Public License
308
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
309
15
 *
310
16
 */
311
17
312
18
#ifndef PROCESS_CONTROLLER_H
313
19
#define PROCESS_CONTROLLER_H
314
20
315
21
#include <QSharedPointer>
316
22
317
23
#include <sys/types.h>
318
24
319
25
namespace qtmir
320
26
{
321
27
322
28
class ProcessController
323
29
{
324
30
public:
325
31
    class OomController
326
32
    {
327
33
    public:
328
34
        OomController();
329
35
        OomController(const OomController&) = delete;
330
36
        virtual ~OomController() = default;
331
37
332
38
        OomController& operator=(const OomController&) = delete;
333
39
334
40
        virtual void ensureProcessLikelyToBeKilled(pid_t);
335
41
        virtual void ensureProcessLessLikelyToBeKilled(pid_t);
336
42
        virtual void ensureProcessUnlikelyToBeKilled(pid_t);
337
43
    };
338
44
339
45
    ProcessController();
340
46
    ProcessController(const ProcessController&) = delete;
341
47
    virtual ~ProcessController();
342
48
343
49
    ProcessController& operator=(const ProcessController&) = delete;
344
50
345
51
    virtual const QSharedPointer<OomController>& oomController() const;
346
52
347
53
    virtual bool sigStopProcessGroupForPid(pid_t pid) const;
348
54
    virtual bool sigContinueProcessGroupForPid(pid_t pid) const;
349
55
350
56
protected:
351
57
    QSharedPointer<OomController> m_oomController;
352
58
};
353
59
354
60
} // namespace qtmir
355
61
356
62
#endif // PROCESS_CONTROLLER_H
357
63
0
358
=== modified file 'src/modules/Unity/Application/taskcontroller.cpp'
359
--- src/modules/Unity/Application/taskcontroller.cpp	2014-10-10 08:38:30 +0000
360
+++ src/modules/Unity/Application/taskcontroller.cpp	2014-10-24 15:59:35 +0000
361
@@ -23,12 +23,6 @@
362
23
// Qt
23
// Qt
363
24
#include <QStringList>
24
#include <QStringList>
364
25
25
365
26
// Process C++
366
27
#include <core/posix/process.h>
367
28
#include <core/posix/this_process.h>
368
29
#include <core/posix/linux/proc/process/oom_adj.h>
369
30
#include <core/posix/linux/proc/process/oom_score_adj.h>
370
31
371
32
// STL
26
// STL
372
33
#include <mutex>
27
#include <mutex>
373
34
28
374
@@ -41,11 +35,9 @@
375
41
35
376
42
TaskController::TaskController(
36
TaskController::TaskController(
377
43
        QObject *parent,
37
        QObject *parent,
380
44
        const QSharedPointer<ApplicationController> &appController,
38
        const QSharedPointer<ApplicationController> &appController) :
379
45
        const QSharedPointer<ProcessController> &processController) :
381
46
    QObject(parent),
39
    QObject(parent),
384
47
    m_appController(appController),
40
    m_appController(appController)
383
48
    m_processController(processController)
385
49
{
41
{
386
50
    connect(m_appController.data(),
42
    connect(m_appController.data(),
387
51
            &ApplicationController::applicationAboutToBeStarted,
43
            &ApplicationController::applicationAboutToBeStarted,
388
@@ -53,11 +45,6 @@
389
53
            &TaskController::processStarting);
45
            &TaskController::processStarting);
390
54
46
391
55
    connect(m_appController.data(),
47
    connect(m_appController.data(),
392
56
            &ApplicationController::applicationStarted,
393
57
            this,
394
58
            &TaskController::onApplicationStarted);
395
59
396
60
    connect(m_appController.data(),
397
61
            &ApplicationController::applicationStopped,
48
            &ApplicationController::applicationStopped,
398
62
            this,
49
            this,
399
63
            &TaskController::processStopped);
50
            &TaskController::processStopped);
400
@@ -109,64 +96,20 @@
401
109
    return m_appController->findDesktopFileForAppId(appId);
96
    return m_appController->findDesktopFileForAppId(appId);
402
110
}
97
}
403
111
98
456
112
bool TaskController::suspend(const Application* app)
99
bool TaskController::suspend(const QString &appId)
457
113
{
100
{
458
114
    qCDebug(QTMIR_APPLICATIONS) << "TaskController::suspend - appId=" << app->appId();
101
    qCDebug(QTMIR_APPLICATIONS) << "TaskController::suspend - appId=" << appId;
459
115
    pid_t pid = m_appController->primaryPidForAppId(app->appId());
102
    return m_appController->pauseApplicationWithAppId(appId);
460
116
    if (pid == 0) {
103
}
461
117
        pid = app->pid();
104
462
118
    }
105
bool TaskController::resume(const QString &appId)
463
119
106
{
464
120
    // FIXME This harcodes the unity8-dash name, we should consider a different approach,
107
    qCDebug(QTMIR_APPLICATIONS) << "TaskController::resume - appId=" << appId;
465
121
    // some privileged way to define which apps should be less likely to be killed.
108
    return m_appController->resumeApplicationWithAppId(appId);
414
122
    if (app->appId() == "unity8-dash") {
415
123
        m_processController->oomController()->ensureProcessLessLikelyToBeKilled(pid);
416
124
    } else {
417
125
        m_processController->oomController()->ensureProcessLikelyToBeKilled(pid);
418
126
    }
419
127
420
128
    if (pid) {
421
129
        // We do assume that the app was launched by ubuntu-app-launch and with that,
422
130
        // in its own process group. For that, we interpret the pid as pgid and
423
131
        // sigstop the complete process group on suspend.
424
132
        return m_processController->sigStopProcessGroupForPid(pid);
425
133
    } else {
426
134
        return false;
427
135
    }
428
136
}
429
137
430
138
bool TaskController::resume(const Application* app)
431
139
{
432
140
    qCDebug(QTMIR_APPLICATIONS) << "TaskController::resume - appId=" << app->appId();
433
141
    pid_t pid = m_appController->primaryPidForAppId(app->appId());
434
142
    if (pid == 0) {
435
143
        pid = app->pid();
436
144
    }
437
145
438
146
    m_processController->oomController()->ensureProcessUnlikelyToBeKilled(pid);
439
147
440
148
    if (pid) {
441
149
        // We do assume that the app was launched by ubuntu-app-launch and with that,
442
150
        // in its own process group. For that, we interpret the pid as pgid and
443
151
        // sigcont the complete process group on resume.
444
152
        return m_processController->sigContinueProcessGroupForPid(pid);
445
153
        return true;
446
154
    } else {
447
155
        qCDebug(QTMIR_APPLICATIONS) << "TaskController::resume - couldn't find PID to resume for appId=" << app->appId();
448
156
        return false;
449
157
    }
450
158
}
451
159
452
160
void TaskController::onApplicationStarted(const QString& id)
453
161
{
454
162
    pid_t pid = m_appController->primaryPidForAppId(id);
455
163
    m_processController->oomController()->ensureProcessUnlikelyToBeKilled(pid);
466
164
}
109
}
467
165
110
468
166
void TaskController::onApplicationFocusRequest(const QString& id)
111
void TaskController::onApplicationFocusRequest(const QString& id)
469
167
{
112
{
470
168
    pid_t pid = m_appController->primaryPidForAppId(id);
471
169
    m_processController->oomController()->ensureProcessUnlikelyToBeKilled(pid);
472
170
    Q_EMIT requestFocus(id);
113
    Q_EMIT requestFocus(id);
473
171
}
114
}
474
172
115
475
173
116
476
=== modified file 'src/modules/Unity/Application/taskcontroller.h'
477
--- src/modules/Unity/Application/taskcontroller.h	2014-09-18 09:39:48 +0000
478
+++ src/modules/Unity/Application/taskcontroller.h	2014-10-24 15:59:35 +0000
479
@@ -23,7 +23,6 @@
480
23
23
481
24
#include "application.h"
24
#include "application.h"
482
25
#include "applicationcontroller.h"
25
#include "applicationcontroller.h"
483
26
#include "processcontroller.h"
484
27
26
485
28
namespace qtmir
27
namespace qtmir
486
29
{
28
{
487
@@ -34,15 +33,14 @@
488
34
public:
33
public:
489
35
    TaskController(
34
    TaskController(
490
36
            QObject *parent,
35
            QObject *parent,
493
37
            const QSharedPointer<ApplicationController> &appController,
36
            const QSharedPointer<ApplicationController> &appController);
492
38
            const QSharedPointer<ProcessController> &processController = QSharedPointer<ProcessController>(new ProcessController()));
494
39
    ~TaskController();
37
    ~TaskController();
495
40
38
496
41
    bool start(const QString &appId, const QStringList &args);
39
    bool start(const QString &appId, const QStringList &args);
497
42
    bool stop(const QString &appId);
40
    bool stop(const QString &appId);
498
43
41
501
44
    bool suspend(const Application* app);
42
    bool suspend(const QString &appId);
502
45
    bool resume(const Application* app);
43
    bool resume(const QString &appId);
503
46
44
504
47
    bool appIdHasProcessId(const QString &appId, const quint64 pid) const;
45
    bool appIdHasProcessId(const QString &appId, const quint64 pid) const;
505
48
    QFileInfo findDesktopFileForAppId(const QString &appId) const;
46
    QFileInfo findDesktopFileForAppId(const QString &appId) const;
506
@@ -55,7 +53,6 @@
507
55
    void requestResume(const QString &appId);
53
    void requestResume(const QString &appId);
508
56
54
509
57
private Q_SLOTS:
55
private Q_SLOTS:
510
58
    void onApplicationStarted(const QString &id);
511
59
    void onApplicationFocusRequest(const QString &id);
56
    void onApplicationFocusRequest(const QString &id);
512
60
    void onApplicationResumeRequest(const QString &id);
57
    void onApplicationResumeRequest(const QString &id);
513
61
58
514
@@ -63,7 +60,6 @@
515
63
60
516
64
private:
61
private:
517
65
    const QSharedPointer<ApplicationController> m_appController;
62
    const QSharedPointer<ApplicationController> m_appController;
518
66
    const QSharedPointer<ProcessController> m_processController;
519
67
};
63
};
520
68
64
521
69
} // namespace qtmir
65
} // namespace qtmir
522
70
66
523
=== modified file 'src/modules/Unity/Application/upstart/applicationcontroller.cpp'
524
--- src/modules/Unity/Application/upstart/applicationcontroller.cpp	2014-07-01 13:38:06 +0000
525
+++ src/modules/Unity/Application/upstart/applicationcontroller.cpp	2014-10-24 15:59:35 +0000
526
@@ -203,6 +203,25 @@
527
203
    return result;
203
    return result;
528
204
}
204
}
529
205
205
530
206
bool ApplicationController::pauseApplicationWithAppId(const QString& appId)
531
207
{
532
208
    auto result = ubuntu_app_launch_pause_application(toLongAppIdIfPossible(appId).toLatin1().constData());
533
209
    if (!result)
534
210
        qDebug() << "ApplicationController::pauseApplication FAILED to pause appId=" << appId;
535
211
536
212
    return result;
537
213
}
538
214
539
215
bool ApplicationController::resumeApplicationWithAppId(const QString& appId)
540
216
{
541
217
    auto result = ubuntu_app_launch_resume_application(toLongAppIdIfPossible(appId).toLatin1().constData());
542
218
    if (!result)
543
219
        qDebug() << "ApplicationController::resumeApplication FAILED to resume appId=" << appId;
544
220
545
221
    return result;
546
222
}
547
223
548
224
549
206
QFileInfo ApplicationController::findDesktopFileForAppId(const QString &appId) const
225
QFileInfo ApplicationController::findDesktopFileForAppId(const QString &appId) const
550
207
{
226
{
551
208
    qCDebug(QTMIR_APPLICATIONS) << "ApplicationController::desktopFilePathForAppId - appId=" << appId;
227
    qCDebug(QTMIR_APPLICATIONS) << "ApplicationController::desktopFilePathForAppId - appId=" << appId;
552
209
228
553
=== modified file 'src/modules/Unity/Application/upstart/applicationcontroller.h'
554
--- src/modules/Unity/Application/upstart/applicationcontroller.h	2014-07-01 13:38:06 +0000
555
+++ src/modules/Unity/Application/upstart/applicationcontroller.h	2014-10-24 15:59:35 +0000
556
@@ -37,6 +37,9 @@
557
37
    bool stopApplicationWithAppId(const QString& appId) override;
37
    bool stopApplicationWithAppId(const QString& appId) override;
558
38
    bool startApplicationWithAppIdAndArgs(const QString& appId, const QStringList& arguments) override;
38
    bool startApplicationWithAppIdAndArgs(const QString& appId, const QStringList& arguments) override;
559
39
39
560
40
    bool pauseApplicationWithAppId(const QString& appId) override;
561
41
    bool resumeApplicationWithAppId(const QString& appId) override;
562
42
563
40
    QFileInfo findDesktopFileForAppId(const QString &appId) const override;
43
    QFileInfo findDesktopFileForAppId(const QString &appId) const override;
564
41
44
565
42
private:
45
private:
566
43
46
567
=== modified file 'tests/modules/ApplicationManager/application_manager_test.cpp'
568
--- tests/modules/ApplicationManager/application_manager_test.cpp	2014-10-10 08:38:30 +0000
569
+++ tests/modules/ApplicationManager/application_manager_test.cpp	2014-10-24 15:59:35 +0000
570
@@ -56,12 +56,6 @@
571
56
56
572
57
    EXPECT_CALL(desktopFileReaderFactory, createInstance(_, _)).Times(1);
57
    EXPECT_CALL(desktopFileReaderFactory, createInstance(_, _)).Times(1);
573
58
58
574
59
    EXPECT_CALL(processController, sigStopProcessGroupForPid(_)).Times(1);
575
60
    EXPECT_CALL(processController, sigContinueProcessGroupForPid(_)).Times(1);
576
61
    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(_)).Times(1);
577
62
    EXPECT_CALL(oomController, ensureProcessLikelyToBeKilled(_)).Times(1);
578
63
    EXPECT_CALL(oomController, ensureProcessLessLikelyToBeKilled(_)).Times(0);
579
64
580
65
    auto application = applicationManager.startApplication(
59
    auto application = applicationManager.startApplication(
581
66
                appId,
60
                appId,
582
67
                ApplicationManager::NoFlag,
61
                ApplicationManager::NoFlag,
583
@@ -87,12 +81,6 @@
584
87
81
585
88
    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
82
    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
586
89
83
587
90
    EXPECT_CALL(processController, sigStopProcessGroupForPid(_)).Times(1);
588
91
    EXPECT_CALL(processController, sigContinueProcessGroupForPid(_)).Times(1);
589
92
    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(_)).Times(1);
590
93
    EXPECT_CALL(oomController, ensureProcessLikelyToBeKilled(_)).Times(0);
591
94
    EXPECT_CALL(oomController, ensureProcessLessLikelyToBeKilled(_)).Times(1);
592
95
593
96
    bool authed = true;
84
    bool authed = true;
594
97
85
595
98
    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("Oo", procId);
86
    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("Oo", procId);
596
@@ -131,12 +119,6 @@
597
131
        onSessionStarting( mirSession );
119
        onSessionStarting( mirSession );
598
132
120
599
133
        EXPECT_NE(nullptr, application);
121
        EXPECT_NE(nullptr, application);
600
134
601
135
        appIds.insert(appId);
602
136
        auto it = appController.children.find(appId);
603
137
        if (it != appController.children.end())
604
138
            EXPECT_CALL(oomController,
605
139
                        ensureProcessUnlikelyToBeKilled(it->pid())).Times(1);
606
140
    }
122
    }
607
141
123
608
142
    for (auto appId : appIds)
124
    for (auto appId : appIds)
609
143
125
610
=== modified file 'tests/modules/TaskController/taskcontroller_test.cpp'
611
--- tests/modules/TaskController/taskcontroller_test.cpp	2014-09-10 11:01:14 +0000
612
+++ tests/modules/TaskController/taskcontroller_test.cpp	2014-10-24 15:59:35 +0000
613
@@ -19,13 +19,8 @@
614
19
#include <Unity/Application/desktopfilereader.h>
19
#include <Unity/Application/desktopfilereader.h>
615
20
#include <Unity/Application/application.h>
20
#include <Unity/Application/application.h>
616
21
21
617
22
#include "mock_oom_controller.h"
618
23
#include "mock_process_controller.h"
619
24
#include "mock_desktop_file_reader.h"
22
#include "mock_desktop_file_reader.h"
620
25
23
621
26
#include <core/posix/fork.h>
622
27
#include <core/posix/linux/proc/process/oom_score_adj.h>
623
28
624
29
#include <gmock/gmock.h>
24
#include <gmock/gmock.h>
625
30
#include <gtest/gtest.h>
25
#include <gtest/gtest.h>
626
31
26
627
@@ -56,6 +51,8 @@
628
56
51
629
57
    MOCK_METHOD1(stopApplicationWithAppId, bool(const QString&));
52
    MOCK_METHOD1(stopApplicationWithAppId, bool(const QString&));
630
58
    MOCK_METHOD2(startApplicationWithAppIdAndArgs, bool(const QString&, const QStringList&));
53
    MOCK_METHOD2(startApplicationWithAppIdAndArgs, bool(const QString&, const QStringList&));
631
54
    MOCK_METHOD1(pauseApplicationWithAppId, bool(const QString&));
632
55
    MOCK_METHOD1(resumeApplicationWithAppId, bool(const QString&));
633
59
};
56
};
634
60
}
57
}
635
61
58
636
@@ -72,19 +69,8 @@
637
72
69
638
73
    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, QStringList())).Times(1).WillRepeatedly(Return(true));
70
    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, QStringList())).Times(1).WillRepeatedly(Return(true));
639
74
71
640
75
    testing::NiceMock<MockOomController> oomController;
641
76
    QSharedPointer<ProcessController::OomController> oomControllerPtr(
642
77
                &oomController,
643
78
                [](ProcessController::OomController*){});
644
79
645
80
    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
646
81
    QSharedPointer<ProcessController> processControllerPtr(
647
82
                &processController,
648
83
                [](ProcessController*){});
649
84
650
85
    TaskController taskController(nullptr,
72
    TaskController taskController(nullptr,
653
86
                                  appControllerPtr,
73
                                  appControllerPtr);
652
87
                                  processControllerPtr);
654
88
74
655
89
    taskController.start(appId, QStringList());
75
    taskController.start(appId, QStringList());
656
90
}
76
}
657
@@ -102,189 +88,9 @@
658
102
88
659
103
    EXPECT_CALL(appController, stopApplicationWithAppId(appId)).Times(1).WillRepeatedly(Return(true));
89
    EXPECT_CALL(appController, stopApplicationWithAppId(appId)).Times(1).WillRepeatedly(Return(true));
660
104
90
661
105
    testing::NiceMock<MockOomController> oomController;
662
106
    QSharedPointer<ProcessController::OomController> oomControllerPtr(
663
107
                &oomController,
664
108
                [](ProcessController::OomController*){});
665
109
666
110
    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
667
111
    QSharedPointer<ProcessController> processControllerPtr(
668
112
                &processController,
669
113
                [](ProcessController*){});
670
114
671
115
    TaskController taskController(nullptr,
91
    TaskController taskController(nullptr,
674
116
                                  appControllerPtr,
92
                                  appControllerPtr);
673
117
                                  processControllerPtr);
675
118
93
676
119
    taskController.stop(appId);
94
    taskController.stop(appId);
677
120
}
95
}
678
121
96
679
122
TEST(TaskController, suspendingAnApplicationAdjustsOomScoreForCorrectPid)
680
123
{
681
124
    using namespace ::testing;
682
125
683
126
    const QString appId{"com.canonical.does.not.exist"};
684
127
685
128
    testing::NiceMock<TriggerableApplicationController> appController;
686
129
    QSharedPointer<TriggerableApplicationController> appControllerPtr(
687
130
                &appController,
688
131
                [](ApplicationController*){});
689
132
690
133
    EXPECT_CALL(appController, primaryPidForAppId(appId)).Times(1).WillRepeatedly(Return(-1));
691
134
692
135
    testing::NiceMock<MockOomController> oomController;
693
136
    QSharedPointer<ProcessController::OomController> oomControllerPtr(
694
137
                &oomController,
695
138
                [](ProcessController::OomController*){});
696
139
697
140
    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
698
141
    QSharedPointer<ProcessController> processControllerPtr(
699
142
                &processController,
700
143
                [](ProcessController*){});
701
144
702
145
    EXPECT_CALL(oomController, ensureProcessLikelyToBeKilled(-1)).Times(1);
703
146
704
147
    auto taskController = QSharedPointer<TaskController>(new TaskController(nullptr,
705
148
                                  appControllerPtr,
706
149
                                  processControllerPtr));
707
150
708
151
709
152
    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
710
153
    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
711
154
    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
712
155
    Application *app = new Application(taskController, mockDesktopFileReader, Application::Running, QStringList(), nullptr);
713
156
    taskController->suspend(app);
714
157
    delete app;
715
158
}
716
159
717
160
TEST(TaskController, resumingAnApplicationAdjustsOomScoreForCorrectPid)
718
161
{
719
162
    using namespace ::testing;
720
163
721
164
    const QString appId{"com.canonical.does.not.exist"};
722
165
723
166
    testing::NiceMock<TriggerableApplicationController> appController;
724
167
    QSharedPointer<TriggerableApplicationController> appControllerPtr(
725
168
                &appController,
726
169
                [](ApplicationController*){});
727
170
728
171
    EXPECT_CALL(appController, primaryPidForAppId(appId)).Times(1).WillRepeatedly(Return(-1));
729
172
730
173
    testing::NiceMock<MockOomController> oomController;
731
174
    QSharedPointer<ProcessController::OomController> oomControllerPtr(
732
175
                &oomController,
733
176
                [](ProcessController::OomController*){});
734
177
735
178
    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
736
179
    QSharedPointer<ProcessController> processControllerPtr(
737
180
                &processController,
738
181
                [](ProcessController*){});
739
182
740
183
    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(-1)).Times(1);
741
184
742
185
    auto taskController = QSharedPointer<TaskController>(new TaskController(nullptr,
743
186
                                  appControllerPtr,
744
187
                                  processControllerPtr));
745
188
746
189
747
190
    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
748
191
    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
749
192
    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
750
193
    Application *app = new Application(taskController, mockDesktopFileReader, Application::Running, QStringList(), nullptr);
751
194
    taskController->resume(app);
752
195
    delete app;
753
196
}
754
197
755
198
TEST(TaskController, aStartedApplicationIsOomScoreAdjusted)
756
199
{
757
200
    using namespace ::testing;
758
201
759
202
    const QString appId{"com.canonical.does.not.exist"};
760
203
761
204
    testing::NiceMock<TriggerableApplicationController> appController;
762
205
    QSharedPointer<TriggerableApplicationController> appControllerPtr(
763
206
                &appController,
764
207
                [](ApplicationController*){});
765
208
    EXPECT_CALL(appController, primaryPidForAppId(appId)).Times(1).WillRepeatedly(Return(42));
766
209
767
210
    testing::NiceMock<MockOomController> oomController;
768
211
    QSharedPointer<ProcessController::OomController> oomControllerPtr(
769
212
                &oomController,
770
213
                [](ProcessController::OomController*){});
771
214
772
215
    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
773
216
    QSharedPointer<ProcessController> processControllerPtr(
774
217
                &processController,
775
218
                [](ProcessController*){});
776
219
777
220
    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(42)).Times(1);
778
221
779
222
    TaskController taskController(nullptr,
780
223
                                  appControllerPtr,
781
224
                                  processControllerPtr);
782
225
783
226
    appControllerPtr->triggerApplicationStarted(appId);
784
227
}
785
228
786
229
TEST(TaskController, aFocusedApplicationIsOomScoreAdjusted)
787
230
{
788
231
    using namespace ::testing;
789
232
790
233
    const QString appId{"com.canonical.does.not.exist"};
791
234
792
235
    testing::NiceMock<TriggerableApplicationController> appController;
793
236
    QSharedPointer<TriggerableApplicationController> appControllerPtr(
794
237
                &appController,
795
238
                [](ApplicationController*){});
796
239
    EXPECT_CALL(appController, primaryPidForAppId(appId)).Times(1).WillRepeatedly(Return(42));
797
240
798
241
    testing::NiceMock<MockOomController> oomController;
799
242
    QSharedPointer<ProcessController::OomController> oomControllerPtr(
800
243
                &oomController,
801
244
                [](ProcessController::OomController*){});
802
245
803
246
    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
804
247
    QSharedPointer<ProcessController> processControllerPtr(
805
248
                &processController,
806
249
                [](ProcessController*){});
807
250
808
251
    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(42)).Times(1);
809
252
810
253
    TaskController taskController(nullptr,
811
254
                                  appControllerPtr,
812
255
                                  processControllerPtr);
813
256
814
257
    appControllerPtr->triggerApplicationFocusRequest(appId);
815
258
}
816
259
817
260
TEST(TaskController, oomControllerUpdatesOomScoreAdjCorrectly)
818
261
{
819
262
    ProcessController::OomController oomController;
820
263
821
264
    auto child = core::posix::fork([]()
822
265
    {
823
266
        while (true);
824
267
825
268
        return core::posix::exit::Status::success;
826
269
    }, core::posix::StandardStream::empty);
827
270
828
271
    EXPECT_GT(child.pid(), 0);
829
272
830
273
    core::posix::linux::proc::process::OomScoreAdj oomScoreAdj;
831
274
    child >> oomScoreAdj;
832
275
833
276
    core::posix::linux::proc::process::OomScoreAdj likelyOomScoreAdj, unlikelyOomScoreAdj;
834
277
    {
835
278
        oomController.ensureProcessLikelyToBeKilled(child.pid());
836
279
        child >> likelyOomScoreAdj;
837
280
838
281
        EXPECT_GE(likelyOomScoreAdj.value, oomScoreAdj.value);
839
282
    }
840
283
841
284
    {
842
285
        oomController.ensureProcessUnlikelyToBeKilled(child.pid());
843
286
        child >> unlikelyOomScoreAdj;
844
287
845
288
        EXPECT_LE(unlikelyOomScoreAdj.value, likelyOomScoreAdj.value);
846
289
    }
847
290
}
848
291
97
849
=== modified file 'tests/modules/common/common.pri'
850
--- tests/modules/common/common.pri	2014-09-11 16:18:40 +0000
851
+++ tests/modules/common/common.pri	2014-10-24 15:59:35 +0000
852
@@ -1,5 +1,5 @@
853
1
CONFIG += no_keywords # keywords clash with ProcessC++
1
CONFIG += no_keywords # keywords clash with ProcessC++
855
2
PKGCONFIG += process-cpp ubuntu-app-launch-2
2
PKGCONFIG += ubuntu-app-launch-2 process-cpp
856
3
3
857
4
QT += quick
4
QT += quick
858
5
5
859
@@ -7,8 +7,6 @@
860
7
    ../common/mock_desktop_file_reader.h \
7
    ../common/mock_desktop_file_reader.h \
861
8
    ../common/mock_focus_controller.h \
8
    ../common/mock_focus_controller.h \
862
9
    ../common/mock_mir_session.h \
9
    ../common/mock_mir_session.h \
863
10
    ../common/mock_oom_controller.h \
864
11
    ../common/mock_process_controller.h \
865
12
    ../common/mock_proc_info.h \
10
    ../common/mock_proc_info.h \
866
13
    ../common/mock_prompt_session.h \
11
    ../common/mock_prompt_session.h \
867
14
    ../common/mock_prompt_session_manager.h \
12
    ../common/mock_prompt_session_manager.h \
868
15
13
869
=== modified file 'tests/modules/common/mock_application_controller.h'
870
--- tests/modules/common/mock_application_controller.h	2014-07-01 13:38:06 +0000
871
+++ tests/modules/common/mock_application_controller.h	2014-10-24 15:59:35 +0000
872
@@ -34,6 +34,8 @@
873
34
34
874
35
    MOCK_METHOD1(stopApplicationWithAppId, bool(const QString&));
35
    MOCK_METHOD1(stopApplicationWithAppId, bool(const QString&));
875
36
    MOCK_METHOD2(startApplicationWithAppIdAndArgs, bool(const QString&, const QStringList&));
36
    MOCK_METHOD2(startApplicationWithAppIdAndArgs, bool(const QString&, const QStringList&));
876
37
    MOCK_METHOD1(pauseApplicationWithAppId, bool(const QString&));
877
38
    MOCK_METHOD1(resumeApplicationWithAppId, bool(const QString&));
878
37
39
879
38
    MockApplicationController()
40
    MockApplicationController()
880
39
    {
41
    {
881
@@ -57,6 +59,14 @@
882
57
        ON_CALL(*this, startApplicationWithAppIdAndArgs(_, _))
59
        ON_CALL(*this, startApplicationWithAppIdAndArgs(_, _))
883
58
                .WillByDefault(
60
                .WillByDefault(
884
59
                    Invoke(this, &MockApplicationController::doStartApplicationWithAppIdAndArgs));
61
                    Invoke(this, &MockApplicationController::doStartApplicationWithAppIdAndArgs));
885
62
886
63
        ON_CALL(*this, pauseApplicationWithAppId(_))
887
64
                .WillByDefault(
888
65
                    Invoke(this, &MockApplicationController::doPauseApplicationWithAppId));
889
66
890
67
        ON_CALL(*this, resumeApplicationWithAppId(_))
891
68
                .WillByDefault(
892
69
                    Invoke(this, &MockApplicationController::doResumeApplicationWithAppId));
893
60
    }
70
    }
894
61
71
895
62
    pid_t doPrimaryPidForAppId(const QString& appId)
72
    pid_t doPrimaryPidForAppId(const QString& appId)
896
@@ -85,14 +95,14 @@
897
85
95
898
86
    bool doStopApplicationWithAppId(const QString& appId)
96
    bool doStopApplicationWithAppId(const QString& appId)
899
87
    {
97
    {
901
88
        (void) appId;
98
        Q_UNUSED(appId);
902
89
99
903
90
        return false;
100
        return false;
904
91
    }
101
    }
905
92
102
906
93
    bool doStartApplicationWithAppIdAndArgs(const QString& appId, const QStringList& args)
103
    bool doStartApplicationWithAppIdAndArgs(const QString& appId, const QStringList& args)
907
94
    {
104
    {
909
95
        (void) args;
105
        Q_UNUSED(args);
910
96
106
911
97
        auto child = core::posix::fork([]()
107
        auto child = core::posix::fork([]()
912
98
        {
108
        {
913
@@ -110,6 +120,20 @@
914
110
        return false;
120
        return false;
915
111
    }
121
    }
916
112
122
917
123
    bool doPauseApplicationWithAppId(const QString& appId)
918
124
    {
919
125
        Q_UNUSED(appId);
920
126
921
127
        return false;
922
128
    }
923
129
924
130
    bool doResumeApplicationWithAppId(const QString& appId)
925
131
    {
926
132
        Q_UNUSED(appId);
927
133
928
134
        return false;
929
135
    }
930
136
931
113
    QMap<QString, core::posix::ChildProcess> children;
137
    QMap<QString, core::posix::ChildProcess> children;
932
114
};
138
};
933
115
} // namespace testing
139
} // namespace testing
934
116
140
935
=== removed file 'tests/modules/common/mock_oom_controller.h'
936
--- tests/modules/common/mock_oom_controller.h	2014-10-10 08:38:30 +0000
937
+++ tests/modules/common/mock_oom_controller.h	1970-01-01 00:00:00 +0000
938
@@ -1,34 +0,0 @@
939
1
/*
940
2
 * Copyright (C) 2013 Canonical, Ltd.
941
3
 *
942
4
 * This program is free software: you can redistribute it and/or modify it under
943
5
 * the terms of the GNU Lesser General Public License version 3, as published by
944
6
 * the Free Software Foundation.
945
7
 *
946
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
947
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
948
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
949
11
 * Lesser General Public License for more details.
950
12
 *
951
13
 * You should have received a copy of the GNU Lesser General Public License
952
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
953
15
 *
954
16
 */
955
17
#ifndef MOCK_OOM_CONTROLLER_H
956
18
#define MOCK_OOM_CONTROLLER_H
957
19
958
20
#include <Unity/Application/processcontroller.h>
959
21
960
22
#include <gmock/gmock.h>
961
23
962
24
namespace testing
963
25
{
964
26
struct MockOomController : public qtmir::ProcessController::OomController
965
27
{
966
28
    MOCK_METHOD1(ensureProcessLikelyToBeKilled, void(pid_t));
967
29
    MOCK_METHOD1(ensureProcessLessLikelyToBeKilled, void(pid_t));
968
30
    MOCK_METHOD1(ensureProcessUnlikelyToBeKilled, void(pid_t));
969
31
};
970
32
}
971
33
972
34
#endif // MOCK_OOM_CONTROLLER_H
973
35
0
974
=== removed file 'tests/modules/common/mock_process_controller.h'
975
--- tests/modules/common/mock_process_controller.h	2014-07-01 13:38:06 +0000
976
+++ tests/modules/common/mock_process_controller.h	1970-01-01 00:00:00 +0000
977
@@ -1,45 +0,0 @@
978
1
/*
979
2
 * Copyright (C) 2013 Canonical, Ltd.
980
3
 *
981
4
 * This program is free software: you can redistribute it and/or modify it under
982
5
 * the terms of the GNU Lesser General Public License version 3, as published by
983
6
 * the Free Software Foundation.
984
7
 *
985
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
986
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
987
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
988
11
 * Lesser General Public License for more details.
989
12
 *
990
13
 * You should have received a copy of the GNU Lesser General Public License
991
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
992
15
 *
993
16
 */
994
17
#ifndef MOCK_PROCESS_CONTROLLER_H
995
18
#define MOCK_PROCESS_CONTROLLER_H
996
19
997
20
#include <Unity/Application/processcontroller.h>
998
21
999
22
#include <gmock/gmock.h>
1000
23
1001
24
namespace testing
1002
25
{
1003
26
struct MockProcessController : public qtmir::ProcessController
1004
27
{
1005
28
    MockProcessController(const QSharedPointer<qtmir::ProcessController::OomController>& oomController)
1006
29
        : m_oomController(oomController)
1007
30
    {
1008
31
    }
1009
32
1010
33
    const QSharedPointer<qtmir::ProcessController::OomController>& oomController() const
1011
34
    {
1012
35
        return m_oomController;
1013
36
    }
1014
37
1015
38
    MOCK_CONST_METHOD1(sigStopProcessGroupForPid, bool(pid_t));
1016
39
    MOCK_CONST_METHOD1(sigContinueProcessGroupForPid, bool(pid_t));
1017
40
1018
41
    QSharedPointer<qtmir::ProcessController::OomController> m_oomController;
1019
42
};
1020
43
}
1021
44
1022
45
#endif // MOCK_PROCESS_CONTROLLER_H
1023
46
0
1024
=== modified file 'tests/modules/common/qtmir_test.h'
1025
--- tests/modules/common/qtmir_test.h	2014-09-11 16:18:40 +0000
1026
+++ tests/modules/common/qtmir_test.h	2014-10-24 15:59:35 +0000
1027
@@ -20,8 +20,6 @@
1028
20
20
1029
21
#include <gtest/gtest.h>
21
#include <gtest/gtest.h>
1030
22
22
1031
23
#include <core/posix/linux/proc/process/oom_score_adj.h>
1032
24
1033
25
#include <Unity/Application/application_manager.h>
23
#include <Unity/Application/application_manager.h>
1034
26
#include <Unity/Application/applicationcontroller.h>
24
#include <Unity/Application/applicationcontroller.h>
1035
27
#include <Unity/Application/mirsurfacemanager.h>
25
#include <Unity/Application/mirsurfacemanager.h>
1036
@@ -32,8 +30,6 @@
1037
32
30
1038
33
#include "mock_application_controller.h"
31
#include "mock_application_controller.h"
1039
34
#include "mock_desktop_file_reader.h"
32
#include "mock_desktop_file_reader.h"
1040
35
#include "mock_oom_controller.h"
1041
36
#include "mock_process_controller.h"
1042
37
#include "mock_proc_info.h"
33
#include "mock_proc_info.h"
1043
38
#include "mock_mir_session.h"
34
#include "mock_mir_session.h"
1044
39
#include "mock_focus_controller.h"
35
#include "mock_focus_controller.h"
1045
@@ -80,12 +76,7 @@
1046
80
{
76
{
1047
81
public:
77
public:
1048
82
    QtMirTest()
78
    QtMirTest()
1055
83
        : processController{
79
        : mirConfig{
1050
84
            QSharedPointer<ProcessController::OomController> (
1051
85
                &oomController,
1052
86
                [](ProcessController::OomController*){})
1053
87
        }
1054
88
        , mirConfig{
1056
89
            QSharedPointer<FakeMirServerConfiguration> (new FakeMirServerConfiguration)
80
            QSharedPointer<FakeMirServerConfiguration> (new FakeMirServerConfiguration)
1057
90
        }
81
        }
1058
91
        , taskController{
82
        , taskController{
1059
@@ -94,10 +85,7 @@
1060
94
                      nullptr,
85
                      nullptr,
1061
95
                      QSharedPointer<ApplicationController>(
86
                      QSharedPointer<ApplicationController>(
1062
96
                          &appController,
87
                          &appController,
1067
97
                          [](ApplicationController*){}),
88
                          [](ApplicationController*){})
1064
98
                      QSharedPointer<ProcessController>(
1065
99
                          &processController,
1066
100
                          [](ProcessController*){})
1068
101
                  )
89
                  )
1069
102
              )
90
              )
1070
103
        }
91
        }
1071
@@ -150,8 +138,6 @@
1072
150
        return nullptr;
138
        return nullptr;
1073
151
    }
139
    }
1074
152
140
1075
153
    testing::NiceMock<testing::MockOomController> oomController;
1076
154
    testing::NiceMock<testing::MockProcessController> processController;
1077
155
    testing::NiceMock<testing::MockApplicationController> appController;
141
    testing::NiceMock<testing::MockApplicationController> appController;
1078
156
    testing::NiceMock<testing::MockProcInfo> procInfo;
142
    testing::NiceMock<testing::MockProcInfo> procInfo;
1079
157
    testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
143
    testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
Reviewer	Review Type	Date Requested	Status
Gerry Boland (community)		2014-09-25	Approve on 2014-10-24
PS Jenkins bot (community)	continuous-integration		Approve on 2014-10-23
Review via email: mp+236033@code.launchpad.net