1
=== modified file 'examples/CMakeLists.txt'
2
--- examples/CMakeLists.txt	2014-05-05 03:36:45 +0000
3
+++ examples/CMakeLists.txt	2014-05-09 12:26:43 +0000
4
@@ -92,6 +92,9 @@
5
92
92
6
93
)
93
)
7
94
94
8
95
add_executable(mir_demo_client_trust_session trust_session.c)
9
96
target_link_libraries(mir_demo_client_trust_session mirclient)
10
97
11
95
add_library(mirdraw STATIC graphics_utils.cpp)
98
add_library(mirdraw STATIC graphics_utils.cpp)
12
96
target_link_libraries(mirdraw ${GLESv2_LIBRARIES})
99
target_link_libraries(mirdraw ${GLESv2_LIBRARIES})
13
97
100
14
@@ -143,7 +146,7 @@
15
143
  server_configuration.cpp
146
  server_configuration.cpp
16
144
)
147
)
17
145
148
19
146
target_link_libraries(mir_demo_standalone_input_filter  
149
target_link_libraries(mir_demo_standalone_input_filter
20
147
  mirserver
150
  mirserver
21
148
)
151
)
22
149
152
23
@@ -158,8 +161,9 @@
24
158
  mir_demo_client_multiwin
161
  mir_demo_client_multiwin
25
159
  mir_demo_client_display_config
162
  mir_demo_client_display_config
26
160
  mir_demo_client_progressbar
163
  mir_demo_client_progressbar
27
164
  mir_demo_client_trust_session
28
161
  mir_demo_standalone_input_filter
165
  mir_demo_standalone_input_filter
30
162
  mir_demo_standalone_render_to_fb 
166
  mir_demo_standalone_render_to_fb
31
163
  mir_demo_standalone_render_surfaces
167
  mir_demo_standalone_render_surfaces
32
164
)
168
)
33
165
169
34
166
170
35
=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.cpp'
36
--- examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-04-15 05:31:19 +0000
37
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-05-09 12:26:43 +0000
38
@@ -102,7 +102,7 @@
39
102
102
40
103
    auto input_platform = mircv::InputPlatform::create();
103
    auto input_platform = mircv::InputPlatform::create();
41
104
    input_thread = input_platform->create_input_thread(
104
    input_thread = input_platform->create_input_thread(
43
105
        surface->client_input_fd(), 
105
        surface->client_input_fd(),
44
106
            std::bind(std::mem_fn(&me::InprocessEGLClient::handle_event), this, std::placeholders::_1));
106
            std::bind(std::mem_fn(&me::InprocessEGLClient::handle_event), this, std::placeholders::_1));
45
107
    input_thread->start();
107
    input_thread->start();
46
108
108
47
109
109
48
=== modified file 'examples/fingerpaint.c'
49
=== added file 'examples/trust_session.c'
50
--- examples/trust_session.c	1970-01-01 00:00:00 +0000
51
+++ examples/trust_session.c	2014-05-09 12:26:43 +0000
52
@@ -0,0 +1,249 @@
53
1
/*
54
2
 * Copyright © 2014 Canonical Ltd.
55
3
 *
56
4
 * This program is free software: you can redistribute it and/or modify
57
5
 * it under the terms of the GNU General Public License version 3 as
58
6
 * published by the Free Software Foundation.
59
7
 *
60
8
 * This program is distributed in the hope that it will be useful,
61
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
62
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
63
11
 * GNU General Public License for more details.
64
12
 *
65
13
 * You should have received a copy of the GNU General Public License
66
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
67
15
 *
68
16
 * Authored by: Nick Dedekind <nick.dedekind <nick.dedekind@canonical.com>
69
17
 */
70
18
71
19
#define _POSIX_SOURCE
72
20
73
21
#include "mir_toolkit/mir_client_library.h"
74
22
#include "mir_toolkit/mir_trust_session.h"
75
23
76
24
#include <assert.h>
77
25
#include <string.h>
78
26
#include <stdio.h>
79
27
#include <stdlib.h>
80
28
#include <getopt.h>
81
29
#include <unistd.h>
82
30
#include <errno.h>
83
31
#include <sys/wait.h>
84
32
#include <sys/types.h>
85
33
#include <signal.h>
86
34
87
35
///\page trust_session.c trust_session.c: A mir client which starts a trust session and trusted client app.
88
36
/// mir_demo_client_trust_session shows the use of mir trust session API.
89
37
/// This program opens a mir connection and creates a trust session.
90
38
///\section trusted_helper trusted_helper()
91
39
/// Opens a mir connection and creates a trust session
92
40
/// before closing the trust session and connection.
93
41
///\section trust_session_app trust_session_app()
94
42
/// Opens a mir connection and creates a surface
95
43
/// before releasing the surface and closing the connection.
96
44
///\example trust_session.c A mir client demonstrating trust sessions.
97
45
///\section MirDemoState MirDemoState
98
46
/// The handles needs to be accessible both to callbacks and to the control function.
99
47
///\snippet trust_session.c MirDemoState_tag
100
48
///\section Callbacks Callbacks
101
49
///\snippet trust_session.c Callback_tag
102
50
/// This program creates two processes, both opening a mir connection, one starting
103
51
/// a trust session with the other process.
104
52
105
53
///\internal [MirDemoState_tag]
106
54
// Utility structure for the state of a single session.
107
55
typedef struct MirDemoState
108
56
{
109
57
    MirConnection *connection;
110
58
    MirSurface *surface;
111
59
    MirTrustSession *trust_session;
112
60
    pid_t  child_pid;
113
61
} MirDemoState;
114
62
///\internal [MirDemoState_tag]
115
63
116
64
117
65
///\internal [Callback_tag]
118
66
// Callback to update MirDemoState on trust_session_event
119
67
static void trust_session_event_callback(MirTrustSession* trust_session,
120
68
                                         MirTrustSessionState state,
121
69
                                         void* context)
122
70
{
123
71
    (void)trust_session;
124
72
    MirDemoState* demo_state = (MirDemoState*)context;
125
73
126
74
    printf("Trust Session state updated to %d\n", state);
127
75
    if (state == mir_trust_session_state_stopped)
128
76
    {
129
77
        kill(demo_state->child_pid, SIGINT);
130
78
    }
131
79
}
132
80
///\internal [Callback_tag]
133
81
134
82
void start_session(const char* server, const char* name, MirDemoState* mcd)
135
83
{
136
84
    // Call mir_connect synchronously
137
85
    mcd->connection = mir_connect_sync(server, name);
138
86
139
87
    // We expect a connection handle;
140
88
    // we expect it to be valid; and,
141
89
    // we don't expect an error description
142
90
    assert(mcd->connection != NULL);
143
91
    assert(mir_connection_is_valid(mcd->connection));
144
92
    assert(strcmp(mir_connection_get_error_message(mcd->connection), "") == 0);
145
93
    printf("%s: Connected\n", name);
146
94
147
95
    // We can query information about the platform we're running on
148
96
    {
149
97
        MirPlatformPackage platform_package;
150
98
        platform_package.data_items = -1;
151
99
        platform_package.fd_items = -1;
152
100
153
101
        mir_connection_get_platform(mcd->connection, &platform_package);
154
102
        assert(0 <= platform_package.data_items);
155
103
        assert(0 <= platform_package.fd_items);
156
104
    }
157
105
}
158
106
159
107
void stop_session(MirDemoState* mcd, const char* name)
160
108
{
161
109
    if (mcd->trust_session)
162
110
    {
163
111
        mir_trust_session_release(mcd->trust_session);
164
112
        mcd->trust_session = 0;
165
113
        printf("%s: Trust session released \n", name);
166
114
    }
167
115
168
116
    if (mcd->surface)
169
117
    {
170
118
        // We should release our surface
171
119
        mir_surface_release_sync(mcd->surface);
172
120
        mcd->surface = 0;
173
121
        printf("%s: Surface released\n", name);
174
122
    }
175
123
176
124
    // We should release our connection
177
125
    mir_connection_release(mcd->connection);
178
126
    printf("%s: Connection released\n", name);
179
127
}
180
128
181
129
void trusted_helper(const char* server, pid_t child_pid)
182
130
{
183
131
    MirDemoState mcd;
184
132
    mcd.connection = 0;
185
133
    mcd.surface = 0;
186
134
    mcd.trust_session = 0;
187
135
    mcd.child_pid = child_pid;
188
136
    start_session(server, "trusted_helper", &mcd);
189
137
190
138
    // We create a trust session
191
139
    mcd.trust_session = mir_connection_start_trust_session_sync(mcd.connection, getpid(), trust_session_event_callback, &mcd);
192
140
    assert(mcd.trust_session != NULL);
193
141
194
142
    assert(mir_trust_session_get_state(mcd.trust_session) == mir_trust_session_state_started);
195
143
    puts("trusted_helper: Started trust session");
196
144
197
145
    MirTrustSessionAddTrustResult add_result = mir_trust_session_add_trusted_session_sync(mcd.trust_session, child_pid);
198
146
    assert(add_result == mir_trust_session_add_tust_succeeded);
199
147
    printf("trusted_helper: added trusted session pid: %d\n", child_pid);
200
148
201
149
    int status;
202
150
    printf("trusted_helper: waiting on child app: %d\n", child_pid);
203
151
    waitpid(child_pid, &status, 0);
204
152
205
153
    if (mir_trust_session_get_state(mcd.trust_session) == mir_trust_session_state_started)
206
154
    {
207
155
        mir_trust_session_stop_sync(mcd.trust_session);
208
156
        assert(mir_trust_session_get_state(mcd.trust_session) == mir_trust_session_state_stopped);
209
157
        puts("trusted_helper: Stopped trust session");
210
158
    }
211
159
    else
212
160
    {
213
161
        puts("trusted_helper: Trusted session stoped by server");
214
162
    }
215
163
    puts("trusted_helper: Done");
216
164
217
165
    stop_session(&mcd, "trusted_helper");
218
166
}
219
167
220
168
void trust_session_app(const char* server)
221
169
{
222
170
    MirDemoState mcd;
223
171
    mcd.connection = 0;
224
172
    mcd.surface = 0;
225
173
    mcd.trust_session = 0;
226
174
    start_session(server, "trust_session_app", &mcd);
227
175
228
176
    // Identify a supported pixel format
229
177
    MirPixelFormat pixel_format;
230
178
    unsigned int valid_formats;
231
179
    mir_connection_get_available_surface_formats(mcd.connection, &pixel_format, 1, &valid_formats);
232
180
    MirSurfaceParameters const request_params =
233
181
        {__PRETTY_FUNCTION__, 640, 480, pixel_format,
234
182
         mir_buffer_usage_hardware, mir_display_output_id_invalid};
235
183
236
184
    // ...we create a surface using that format and wait for callback to complete.
237
185
    mcd.surface = mir_connection_create_surface_sync(mcd.connection, &request_params);
238
186
239
187
    // We expect a surface handle;
240
188
    // we expect it to be valid; and,
241
189
    // we don't expect an error description
242
190
    assert(mcd.surface != NULL);
243
191
    assert(mir_surface_is_valid(mcd.surface));
244
192
    assert(strcmp(mir_surface_get_error_message(mcd.surface), "") == 0);
245
193
    puts("trust_session_app: Surface created");
246
194
247
195
    puts("trust_session_app: Press any key to exit");
248
196
    // Wait for stdin
249
197
    getchar();
250
198
    puts("trust_session_app: Done");
251
199
252
200
    stop_session(&mcd, "trust_session_app");
253
201
}
254
202
255
203
// The main() function deals with parsing arguments and defaults
256
204
int main(int argc, char* argv[])
257
205
{
258
206
    // Some variables for holding command line options
259
207
    char const *server = NULL;
260
208
261
209
    // Parse the command line
262
210
    {
263
211
        int arg;
264
212
        opterr = 0;
265
213
        while ((arg = getopt (argc, argv, "c:hm:")) != -1)
266
214
        {
267
215
            switch (arg)
268
216
            {
269
217
            case 'm':
270
218
                server = optarg;
271
219
                break;
272
220
273
221
            case '?':
274
222
            case 'h':
275
223
            default:
276
224
                puts(argv[0]);
277
225
                puts("Usage:");
278
226
                puts("    -m <Mir server socket>");
279
227
                puts("    -h: this help text");
280
228
                return -1;
281
229
            }
282
230
        }
283
231
    }
284
232
285
233
    // Start a new process.
286
234
    // This simulates the helper starting a new application which it adds to the trusted session.
287
235
    pid_t pid = fork();
288
236
289
237
    if (pid == 0)
290
238
    {
291
239
        sleep(1);
292
240
        trust_session_app(server);
293
241
    }
294
242
    else if (pid > 0)
295
243
    {
296
244
        printf("trusted_helper: pid:%d , child:%d\n", getpid(), pid);
297
245
        trusted_helper(server, pid);
298
246
    }
299
247
300
248
    return 0;
301
249
}
302
0
250
303
=== added file 'include/client/mir_toolkit/mir_trust_session.h'
304
--- include/client/mir_toolkit/mir_trust_session.h	1970-01-01 00:00:00 +0000
305
+++ include/client/mir_toolkit/mir_trust_session.h	2014-05-09 12:26:43 +0000
306
@@ -0,0 +1,119 @@
307
1
/*
308
2
 * Copyright © 2014 Canonical Ltd.
309
3
 *
310
4
 * This program is free software: you can redistribute it and/or modify it
311
5
 * under the terms of the GNU Lesser General Public License version 3,
312
6
 * as published by the Free Software Foundation.
313
7
 *
314
8
 * This program is distributed in the hope that it will be useful,
315
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
316
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
317
11
 * GNU Lesser General Public License for more details.
318
12
 *
319
13
 * You should have received a copy of the GNU Lesser General Public License
320
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
321
15
 */
322
16
323
17
#ifndef MIR_TOOLKIT_MIR_TRUST_SESSION_H_
324
18
#define MIR_TOOLKIT_MIR_TRUST_SESSION_H_
325
19
326
20
#include "mir_toolkit/mir_client_library.h"
327
21
328
22
#include <sys/types.h>
329
23
330
24
#ifdef __cplusplus
331
25
/**
332
26
 * \addtogroup mir_toolkit
333
27
 * @{
334
28
 */
335
29
extern "C" {
336
30
#endif
337
31
338
32
/**
339
33
 * Create an new trust session
340
34
 *   \param [in] connection        The connection
341
35
 *   \param [in] base_session_pid  The process id of the initiating application
342
36
 *   \param [in] start_callback    Callback function to be invoked when request
343
37
 *                                 completes
344
38
 *   \param [in] start_callback    The function to be called when the trust session event occurs
345
39
 *   \param [in,out] context       User data passed to the callback functions
346
40
 *   \return                       A handle that can be passed to mir_wait_for
347
41
 */
348
42
MirWaitHandle *mir_connection_start_trust_session(MirConnection* connection,
349
43
    pid_t base_session_pid,
350
44
    mir_trust_session_callback start_callback,
351
45
    mir_trust_session_event_callback event_callback,
352
46
    void* context);
353
47
354
48
/**
355
49
 * Create an new trust session
356
50
 *   \param [in] connection  The connection
357
51
 *   \param [in] base_session_pid The process id of the initiating application
358
52
 *   \param [in] callback         Callback function to be invoked when request
359
53
 *                                completes
360
54
 *   \param [in,out] context      User data passed to the callback function
361
55
 *   \param [in] callback         The function to be called when the trust session event occurs
362
56
 *   \return                      A handle that can be passed to mir_wait_for
363
57
 */
364
58
MirTrustSession *mir_connection_start_trust_session_sync(MirConnection* connection,
365
59
    pid_t base_session_pid,
366
60
    mir_trust_session_event_callback event_callback,
367
61
    void* context);
368
62
369
63
/**
370
64
 * Add a process id to the trust session relationship
371
65
 *   \param [in] trust_session  The trust session
372
66
 *   \param [in] session_pid    The process id of the application to add
373
67
 *   \param [in] callback       Callback function to be invoked when request
374
68
 *                              completes
375
69
 *   \return                    A MirTrustSessionAddTrustResult result of the call
376
70
 */
377
71
MirWaitHandle *mir_trust_session_add_trusted_session(MirTrustSession *trust_session,
378
72
    pid_t session_pid,
379
73
    mir_trust_session_add_trusted_session_callback callback,
380
74
    void* context);
381
75
382
76
/**
383
77
 * Perform a mir_trust_session_add_trusted_pid() but also wait for and return the result.
384
78
 *   \param [in] trust_session  The trust session
385
79
 *   \param [in] pid            The process id of the application to add
386
80
 *   \return                    A MirTrustSessionAddTrustResult result of the call
387
81
 */
388
82
MirTrustSessionAddTrustResult mir_trust_session_add_trusted_session_sync(MirTrustSession *trust_session,
389
83
    pid_t pid);
390
84
391
85
/**
392
86
 * Request the cancellation of a trust session
393
87
 *   \param [in] trust_session  The trust session
394
88
 *   \return                    True if the request was made successfully,
395
89
 *                              false otherwise
396
90
 */
397
91
MirWaitHandle *mir_trust_session_stop(MirTrustSession *trust_session, mir_trust_session_callback callback, void* context);
398
92
399
93
/**
400
94
 * Perform a mir_trust_session_stop() but also wait for and return the result.
401
95
 *   \param [in] trust_session  The trust session
402
96
 *   \return                    True if the request was made successfully,
403
97
 *                              false otherwise
404
98
 */
405
99
MirBool mir_trust_session_stop_sync(MirTrustSession *trust_session);
406
100
407
101
/**
408
102
 * Return the state of trust session
409
103
 * \param [in] trust_session  The trust session
410
104
 * \return                    The state of the trust session
411
105
 */
412
106
MirTrustSessionState mir_trust_session_get_state(MirTrustSession *trust_session);
413
107
414
108
/**
415
109
 * Release a trust session
416
110
 *   \param [in] trust_session  The trust session to release
417
111
 */
418
112
void mir_trust_session_release(MirTrustSession* trust_session);
419
113
420
114
#ifdef __cplusplus
421
115
}
422
116
/**@}*/
423
117
#endif
424
118
425
119
#endif /* MIR_TOOLKIT_MIR_TRUST_SESSION_H_ */
426
0
120
427
=== modified file 'include/server/mir/default_server_configuration.h'
428
--- include/server/mir/default_server_configuration.h	2014-05-09 03:00:20 +0000
429
+++ include/server/mir/default_server_configuration.h	2014-05-09 12:26:43 +0000
430
@@ -83,6 +83,7 @@
431
83
class SurfaceStack;
83
class SurfaceStack;
432
84
class InputRegistrar;
84
class InputRegistrar;
433
85
class SceneReport;
85
class SceneReport;
434
86
class TrustSessionListener;
435
86
}
87
}
436
87
namespace graphics
88
namespace graphics
437
88
{
89
{
438
@@ -212,6 +213,7 @@
439
212
    virtual std::shared_ptr<scene::PlacementStrategy>   the_placement_strategy();
213
    virtual std::shared_ptr<scene::PlacementStrategy>   the_placement_strategy();
440
213
    virtual std::shared_ptr<scene::SessionListener>     the_session_listener();
214
    virtual std::shared_ptr<scene::SessionListener>     the_session_listener();
441
214
    virtual std::shared_ptr<shell::DisplayLayout>       the_shell_display_layout();
215
    virtual std::shared_ptr<shell::DisplayLayout>       the_shell_display_layout();
442
216
    virtual std::shared_ptr<scene::TrustSessionListener>     the_trust_session_listener();
443
215
    /** @} */
217
    /** @} */
444
216
218
445
217
    /** @name internal scene configuration
219
    /** @name internal scene configuration
446
@@ -322,6 +324,7 @@
447
322
    CachedPtr<scene::MediatingDisplayChanger> mediating_display_changer;
324
    CachedPtr<scene::MediatingDisplayChanger> mediating_display_changer;
448
323
    CachedPtr<graphics::GLProgramFactory> gl_program_factory;
325
    CachedPtr<graphics::GLProgramFactory> gl_program_factory;
449
324
    CachedPtr<graphics::GLConfig> gl_config;
326
    CachedPtr<graphics::GLConfig> gl_config;
450
327
    CachedPtr<scene::TrustSessionListener> trust_session_listener;
451
325
328
452
326
private:
329
private:
453
327
    std::shared_ptr<options::Configuration> const configuration_options;
330
    std::shared_ptr<options::Configuration> const configuration_options;
454
328
331
455
=== modified file 'include/server/mir/frontend/connection_context.h'
456
--- include/server/mir/frontend/connection_context.h	2014-05-08 13:07:13 +0000
457
+++ include/server/mir/frontend/connection_context.h	2014-05-09 12:26:43 +0000
458
@@ -1,3 +1,4 @@
459
1
<<<<<<< TREE
460
1
/*
2
/*
461
2
 * Copyright © 2014 Canonical Ltd.
3
 * Copyright © 2014 Canonical Ltd.
462
3
 *
4
 *
463
@@ -50,3 +51,60 @@
464
50
}
51
}
465
51
52
466
52
#endif /* MIR_FRONTEND_CONNECTION_CONTEXT_H_ */
53
#endif /* MIR_FRONTEND_CONNECTION_CONTEXT_H_ */
467
54
=======
468
55
/*
469
56
 * Copyright © 014 Canonical Ltd.
470
57
 *
471
58
 * This program is free software: you can redistribute it and/or modify it
472
59
 * under the terms of the GNU General Public License version 3,
473
60
 * as published by the Free Software Foundation.
474
61
 *
475
62
 * This program is distributed in the hope that it will be useful,
476
63
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
477
64
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
478
65
 * GNU General Public License for more details.
479
66
 *
480
67
 * You should have received a copy of the GNU General Public License
481
68
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
482
69
 *
483
70
 * Authored by: Alan Griffiths <alan@octopull.co.uk>
484
71
 */
485
72
486
73
#ifndef MIR_FRONTEND_CONNECTION_CONTEXT_H_
487
74
#define MIR_FRONTEND_CONNECTION_CONTEXT_H_
488
75
489
76
#include <functional>
490
77
#include <memory>
491
78
492
79
namespace mir
493
80
{
494
81
namespace frontend
495
82
{
496
83
class Connector;
497
84
class Session;
498
85
499
86
class ConnectionContext
500
87
{
501
88
public:
502
89
    ConnectionContext() = delete;
503
90
    ConnectionContext(const ConnectionContext&) = default;
504
91
    ConnectionContext& operator=(const ConnectionContext&) = default;
505
92
    ConnectionContext(Connector const* connector) :
506
93
        ConnectionContext([](std::shared_ptr<Session> const&){}, connector) {}
507
94
    ConnectionContext(
508
95
        std::function<void(std::shared_ptr<Session> const& session)> const connect_handler,
509
96
        Connector const* connector);
510
97
511
98
    int fd_for_new_client(std::function<void(std::shared_ptr<Session> const& session)> const& connect_handler) const;
512
99
513
100
    void handle_client_connect(std::shared_ptr<Session> const& session) const { connect_handler(session); }
514
101
515
102
private:
516
103
    std::function<void(std::shared_ptr<Session> const& session)> const connect_handler;
517
104
    Connector const* const connector;
518
105
};
519
106
}
520
107
}
521
108
522
109
#endif /* MIR_FRONTEND_CONNECTION_CONTEXT_H_ */
523
110
>>>>>>> MERGE-SOURCE
524
53
111
525
=== modified file 'include/server/mir/frontend/event_sink.h'
526
--- include/server/mir/frontend/event_sink.h	2013-08-28 03:41:48 +0000
527
+++ include/server/mir/frontend/event_sink.h	2014-05-09 12:26:43 +0000
528
@@ -35,6 +35,8 @@
529
35
    virtual ~EventSink() = default;
35
    virtual ~EventSink() = default;
530
36
36
531
37
    virtual void handle_event(MirEvent const& e) = 0;
37
    virtual void handle_event(MirEvent const& e) = 0;
532
38
533
39
    // TODO - remove these in favour of using handle_event
534
38
    virtual void handle_lifecycle_event(MirLifecycleState state) = 0;
40
    virtual void handle_lifecycle_event(MirLifecycleState state) = 0;
535
39
    virtual void handle_display_config_change(graphics::DisplayConfiguration const& config) = 0;
41
    virtual void handle_display_config_change(graphics::DisplayConfiguration const& config) = 0;
536
40
42
537
41
43
538
=== modified file 'include/server/mir/frontend/session.h'
539
--- include/server/mir/frontend/session.h	2014-05-06 16:54:43 +0000
540
+++ include/server/mir/frontend/session.h	2014-05-09 12:26:43 +0000
541
@@ -50,6 +50,7 @@
542
50
    virtual void destroy_surface(SurfaceId surface) = 0;
50
    virtual void destroy_surface(SurfaceId surface) = 0;
543
51
    virtual std::shared_ptr<Surface> get_surface(SurfaceId surface) const = 0;
51
    virtual std::shared_ptr<Surface> get_surface(SurfaceId surface) const = 0;
544
52
52
545
53
    virtual pid_t process_id() const = 0;
546
53
    virtual std::string name() const = 0;
54
    virtual std::string name() const = 0;
547
54
55
548
55
    virtual void hide() = 0;
56
    virtual void hide() = 0;
549
56
57
550
=== modified file 'include/server/mir/frontend/session_mediator_report.h'
551
--- include/server/mir/frontend/session_mediator_report.h	2014-03-06 06:05:17 +0000
552
+++ include/server/mir/frontend/session_mediator_report.h	2014-05-09 12:26:43 +0000
553
@@ -48,6 +48,12 @@
554
48
48
555
49
    virtual void session_configure_display_called(std::string const& app_name) = 0;
49
    virtual void session_configure_display_called(std::string const& app_name) = 0;
556
50
50
557
51
    virtual void session_start_trust_session_called(std::string const& app_name, std::string const& trust_info) = 0;
558
52
559
53
    virtual void session_add_trusted_session_called(std::string const& app_name, std::string const& trust_info) = 0;
560
54
561
55
    virtual void session_stop_trust_session_called(std::string const& app_name) = 0;
562
56
563
51
    virtual void session_error(
57
    virtual void session_error(
564
52
        std::string const& app_name,
58
        std::string const& app_name,
565
53
        char const* method,
59
        char const* method,
566
54
60
567
=== modified file 'include/server/mir/frontend/shell.h'
568
--- include/server/mir/frontend/shell.h	2014-04-15 05:31:19 +0000
569
+++ include/server/mir/frontend/shell.h	2014-05-09 12:26:43 +0000
570
@@ -20,6 +20,7 @@
571
20
#define MIR_FRONTEND_SHELL_H_
20
#define MIR_FRONTEND_SHELL_H_
572
21
21
573
22
#include "mir/frontend/surface_id.h"
22
#include "mir/frontend/surface_id.h"
574
23
#include "mir_toolkit/common.h"
575
23
24
576
24
#include <sys/types.h>
25
#include <sys/types.h>
577
25
26
578
@@ -30,11 +31,13 @@
579
30
namespace scene
31
namespace scene
580
31
{
32
{
581
32
struct SurfaceCreationParameters;
33
struct SurfaceCreationParameters;
582
34
struct TrustSessionCreationParameters;
583
33
}
35
}
584
34
namespace frontend
36
namespace frontend
585
35
{
37
{
586
36
class EventSink;
38
class EventSink;
587
37
class Session;
39
class Session;
588
40
class TrustSession;
589
38
41
590
39
class Shell
42
class Shell
591
40
{
43
{
592
@@ -54,6 +57,12 @@
593
54
57
594
55
    virtual void handle_surface_created(std::shared_ptr<Session> const& session) = 0;
58
    virtual void handle_surface_created(std::shared_ptr<Session> const& session) = 0;
595
56
59
596
60
    virtual std::shared_ptr<TrustSession> start_trust_session_for(std::shared_ptr<Session> const& session,
597
61
                                                                  scene::TrustSessionCreationParameters const& params) = 0;
598
62
    virtual MirTrustSessionAddTrustResult add_trusted_session_for(std::shared_ptr<TrustSession> const& trust_session,
599
63
                                                                  pid_t session_pid) = 0;
600
64
    virtual void stop_trust_session(std::shared_ptr<TrustSession> const& trust_session) = 0;
601
65
602
57
protected:
66
protected:
603
58
    Shell() = default;
67
    Shell() = default;
604
59
    Shell(const Shell&) = delete;
68
    Shell(const Shell&) = delete;
605
60
69
606
=== added file 'include/server/mir/frontend/trust_session.h'
607
--- include/server/mir/frontend/trust_session.h	1970-01-01 00:00:00 +0000
608
+++ include/server/mir/frontend/trust_session.h	2014-05-09 12:26:43 +0000
609
@@ -0,0 +1,53 @@
610
1
/*
611
2
 * Copyright © 2014 Canonical Ltd.
612
3
 *
613
4
 * This program is free software: you can redistribute it and/or modify it
614
5
 * under the terms of the GNU General Public License version 3,
615
6
 * as published by the Free Software Foundation.
616
7
 *
617
8
 * This program is distributed in the hope that it will be useful,
618
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
619
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
620
11
 * GNU General Public License for more details.
621
12
 *
622
13
 * You should have received a copy of the GNU General Public License
623
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
624
15
 *
625
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
626
17
 */
627
18
628
19
#ifndef MIR_FRONTEND_TRUST_SESSION_H_
629
20
#define MIR_FRONTEND_TRUST_SESSION_H_
630
21
631
22
#include "mir_toolkit/common.h"
632
23
633
24
#include <sys/types.h>
634
25
#include <vector>
635
26
#include <string>
636
27
#include <memory>
637
28
638
29
namespace mir
639
30
{
640
31
641
32
namespace frontend
642
33
{
643
34
class TrustSession
644
35
{
645
36
public:
646
37
    virtual ~TrustSession() = default;
647
38
648
39
    virtual MirTrustSessionState get_state() const = 0;
649
40
650
41
    virtual void start() = 0;
651
42
    virtual void stop() = 0;
652
43
653
44
protected:
654
45
    TrustSession() = default;
655
46
    TrustSession(const TrustSession&) = delete;
656
47
    TrustSession& operator=(const TrustSession&) = delete;
657
48
};
658
49
659
50
}
660
51
}
661
52
662
53
#endif // MIR_FRONTEND_TRUST_SESSION_H_
663
0
54
664
=== added file 'include/server/mir/scene/null_trust_session_listener.h'
665
--- include/server/mir/scene/null_trust_session_listener.h	1970-01-01 00:00:00 +0000
666
+++ include/server/mir/scene/null_trust_session_listener.h	2014-05-09 12:26:43 +0000
667
@@ -0,0 +1,50 @@
668
1
/*
669
2
 * Copyright © 2014 Canonical Ltd.
670
3
 *
671
4
 * This program is free software: you can redistribute it and/or modify it
672
5
 * under the terms of the GNU General Public License version 3,
673
6
 * as published by the Free Software Foundation.
674
7
 *
675
8
 * This program is distributed in the hope that it will be useful,
676
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
677
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
678
11
 * GNU General Public License for more details.
679
12
 *
680
13
 * You should have received a copy of the GNU General Public License
681
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
682
15
 *
683
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
684
17
 */
685
18
686
19
#ifndef MIR_SCENE_NULL_TRUST_SESSION_LISTENER_H_
687
20
#define MIR_SCENE_NULL_TRUST_SESSION_LISTENER_H_
688
21
689
22
#include "mir/scene/trust_session_listener.h"
690
23
691
24
namespace mir
692
25
{
693
26
namespace scene
694
27
{
695
28
696
29
class NullTrustSessionListener : public TrustSessionListener
697
30
{
698
31
public:
699
32
    NullTrustSessionListener() = default;
700
33
    virtual ~NullTrustSessionListener() noexcept(true) = default;
701
34
702
35
    void starting(TrustSession const&) override {};
703
36
    void stopping(TrustSession const&) override {};
704
37
705
38
    void trusted_session_beginning(TrustSession&, Session const&) override {};
706
39
    void trusted_session_ending(TrustSession&, Session const&) override {};
707
40
708
41
protected:
709
42
    NullTrustSessionListener(const NullTrustSessionListener&) = delete;
710
43
    NullTrustSessionListener& operator=(const NullTrustSessionListener&) = delete;
711
44
};
712
45
713
46
}
714
47
}
715
48
716
49
717
50
#endif // MIR_SHELL_NULL_TRUST_SESSION_LISTENER_H_
718
0
51
719
=== modified file 'include/server/mir/scene/session.h'
720
--- include/server/mir/scene/session.h	2014-04-15 05:31:19 +0000
721
+++ include/server/mir/scene/session.h	2014-05-09 12:26:43 +0000
722
@@ -34,12 +34,14 @@
723
34
{
34
{
724
35
public:
35
public:
725
36
    virtual void force_requests_to_complete() = 0;
36
    virtual void force_requests_to_complete() = 0;
726
37
    virtual pid_t process_id() const = 0;
727
38
37
728
39
    virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
38
    virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
729
40
    virtual std::shared_ptr<Surface> default_surface() const = 0;
39
    virtual std::shared_ptr<Surface> default_surface() const = 0;
730
41
    virtual void set_lifecycle_state(MirLifecycleState state) = 0;
40
    virtual void set_lifecycle_state(MirLifecycleState state) = 0;
731
42
    virtual void send_display_config(graphics::DisplayConfiguration const&) = 0;
41
    virtual void send_display_config(graphics::DisplayConfiguration const&) = 0;
732
42
733
43
    virtual void begin_trust_session() = 0;
734
44
    virtual void end_trust_session() = 0;
735
43
};
45
};
736
44
}
46
}
737
45
}
47
}
738
46
48
739
=== added file 'include/server/mir/scene/trust_session.h'
740
--- include/server/mir/scene/trust_session.h	1970-01-01 00:00:00 +0000
741
+++ include/server/mir/scene/trust_session.h	2014-05-09 12:26:43 +0000
742
@@ -0,0 +1,43 @@
743
1
/*
744
2
 * Copyright © 2014 Canonical Ltd.
745
3
 *
746
4
 * This program is free software: you can redistribute it and/or modify it
747
5
 * under the terms of the GNU General Public License version 3,
748
6
 * as published by the Free Software Foundation.
749
7
 *
750
8
 * This program is distributed in the hope that it will be useful,
751
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
752
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
753
11
 * GNU General Public License for more details.
754
12
 *
755
13
 * You should have received a copy of the GNU General Public License
756
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
757
15
 *
758
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
759
17
 */
760
18
761
19
#ifndef MIR_SCENE_TRUST_SESSION_H_
762
20
#define MIR_SCENE_TRUST_SESSION_H_
763
21
764
22
#include "mir/frontend/trust_session.h"
765
23
766
24
namespace mir
767
25
{
768
26
namespace scene
769
27
{
770
28
class Session;
771
29
772
30
class TrustSession : public frontend::TrustSession
773
31
{
774
32
public:
775
33
    virtual std::weak_ptr<Session> get_trusted_helper() const = 0;
776
34
777
35
    virtual bool add_trusted_child(std::shared_ptr<Session> const& session) = 0;
778
36
    virtual void remove_trusted_child(std::shared_ptr<Session> const& session) = 0;
779
37
    virtual void for_each_trusted_child(std::function<void(std::shared_ptr<Session> const&)> f, bool reverse) const = 0;
780
38
};
781
39
782
40
}
783
41
}
784
42
785
43
#endif // MIR_SHELL_TRUST_SESSION_H_
786
0
44
787
=== added file 'include/server/mir/scene/trust_session_creation_parameters.h'
788
--- include/server/mir/scene/trust_session_creation_parameters.h	1970-01-01 00:00:00 +0000
789
+++ include/server/mir/scene/trust_session_creation_parameters.h	2014-05-09 12:26:43 +0000
790
@@ -0,0 +1,46 @@
791
1
/*
792
2
 * Copyright © 2014 Canonical Ltd.
793
3
 *
794
4
 * This program is free software: you can redistribute it and/or modify it
795
5
 * under the terms of the GNU General Public License version 3,
796
6
 * as published by the Free Software Foundation.
797
7
 *
798
8
 * This program is distributed in the hope that it will be useful,
799
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
800
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
801
11
 * GNU General Public License for more details.
802
12
 *
803
13
 * You should have received a copy of the GNU General Public License
804
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
805
15
 *
806
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
807
17
 */
808
18
809
19
#ifndef MIR_SCENE_TRUSTED_SESSION_CREATION_PARAMETERS_H_
810
20
#define MIR_SCENE_TRUSTED_SESSION_CREATION_PARAMETERS_H_
811
21
812
22
#include <sys/types.h>
813
23
#include <vector>
814
24
815
25
namespace mir
816
26
{
817
27
namespace scene
818
28
{
819
29
820
30
struct TrustSessionCreationParameters
821
31
{
822
32
    TrustSessionCreationParameters();
823
33
824
34
    TrustSessionCreationParameters& set_base_process_id(pid_t process_id);
825
35
826
36
    pid_t base_process_id;
827
37
};
828
38
829
39
bool operator==(const TrustSessionCreationParameters& lhs, const TrustSessionCreationParameters& rhs);
830
40
bool operator!=(const TrustSessionCreationParameters& lhs, const TrustSessionCreationParameters& rhs);
831
41
832
42
TrustSessionCreationParameters a_trust_session();
833
43
}
834
44
}
835
45
836
46
#endif /* MIR_SCENE_TRUSTED_SESSION_CREATION_PARAMETERS_H_ */
837
0
47
838
=== added file 'include/server/mir/scene/trust_session_listener.h'
839
--- include/server/mir/scene/trust_session_listener.h	1970-01-01 00:00:00 +0000
840
+++ include/server/mir/scene/trust_session_listener.h	2014-05-09 12:26:43 +0000
841
@@ -0,0 +1,52 @@
842
1
/*
843
2
 * Copyright © 2014 Canonical Ltd.
844
3
 *
845
4
 * This program is free software: you can redistribute it and/or modify it
846
5
 * under the terms of the GNU General Public License version 3,
847
6
 * as published by the Free Software Foundation.
848
7
 *
849
8
 * This program is distributed in the hope that it will be useful,
850
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
851
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
852
11
 * GNU General Public License for more details.
853
12
 *
854
13
 * You should have received a copy of the GNU General Public License
855
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
856
15
 *
857
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
858
17
 */
859
18
860
19
#ifndef MIR_SCENE_TRUST_SESSION_LISTENER_H_
861
20
#define MIR_SCENE_TRUST_SESSION_LISTENER_H_
862
21
863
22
#include <memory>
864
23
865
24
namespace mir
866
25
{
867
26
namespace scene
868
27
{
869
28
class Session;
870
29
class TrustSession;
871
30
872
31
class TrustSessionListener
873
32
{
874
33
public:
875
34
    virtual void starting(TrustSession const& trust_session) = 0;
876
35
    virtual void stopping(TrustSession const& trust_session) = 0;
877
36
878
37
    virtual void trusted_session_beginning(TrustSession& trust_session, Session const& session) = 0;
879
38
    virtual void trusted_session_ending(TrustSession& trust_session, Session const& session) = 0;
880
39
881
40
protected:
882
41
    TrustSessionListener() = default;
883
42
    virtual ~TrustSessionListener() = default;
884
43
885
44
    TrustSessionListener(const TrustSessionListener&) = delete;
886
45
    TrustSessionListener& operator=(const TrustSessionListener&) = delete;
887
46
};
888
47
889
48
}
890
49
}
891
50
892
51
893
52
#endif // MIR_SCENE_TRUST_SESSION_LISTENER_H_
894
0
53
895
=== modified file 'include/shared/mir_toolkit/client_types.h'
896
--- include/shared/mir_toolkit/client_types.h	2014-05-08 11:48:23 +0000
897
+++ include/shared/mir_toolkit/client_types.h	2014-05-09 12:26:43 +0000
898
@@ -46,6 +46,7 @@
899
46
typedef struct MirConnection MirConnection;
46
typedef struct MirConnection MirConnection;
900
47
typedef struct MirSurface MirSurface;
47
typedef struct MirSurface MirSurface;
901
48
typedef struct MirScreencast MirScreencast;
48
typedef struct MirScreencast MirScreencast;
902
49
typedef struct MirTrustSession MirTrustSession;
903
49
50
904
50
/**
51
/**
905
51
 * Returned by asynchronous functions. Must not be free'd by
52
 * Returned by asynchronous functions. Must not be free'd by
906
@@ -104,6 +105,7 @@
907
104
    MirConnection* connection, void* context);
105
    MirConnection* connection, void* context);
908
105
106
909
106
/**
107
/**
910
108
<<<<<<< TREE
911
107
 * Callback called when a request for client file descriptors completes
109
 * Callback called when a request for client file descriptors completes
912
108
 *   \param [in] connection     The connection associated with the display change
110
 *   \param [in] connection     The connection associated with the display change
913
109
 *   \param [in] count          The number of FDs allocated
111
 *   \param [in] count          The number of FDs allocated
914
@@ -117,6 +119,19 @@
915
117
    MirConnection* connection, size_t count, int const* fds, void* context);
119
    MirConnection* connection, size_t count, int const* fds, void* context);
916
118
120
917
119
/**
121
/**
918
122
=======
919
123
 * Callback called when a request for client file descriptors completes
920
124
 *   \param [in] connection     The connection associated with the display change
921
125
 *   \param [in] count          The number of FDs allocated
922
126
 *   \param [in] fds            Array of FDs
923
127
 *   \param [in,out] context    The context provided by client
924
128
 */
925
129
926
130
typedef void (*mir_client_fd_callback)(
927
131
    MirConnection* connection, size_t count, int const* fds, void* context);
928
132
929
133
/**
930
134
>>>>>>> MERGE-SOURCE
931
120
 * MirBufferUsage specifies how a surface can and will be used. A "hardware"
135
 * MirBufferUsage specifies how a surface can and will be used. A "hardware"
932
121
 * surface can be used for OpenGL accelerated rendering. A "software" surface
136
 * surface can be used for OpenGL accelerated rendering. A "software" surface
933
122
 * is one that can be addressed in main memory and blitted to directly.
137
 * is one that can be addressed in main memory and blitted to directly.
934
@@ -319,6 +334,31 @@
935
319
 */
334
 */
936
320
typedef void (*mir_screencast_callback)(MirScreencast *screencast, void *client_context);
335
typedef void (*mir_screencast_callback)(MirScreencast *screencast, void *client_context);
937
321
336
938
337
/**
939
338
 * Callback member of MirTrustSession for handling of trust sessions.
940
339
 *   \param [in] tps            The trust session associated with the callback
941
340
 *   \param [in,out] context    The context provided by the client
942
341
 */
943
342
typedef void (*mir_trust_session_callback)(MirTrustSession* tps, void* context);
944
343
945
344
/**
946
345
 * Callback member of MirTrustSession for adding trusted sessions
947
346
 *   \param [in] trusted_session  The trust session associated with the callback
948
347
 *   \param [in] result           The result of adding a trusted session
949
348
 *   \param [in,out] context      The context provided by the client
950
349
 */
951
350
typedef void (*mir_trust_session_add_trusted_session_callback)(
952
351
    MirTrustSession* trusted_session, MirTrustSessionAddTrustResult result, void* context);
953
352
954
353
/**
955
354
 * Callback member of MirTrustSession for handling of trust sessions events.
956
355
 *   \param [in] trusted_session  The trust session associated with the callback
957
356
 *   \param [in] state            The state of the trust session
958
357
 *   \param [in,out] context      The context provided by the client
959
358
 */
960
359
typedef void (*mir_trust_session_event_callback)(
961
360
    MirTrustSession* trusted_session, MirTrustSessionState state, void* context);
962
361
963
322
#ifdef __cplusplus
362
#ifdef __cplusplus
964
323
}
363
}
965
324
/**@}*/
364
/**@}*/
966
325
365
967
=== modified file 'include/shared/mir_toolkit/common.h'
968
--- include/shared/mir_toolkit/common.h	2014-03-06 06:05:17 +0000
969
+++ include/shared/mir_toolkit/common.h	2014-05-09 12:26:43 +0000
970
@@ -87,6 +87,23 @@
971
87
    mir_power_mode_off /* Powered down. */
87
    mir_power_mode_off /* Powered down. */
972
88
} MirPowerMode;
88
} MirPowerMode;
973
89
89
974
90
typedef enum MirTrustSessionState
975
91
{
976
92
    mir_trust_session_state_stopped = 0,
977
93
    mir_trust_session_state_started
978
94
} MirTrustSessionState;
979
95
980
96
/**
981
97
 * MirTrustSessionAddTrustResult specifies the result of a
982
98
 * call to add an app id to a trust session
983
99
 */
984
100
typedef enum
985
101
{
986
102
    mir_trust_session_add_tust_failed,
987
103
    mir_trust_session_add_tust_duplicate,
988
104
    mir_trust_session_add_tust_succeeded
989
105
} MirTrustSessionAddTrustResult;
990
106
991
90
/**
107
/**
992
91
 * The order of components in a format enum matches the
108
 * The order of components in a format enum matches the
993
92
 * order of the components as they would be written in an
109
 * order of the components as they would be written in an
994
93
110
995
=== modified file 'include/shared/mir_toolkit/event.h'
996
--- include/shared/mir_toolkit/event.h	2014-03-06 06:05:17 +0000
997
+++ include/shared/mir_toolkit/event.h	2014-05-09 12:26:43 +0000
998
@@ -40,7 +40,8 @@
999
40
    mir_event_type_key,
40
    mir_event_type_key,
1000
41
    mir_event_type_motion,
41
    mir_event_type_motion,
1001
42
    mir_event_type_surface,
42
    mir_event_type_surface,
1003
43
    mir_event_type_resize
43
    mir_event_type_resize,
1004
44
    mir_event_type_trust_session_state_change
1005
44
} MirEventType;
45
} MirEventType;
1006
45
46
1007
46
typedef enum {
47
typedef enum {
1008
@@ -204,6 +205,13 @@
1009
204
    int height;
205
    int height;
1010
205
} MirResizeEvent;
206
} MirResizeEvent;
1011
206
207
1012
208
typedef struct
1013
209
{
1014
210
    MirEventType type;
1015
211
1016
212
    MirTrustSessionState new_state;
1017
213
} MirTrustSessionEvent;
1018
214
1019
207
typedef union
215
typedef union
1020
208
{
216
{
1021
209
    MirEventType    type;
217
    MirEventType    type;
1022
@@ -211,6 +219,7 @@
1023
211
    MirMotionEvent  motion;
219
    MirMotionEvent  motion;
1024
212
    MirSurfaceEvent surface;
220
    MirSurfaceEvent surface;
1025
213
    MirResizeEvent  resize;
221
    MirResizeEvent  resize;
1026
222
    MirTrustSessionEvent  trust_session;
1027
214
} MirEvent;
223
} MirEvent;
1028
215
224
1029
216
#ifdef __cplusplus
225
#ifdef __cplusplus
1030
217
226
1031
=== modified file 'include/test/mir_test/test_protobuf_client.h'
1032
--- include/test/mir_test/test_protobuf_client.h	2013-08-28 03:41:48 +0000
1033
+++ include/test/mir_test/test_protobuf_client.h	2014-05-09 12:26:43 +0000
1034
@@ -21,6 +21,7 @@
1035
21
#define MIR_TEST_TEST_CLIENT_H_
21
#define MIR_TEST_TEST_CLIENT_H_
1036
22
22
1037
23
#include "mir_protobuf.pb.h"
23
#include "mir_protobuf.pb.h"
1038
24
#include "wait_condition.h"
1039
24
25
1040
25
#include <gmock/gmock.h>
26
#include <gmock/gmock.h>
1041
26
27
1042
@@ -49,6 +50,10 @@
1043
49
    mir::protobuf::Connection connection;
50
    mir::protobuf::Connection connection;
1044
50
    mir::protobuf::DisplayConfiguration disp_config;
51
    mir::protobuf::DisplayConfiguration disp_config;
1045
51
    mir::protobuf::DisplayConfiguration disp_config_response;
52
    mir::protobuf::DisplayConfiguration disp_config_response;
1046
53
    mir::protobuf::TrustSessionParameters trust_session_parameters;
1047
54
    mir::protobuf::TrustedSession trusted_session;
1048
55
    mir::protobuf::TrustSession trust_session;
1049
56
    mir::protobuf::TrustSessionAddResult add_trust_result;
1050
52
57
1051
53
    MOCK_METHOD0(connect_done, void());
58
    MOCK_METHOD0(connect_done, void());
1052
54
    MOCK_METHOD0(create_surface_done, void());
59
    MOCK_METHOD0(create_surface_done, void());
1053
@@ -57,6 +62,9 @@
1054
57
    MOCK_METHOD0(disconnect_done, void());
62
    MOCK_METHOD0(disconnect_done, void());
1055
58
    MOCK_METHOD0(drm_auth_magic_done, void());
63
    MOCK_METHOD0(drm_auth_magic_done, void());
1056
59
    MOCK_METHOD0(display_configure_done, void());
64
    MOCK_METHOD0(display_configure_done, void());
1057
65
    MOCK_METHOD0(trust_session_start_done, void());
1058
66
    MOCK_METHOD0(trust_session_add_trusted_session_done, void());
1059
67
    MOCK_METHOD0(trust_session_stop_done, void());
1060
60
68
1061
61
    void on_connect_done();
69
    void on_connect_done();
1062
62
70
1063
@@ -94,6 +102,12 @@
1064
94
102
1065
95
    void wait_for_configure_display_done();
103
    void wait_for_configure_display_done();
1066
96
104
1067
105
    void wait_for_trust_session_start_done();
1068
106
1069
107
    void wait_for_trust_session_add_trusted_session_done();
1070
108
1071
109
    void wait_for_trust_session_stop_done();
1072
110
1073
97
    const int maxwait;
111
    const int maxwait;
1074
98
    std::atomic<bool> connect_done_called;
112
    std::atomic<bool> connect_done_called;
1075
99
    std::atomic<bool> create_surface_called;
113
    std::atomic<bool> create_surface_called;
1076
@@ -104,6 +118,10 @@
1077
104
    std::atomic<bool> configure_display_done_called;
118
    std::atomic<bool> configure_display_done_called;
1078
105
    std::atomic<bool> tfd_done_called;
119
    std::atomic<bool> tfd_done_called;
1079
106
120
1080
121
    WaitCondition wc_trust_session_start;
1081
122
    WaitCondition wc_trust_session_add;
1082
123
    WaitCondition wc_trust_session_stop;
1083
124
1084
107
    std::atomic<int> connect_done_count;
125
    std::atomic<int> connect_done_count;
1085
108
    std::atomic<int> create_surface_done_count;
126
    std::atomic<int> create_surface_done_count;
1086
109
    std::atomic<int> disconnect_done_count;
127
    std::atomic<int> disconnect_done_count;
1087
110
128
1088
=== modified file 'include/test/mir_test_doubles/mock_scene_session.h'
1089
--- include/test/mir_test_doubles/mock_scene_session.h	2014-05-07 14:25:45 +0000
1090
+++ include/test/mir_test_doubles/mock_scene_session.h	2014-05-09 12:26:43 +0000
1091
@@ -52,6 +52,9 @@
1092
52
    MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
52
    MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
1093
53
53
1094
54
    MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState state));
54
    MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState state));
1095
55
1096
56
    MOCK_METHOD0(begin_trust_session, void());
1097
57
    MOCK_METHOD0(end_trust_session, void());
1098
55
};
58
};
1099
56
59
1100
57
}
60
}
1101
58
61
1102
=== modified file 'include/test/mir_test_doubles/mock_shell.h'
1103
--- include/test/mir_test_doubles/mock_shell.h	2014-04-15 05:31:19 +0000
1104
+++ include/test/mir_test_doubles/mock_shell.h	2014-05-09 12:26:43 +0000
1105
@@ -22,6 +22,7 @@
1106
22
#include "mir/scene/surface_creation_parameters.h"
22
#include "mir/scene/surface_creation_parameters.h"
1107
23
#include "mir/frontend/shell.h"
23
#include "mir/frontend/shell.h"
1108
24
#include "mir/frontend/surface_id.h"
24
#include "mir/frontend/surface_id.h"
1109
25
#include "mir/scene/trust_session_creation_parameters.h"
1110
25
26
1111
26
#include <gmock/gmock.h>
27
#include <gmock/gmock.h>
1112
27
28
1113
@@ -43,6 +44,14 @@
1114
43
44
1115
44
    MOCK_METHOD2(create_surface_for, frontend::SurfaceId(std::shared_ptr<frontend::Session> const&, scene::SurfaceCreationParameters const&));
45
    MOCK_METHOD2(create_surface_for, frontend::SurfaceId(std::shared_ptr<frontend::Session> const&, scene::SurfaceCreationParameters const&));
1116
45
    MOCK_METHOD1(handle_surface_created, void(std::shared_ptr<frontend::Session> const&));
46
    MOCK_METHOD1(handle_surface_created, void(std::shared_ptr<frontend::Session> const&));
1117
47
1118
48
    MOCK_METHOD2(start_trust_session_for, std::shared_ptr<frontend::TrustSession>(
1119
49
        std::shared_ptr<frontend::Session> const&,
1120
50
        scene::TrustSessionCreationParameters const&));
1121
51
    MOCK_METHOD2(add_trusted_session_for, MirTrustSessionAddTrustResult(
1122
52
        std::shared_ptr<frontend::TrustSession> const&,
1123
53
        pid_t));
1124
54
    MOCK_METHOD1(stop_trust_session, void(std::shared_ptr<frontend::TrustSession> const&));
1125
46
};
55
};
1126
47
56
1127
48
}
57
}
1128
49
58
1129
=== added file 'include/test/mir_test_doubles/mock_trust_session_listener.h'
1130
--- include/test/mir_test_doubles/mock_trust_session_listener.h	1970-01-01 00:00:00 +0000
1131
+++ include/test/mir_test_doubles/mock_trust_session_listener.h	2014-05-09 12:26:43 +0000
1132
@@ -0,0 +1,48 @@
1133
1
/*
1134
2
 * Copyright © 2014 Canonical Ltd.
1135
3
 *
1136
4
 * This program is free software: you can redistribute it and/or modify it
1137
5
 * under the terms of the GNU General Public License version 3,
1138
6
 * as published by the Free Software Foundation.
1139
7
 *
1140
8
 * This program is distributed in the hope that it will be useful,
1141
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1142
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1143
11
 * GNU General Public License for more details.
1144
12
 *
1145
13
 * You should have received a copy of the GNU General Public License
1146
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1147
15
 *
1148
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
1149
17
 */
1150
18
1151
19
#ifndef MIR_TEST_DOUBLES_MOCK_TRUST_SESSION_LISTENER_H_
1152
20
#define MIR_TEST_DOUBLES_MOCK_TRUST_SESSION_LISTENER_H_
1153
21
1154
22
#include "mir/scene/trust_session_listener.h"
1155
23
1156
24
#include <gmock/gmock.h>
1157
25
1158
26
namespace mir
1159
27
{
1160
28
namespace test
1161
29
{
1162
30
namespace doubles
1163
31
{
1164
32
1165
33
struct MockTrustSessionListener : public scene::TrustSessionListener
1166
34
{
1167
35
    virtual ~MockTrustSessionListener() noexcept(true) {}
1168
36
1169
37
    MOCK_METHOD1(starting, void(scene::TrustSession const&));
1170
38
    MOCK_METHOD1(stopping, void(scene::TrustSession const&));
1171
39
1172
40
    MOCK_METHOD2(trusted_session_beginning, void(scene::TrustSession&, scene::Session const&));
1173
41
    MOCK_METHOD2(trusted_session_ending, void(scene::TrustSession&, scene::Session const&));
1174
42
};
1175
43
1176
44
}
1177
45
}
1178
46
} // namespace mir
1179
47
1180
48
#endif // MIR_TEST_DOUBLES_MOCK_TRUST_SESSION_LISTENER_H_
1181
0
49
1182
=== added file 'include/test/mir_test_doubles/null_trust_session.h'
1183
--- include/test/mir_test_doubles/null_trust_session.h	1970-01-01 00:00:00 +0000
1184
+++ include/test/mir_test_doubles/null_trust_session.h	2014-05-09 12:26:43 +0000
1185
@@ -0,0 +1,70 @@
1186
1
/*
1187
2
 * Copyright © 2013 Canonical Ltd.
1188
3
 *
1189
4
 * This program is free software: you can redistribute it and/or modify it
1190
5
 * under the terms of the GNU General Public License version 3,
1191
6
 * as published by the Free Software Foundation.
1192
7
 *
1193
8
 * This program is distributed in the hope that it will be useful,
1194
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1195
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1196
11
 * GNU General Public License for more details.
1197
12
 *
1198
13
 * You should have received a copy of the GNU General Public License
1199
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1200
15
 *
1201
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
1202
17
 */
1203
18
1204
19
#ifndef MIR_TEST_DOUBLES_NULL_TRUST_SESSION_H_
1205
20
#define MIR_TEST_DOUBLES_NULL_TRUST_SESSION_H_
1206
21
1207
22
#include "mir/scene/trust_session.h"
1208
23
1209
24
namespace mir
1210
25
{
1211
26
namespace test
1212
27
{
1213
28
namespace doubles
1214
29
{
1215
30
1216
31
class NullTrustSession : public scene::TrustSession
1217
32
{
1218
33
    MirTrustSessionState get_state() const override
1219
34
    {
1220
35
      return mir_trust_session_state_stopped;
1221
36
    }
1222
37
1223
38
    void start() override
1224
39
    {
1225
40
    }
1226
41
1227
42
    void stop() override
1228
43
    {
1229
44
    }
1230
45
1231
46
    std::weak_ptr<scene::Session> get_trusted_helper() const override
1232
47
    {
1233
48
      return std::weak_ptr<scene::Session>();
1234
49
    }
1235
50
1236
51
    bool add_trusted_child(std::shared_ptr<scene::Session> const&) override
1237
52
    {
1238
53
        return false;
1239
54
    }
1240
55
1241
56
    void remove_trusted_child(std::shared_ptr<scene::Session> const&) override
1242
57
    {
1243
58
    }
1244
59
1245
60
    void for_each_trusted_child(std::function<void(std::shared_ptr<scene::Session> const&)>,
1246
61
                                bool) const override
1247
62
    {
1248
63
    }
1249
64
};
1250
65
1251
66
}
1252
67
}
1253
68
}
1254
69
1255
70
#endif /* MIR_TEST_DOUBLES_NULL_TRUST_SESSION_H_ */
1256
0
71
1257
=== modified file 'include/test/mir_test_doubles/stub_scene_session.h'
1258
--- include/test/mir_test_doubles/stub_scene_session.h	2014-05-06 16:54:43 +0000
1259
+++ include/test/mir_test_doubles/stub_scene_session.h	2014-05-09 12:26:43 +0000
1260
@@ -76,6 +76,14 @@
1261
76
    void set_lifecycle_state(MirLifecycleState /*state*/)
76
    void set_lifecycle_state(MirLifecycleState /*state*/)
1262
77
    {
77
    {
1263
78
    }
78
    }
1264
79
1265
80
    void begin_trust_session() override
1266
81
    {
1267
82
    }
1268
83
1269
84
    void end_trust_session() override
1270
85
    {
1271
86
    }
1272
79
};
87
};
1273
80
88
1274
81
}
89
}
1275
82
90
1276
=== modified file 'include/test/mir_test_doubles/stub_session.h'
1277
--- include/test/mir_test_doubles/stub_session.h	2014-05-06 16:54:43 +0000
1278
+++ include/test/mir_test_doubles/stub_session.h	2014-05-09 12:26:43 +0000
1279
@@ -41,6 +41,10 @@
1280
41
    {
41
    {
1281
42
        return std::shared_ptr<frontend::Surface>();
42
        return std::shared_ptr<frontend::Surface>();
1282
43
    }
43
    }
1283
44
    pid_t process_id() const override
1284
45
    {
1285
46
        return 0;
1286
47
    }
1287
44
    std::string name() const override
48
    std::string name() const override
1288
45
    {
49
    {
1289
46
        return std::string();
50
        return std::string();
1290
47
51
1291
=== modified file 'include/test/mir_test_doubles/stub_shell.h'
1292
--- include/test/mir_test_doubles/stub_shell.h	2014-04-15 05:31:19 +0000
1293
+++ include/test/mir_test_doubles/stub_shell.h	2014-05-09 12:26:43 +0000
1294
@@ -49,6 +49,21 @@
1295
49
    void handle_surface_created(std::shared_ptr<frontend::Session> const& /* session */) override
49
    void handle_surface_created(std::shared_ptr<frontend::Session> const& /* session */) override
1296
50
    {
50
    {
1297
51
    }
51
    }
1298
52
    std::shared_ptr<frontend::TrustSession> start_trust_session_for(std::shared_ptr<frontend::Session> const& /* session */,
1299
53
        scene::TrustSessionCreationParameters const& /* params */)
1300
54
    {
1301
55
        return std::shared_ptr<frontend::TrustSession>();
1302
56
    }
1303
57
    MirTrustSessionAddTrustResult add_trusted_session_for(
1304
58
        std::shared_ptr<frontend::TrustSession> const&  /* trust_session */,
1305
59
        pid_t /* session_pid */)
1306
60
    {
1307
61
        return mir_trust_session_add_tust_failed;
1308
62
    }
1309
63
    void stop_trust_session(std::shared_ptr<frontend::TrustSession>  const& /* trust_session */)
1310
64
    {
1311
65
    }
1312
66
1313
52
    std::shared_ptr<StubSession> const stub_session;
67
    std::shared_ptr<StubSession> const stub_session;
1314
53
};
68
};
1315
54
69
1316
55
70
1317
=== modified file 'src/client/CMakeLists.txt'
1318
--- src/client/CMakeLists.txt	2014-03-31 14:36:08 +0000
1319
+++ src/client/CMakeLists.txt	2014-05-09 12:26:43 +0000
1320
@@ -47,6 +47,9 @@
1321
47
  private.cpp
47
  private.cpp
1322
48
  mir_screencast.cpp
48
  mir_screencast.cpp
1323
49
  mir_screencast_api.cpp
49
  mir_screencast_api.cpp
1324
50
  mir_trust_session.cpp
1325
51
  mir_trust_session_api.cpp
1326
52
  event_distributor.cpp
1327
50
)
53
)
1328
51
54
1329
52
add_library(
55
add_library(
1330
@@ -81,7 +84,7 @@
1331
81
  mirclientlttngstatic
84
  mirclientlttngstatic
1332
82
85
1333
83
  ${MIR_COMMON_PLATFORM_LIBRARIES}
86
  ${MIR_COMMON_PLATFORM_LIBRARIES}
1335
84
 
87
1336
85
  3rd_party
88
  3rd_party
1337
86
)
89
)
1338
87
90
1339
88
91
1340
=== modified file 'src/client/connection_configuration.h'
1341
--- src/client/connection_configuration.h	2014-03-06 06:05:17 +0000
1342
+++ src/client/connection_configuration.h	2014-05-09 12:26:43 +0000
1343
@@ -47,6 +47,7 @@
1344
47
class ClientPlatformFactory;
47
class ClientPlatformFactory;
1345
48
class DisplayConfiguration;
48
class DisplayConfiguration;
1346
49
class LifecycleControl;
49
class LifecycleControl;
1347
50
class EventDistributor;
1348
50
51
1349
51
class ConnectionConfiguration
52
class ConnectionConfiguration
1350
52
{
53
{
1351
@@ -60,6 +61,7 @@
1352
60
    virtual std::shared_ptr<input::receiver::InputPlatform> the_input_platform() = 0;
61
    virtual std::shared_ptr<input::receiver::InputPlatform> the_input_platform() = 0;
1353
61
    virtual std::shared_ptr<DisplayConfiguration> the_display_configuration() = 0;
62
    virtual std::shared_ptr<DisplayConfiguration> the_display_configuration() = 0;
1354
62
    virtual std::shared_ptr<LifecycleControl> the_lifecycle_control() = 0;
63
    virtual std::shared_ptr<LifecycleControl> the_lifecycle_control() = 0;
1355
64
    virtual std::shared_ptr<EventDistributor> the_event_distributor() = 0;
1356
63
65
1357
64
protected:
66
protected:
1358
65
    ConnectionConfiguration() = default;
67
    ConnectionConfiguration() = default;
1359
66
68
1360
=== modified file 'src/client/default_connection_configuration.cpp'
1361
--- src/client/default_connection_configuration.cpp	2014-03-26 05:48:59 +0000
1362
+++ src/client/default_connection_configuration.cpp	2014-05-09 12:26:43 +0000
1363
@@ -32,6 +32,7 @@
1364
32
#include "lifecycle_control.h"
32
#include "lifecycle_control.h"
1365
33
#include "mir/shared_library.h"
33
#include "mir/shared_library.h"
1366
34
#include "client_platform_factory.h"
34
#include "client_platform_factory.h"
1367
35
#include "event_distributor.h"
1368
35
36
1369
36
namespace mcl = mir::client;
37
namespace mcl = mir::client;
1370
37
38
1371
@@ -81,7 +82,7 @@
1372
81
        [this]
82
        [this]
1373
82
        {
83
        {
1374
83
            return mcl::rpc::make_rpc_channel(
84
            return mcl::rpc::make_rpc_channel(
1376
84
                the_socket_file(), the_surface_map(), the_display_configuration(), the_rpc_report(), the_lifecycle_control());
85
                the_socket_file(), the_surface_map(), the_display_configuration(), the_rpc_report(), the_lifecycle_control(), the_event_distributor());
1377
85
        });
86
        });
1378
86
}
87
}
1379
87
88
1380
@@ -182,3 +183,12 @@
1381
182
            return std::make_shared<mcl::LifecycleControl>();
183
            return std::make_shared<mcl::LifecycleControl>();
1382
183
        });
184
        });
1383
184
}
185
}
1384
186
1385
187
std::shared_ptr<mcl::EventDistributor> mcl::DefaultConnectionConfiguration::the_event_distributor()
1386
188
{
1387
189
    return event_distributor(
1388
190
        []
1389
191
        {
1390
192
            return std::make_shared<mcl::EventDistributor>();
1391
193
        });
1392
194
}
1393
185
195
1394
=== modified file 'src/client/default_connection_configuration.h'
1395
--- src/client/default_connection_configuration.h	2014-03-06 06:05:17 +0000
1396
+++ src/client/default_connection_configuration.h	2014-05-09 12:26:43 +0000
1397
@@ -54,6 +54,7 @@
1398
54
    std::shared_ptr<input::receiver::InputPlatform> the_input_platform();
54
    std::shared_ptr<input::receiver::InputPlatform> the_input_platform();
1399
55
    std::shared_ptr<DisplayConfiguration> the_display_configuration();
55
    std::shared_ptr<DisplayConfiguration> the_display_configuration();
1400
56
    std::shared_ptr<LifecycleControl> the_lifecycle_control();
56
    std::shared_ptr<LifecycleControl> the_lifecycle_control();
1401
57
    std::shared_ptr<EventDistributor> the_event_distributor();
1402
57
58
1403
58
    virtual std::string the_socket_file();
59
    virtual std::string the_socket_file();
1404
59
    virtual std::shared_ptr<rpc::RpcReport> the_rpc_report();
60
    virtual std::shared_ptr<rpc::RpcReport> the_rpc_report();
1405
@@ -67,6 +68,7 @@
1406
67
    CachedPtr<ConnectionSurfaceMap> surface_map;
68
    CachedPtr<ConnectionSurfaceMap> surface_map;
1407
68
    CachedPtr<DisplayConfiguration> display_configuration;
69
    CachedPtr<DisplayConfiguration> display_configuration;
1408
69
    CachedPtr<LifecycleControl> lifecycle_control;
70
    CachedPtr<LifecycleControl> lifecycle_control;
1409
71
    CachedPtr<EventDistributor> event_distributor;
1410
70
72
1411
71
    CachedPtr<rpc::RpcReport> rpc_report;
73
    CachedPtr<rpc::RpcReport> rpc_report;
1412
72
    CachedPtr<input::receiver::InputReceiverReport> input_receiver_report;
74
    CachedPtr<input::receiver::InputReceiverReport> input_receiver_report;
1413
73
75
1414
=== added file 'src/client/event_distributor.cpp'
1415
--- src/client/event_distributor.cpp	1970-01-01 00:00:00 +0000
1416
+++ src/client/event_distributor.cpp	2014-05-09 12:26:43 +0000
1417
@@ -0,0 +1,57 @@
1418
1
/*
1419
2
 * Copyright © 2014 Canonical Ltd.
1420
3
 *
1421
4
 * This program is free software: you can redistribute it and/or modify it
1422
5
 * under the terms of the GNU Lesser General Public License version 3,
1423
6
 * as published by the Free Software Foundation.
1424
7
 *
1425
8
 * This program is distributed in the hope that it will be useful,
1426
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1427
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1428
11
 * GNU Lesser General Public License for more details.
1429
12
 *
1430
13
 * You should have received a copy of the GNU Lesser General Public License
1431
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1432
15
 *
1433
16
 * Authored by: Nick Dedekind <nick.dedekind@gmail.com>
1434
17
 */
1435
18
1436
19
#include "event_distributor.h"
1437
20
1438
21
namespace mcl = mir::client;
1439
22
1440
23
mcl::EventDistributor::EventDistributor() :
1441
24
    next_fn_id(0)
1442
25
{
1443
26
}
1444
27
1445
28
int mcl::EventDistributor::register_event_handler(std::function<void(MirEvent const&)> const& fn)
1446
29
{
1447
30
    std::lock_guard<decltype(mutex)> lock(mutex);
1448
31
1449
32
    int id = next_id();
1450
33
    event_handlers[id] = fn;
1451
34
    return id;
1452
35
}
1453
36
1454
37
void mcl::EventDistributor::unregister_event_handler(int id)
1455
38
{
1456
39
    std::lock_guard<decltype(mutex)> lock(mutex);
1457
40
1458
41
    event_handlers.erase(id);
1459
42
}
1460
43
1461
44
void mcl::EventDistributor::handle_event(MirEvent const& event)
1462
45
{
1463
46
    std::lock_guard<decltype(mutex)> lock(mutex);
1464
47
1465
48
    for (auto const& fn : event_handlers)
1466
49
    {
1467
50
        fn.second(event);
1468
51
    }
1469
52
}
1470
53
1471
54
int mcl::EventDistributor::next_id()
1472
55
{
1473
56
    return ++next_fn_id;
1474
57
}
1475
0
\ No newline at end of file
58
\ No newline at end of file
1476
1
59
1477
=== added file 'src/client/event_distributor.h'
1478
--- src/client/event_distributor.h	1970-01-01 00:00:00 +0000
1479
+++ src/client/event_distributor.h	2014-05-09 12:26:43 +0000
1480
@@ -0,0 +1,52 @@
1481
1
/*
1482
2
 * Copyright © 2014 Canonical Ltd.
1483
3
 *
1484
4
 * This program is free software: you can redistribute it and/or modify it
1485
5
 * under the terms of the GNU Lesser General Public License version 3,
1486
6
 * as published by the Free Software Foundation.
1487
7
 *
1488
8
 * This program is distributed in the hope that it will be useful,
1489
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1490
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1491
11
 * GNU Lesser General Public License for more details.
1492
12
 *
1493
13
 * You should have received a copy of the GNU Lesser General Public License
1494
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1495
15
 *
1496
16
 * Authored by: Nick Dedekind <nick.dedekind@gmail.com>
1497
17
 */
1498
18
1499
19
#ifndef MIR_CLIENT_EVENT_DISTRIBUTOR_H
1500
20
1501
21
#include "mir_toolkit/event.h"
1502
22
1503
23
#include <functional>
1504
24
#include <mutex>
1505
25
#include <map>
1506
26
1507
27
namespace mir
1508
28
{
1509
29
namespace client
1510
30
{
1511
31
class EventDistributor
1512
32
{
1513
33
public:
1514
34
    EventDistributor();
1515
35
    ~EventDistributor() = default;
1516
36
1517
37
    int register_event_handler(std::function<void(MirEvent const&)> const&);
1518
38
    void unregister_event_handler(int id);
1519
39
1520
40
    void handle_event(MirEvent const& event);
1521
41
1522
42
private:
1523
43
    int next_id();
1524
44
1525
45
    mutable std::mutex mutex;
1526
46
    std::map<int, std::function<void(MirEvent const&)>> event_handlers;
1527
47
    int next_fn_id;
1528
48
};
1529
49
}
1530
50
}
1531
51
1532
52
#endif /* MIR_CLIENT_EVENT_DISTRIBUTOR_H */
1533
0
53
1534
=== modified file 'src/client/mir_connection.cpp'
1535
--- src/client/mir_connection.cpp	2014-05-07 13:51:38 +0000
1536
+++ src/client/mir_connection.cpp	2014-05-09 12:26:43 +0000
1537
@@ -18,6 +18,7 @@
1538
18
18
1539
19
#include "mir_connection.h"
19
#include "mir_connection.h"
1540
20
#include "mir_surface.h"
20
#include "mir_surface.h"
1541
21
#include "mir_trust_session.h"
1542
21
#include "client_platform.h"
22
#include "client_platform.h"
1543
22
#include "client_platform_factory.h"
23
#include "client_platform_factory.h"
1544
23
#include "rpc/mir_basic_rpc_channel.h"
24
#include "rpc/mir_basic_rpc_channel.h"
1545
@@ -82,7 +83,8 @@
1546
82
        input_platform(conf.the_input_platform()),
83
        input_platform(conf.the_input_platform()),
1547
83
        display_configuration(conf.the_display_configuration()),
84
        display_configuration(conf.the_display_configuration()),
1548
84
        lifecycle_control(conf.the_lifecycle_control()),
85
        lifecycle_control(conf.the_lifecycle_control()),
1550
85
        surface_map(conf.the_surface_map())
86
        surface_map(conf.the_surface_map()),
1551
87
        event_distributor(conf.the_event_distributor())
1552
86
{
88
{
1553
87
    connect_result.set_error("connect not called");
89
    connect_result.set_error("connect not called");
1554
88
    {
90
    {
1555
@@ -193,6 +195,11 @@
1556
193
    return new_wait_handle;
195
    return new_wait_handle;
1557
194
}
196
}
1558
195
197
1559
198
MirTrustSession* MirConnection::create_trust_session()
1560
199
{
1561
200
    return new MirTrustSession(display_server(), event_distributor);
1562
201
}
1563
202
1564
196
namespace
203
namespace
1565
197
{
204
{
1566
198
void default_lifecycle_event_handler(MirLifecycleState transition)
205
void default_lifecycle_event_handler(MirLifecycleState transition)
1567
@@ -522,6 +529,6 @@
1568
522
}
529
}
1569
523
530
1570
524
mir::protobuf::DisplayServer& MirConnection::display_server()
531
mir::protobuf::DisplayServer& MirConnection::display_server()
1572
525
{ 
532
{
1573
526
    return server;
533
    return server;
1574
527
}
534
}
1575
528
535
1576
=== modified file 'src/client/mir_connection.h'
1577
--- src/client/mir_connection.h	2014-05-07 13:51:38 +0000
1578
+++ src/client/mir_connection.h	2014-05-09 12:26:43 +0000
1579
@@ -45,6 +45,7 @@
1580
45
class ConnectionSurfaceMap;
45
class ConnectionSurfaceMap;
1581
46
class DisplayConfiguration;
46
class DisplayConfiguration;
1582
47
class LifecycleControl;
47
class LifecycleControl;
1583
48
class EventDistributor;
1584
48
49
1585
49
namespace rpc
50
namespace rpc
1586
50
{
51
{
1587
@@ -86,6 +87,8 @@
1588
86
            mir_surface_callback callback,
87
            mir_surface_callback callback,
1589
87
            void *context);
88
            void *context);
1590
88
89
1591
90
    MirTrustSession* create_trust_session();
1592
91
1593
89
    char const * get_error_message();
92
    char const * get_error_message();
1594
90
93
1595
91
    MirWaitHandle* connect(
94
    MirWaitHandle* connect(
1596
@@ -172,6 +175,8 @@
1597
172
175
1598
173
    std::shared_ptr<mir::client::ConnectionSurfaceMap> const surface_map;
176
    std::shared_ptr<mir::client::ConnectionSurfaceMap> const surface_map;
1599
174
177
1600
178
    std::shared_ptr<mir::client::EventDistributor> const event_distributor;
1601
179
1602
175
    std::vector<int> extra_platform_data;
180
    std::vector<int> extra_platform_data;
1603
176
181
1604
177
    struct SurfaceRelease;
182
    struct SurfaceRelease;
1605
178
183
1606
=== added file 'src/client/mir_trust_session.cpp'
1607
--- src/client/mir_trust_session.cpp	1970-01-01 00:00:00 +0000
1608
+++ src/client/mir_trust_session.cpp	2014-05-09 12:26:43 +0000
1609
@@ -0,0 +1,182 @@
1610
1
/*
1611
2
 * Copyright © 2014 Canonical Ltd.
1612
3
 *
1613
4
 * This program is free software: you can redistribute it and/or modify it
1614
5
 * under the terms of the GNU Lesser General Public License version 3,
1615
6
 * as published by the Free Software Foundation.
1616
7
 *
1617
8
 * This program is distributed in the hope that it will be useful,
1618
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1619
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1620
11
 * GNU Lesser General Public License for more details.
1621
12
 *
1622
13
 * You should have received a copy of the GNU Lesser General Public License
1623
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1624
15
 *
1625
16
 * Authored by: Nick Dedekind <nick.dedekind@gmail.com>
1626
17
 */
1627
18
1628
19
#include "mir_trust_session.h"
1629
20
#include "event_distributor.h"
1630
21
1631
22
namespace mp = mir::protobuf;
1632
23
namespace mcl = mir::client;
1633
24
1634
25
MirTrustSession::MirTrustSession(
1635
26
    mp::DisplayServer& server,
1636
27
    std::shared_ptr<mcl::EventDistributor> const& event_distributor)
1637
28
    : server(server),
1638
29
      event_distributor(event_distributor),
1639
30
      state(mir_trust_session_state_stopped)
1640
31
{
1641
32
    event_distributor_fn_id = event_distributor->register_event_handler(
1642
33
        [this](MirEvent const& event)
1643
34
        {
1644
35
            if (event.type != mir_event_type_trust_session_state_change)
1645
36
                return;
1646
37
1647
38
            std::lock_guard<decltype(mutex_event_handler)> lock(mutex_event_handler);
1648
39
1649
40
            set_state(event.trust_session.new_state);
1650
41
            if (handle_trust_session_event) {
1651
42
                handle_trust_session_event(event.trust_session.new_state);
1652
43
            }
1653
44
        }
1654
45
    );
1655
46
}
1656
47
1657
48
MirTrustSession::~MirTrustSession()
1658
49
{
1659
50
    event_distributor->unregister_event_handler(event_distributor_fn_id);
1660
51
}
1661
52
1662
53
MirTrustSessionState MirTrustSession::get_state() const
1663
54
{
1664
55
    std::lock_guard<decltype(mutex)> lock(mutex);
1665
56
1666
57
    return state;
1667
58
}
1668
59
1669
60
void MirTrustSession::set_state(MirTrustSessionState new_state)
1670
61
{
1671
62
    std::lock_guard<decltype(mutex)> lock(mutex);
1672
63
1673
64
    state = new_state;
1674
65
}
1675
66
1676
67
MirWaitHandle* MirTrustSession::start(pid_t pid, mir_trust_session_callback callback, void* context)
1677
68
{
1678
69
    mir::protobuf::TrustSessionParameters parameters;
1679
70
    parameters.mutable_base_trusted_session()->set_pid(pid);
1680
71
1681
72
    server.start_trust_session(
1682
73
        0,
1683
74
        &parameters,
1684
75
        &session,
1685
76
        google::protobuf::NewCallback(this, &MirTrustSession::done_start,
1686
77
                                      callback, context));
1687
78
1688
79
    return &start_wait_handle;
1689
80
}
1690
81
1691
82
MirWaitHandle* MirTrustSession::stop(mir_trust_session_callback callback, void* context)
1692
83
{
1693
84
    server.stop_trust_session(
1694
85
        0,
1695
86
        &protobuf_void,
1696
87
        &protobuf_void,
1697
88
        google::protobuf::NewCallback(this, &MirTrustSession::done_stop,
1698
89
                                      callback, context));
1699
90
1700
91
    return &stop_wait_handle;
1701
92
}
1702
93
1703
94
MirWaitHandle* MirTrustSession::add_trusted_session(pid_t pid,
1704
95
    mir_trust_session_add_trusted_session_callback callback,
1705
96
    void* context)
1706
97
{
1707
98
    mir::protobuf::TrustedSession trusted_session;
1708
99
    trusted_session.set_pid(pid);
1709
100
1710
101
    server.add_trusted_session(
1711
102
        0,
1712
103
        &trusted_session,
1713
104
        &add_result,
1714
105
        google::protobuf::NewCallback(this, &MirTrustSession::done_add_trusted_session,
1715
106
                                      callback, context));
1716
107
1717
108
    return &add_result_wait_handle;
1718
109
}
1719
110
1720
111
void MirTrustSession::register_trust_session_event_callback(
1721
112
    mir_trust_session_event_callback callback,
1722
113
    void* context)
1723
114
{
1724
115
    std::lock_guard<decltype(mutex_event_handler)> lock(mutex_event_handler);
1725
116
1726
117
    handle_trust_session_event =
1727
118
        [this, callback, context](MirTrustSessionState new_state)
1728
119
        {
1729
120
            callback(this, new_state, context);
1730
121
        };
1731
122
}
1732
123
1733
124
void MirTrustSession::done_start(mir_trust_session_callback callback, void* context)
1734
125
{
1735
126
    std::string error;
1736
127
    MirTrustSessionState new_state = mir_trust_session_state_stopped;
1737
128
    {
1738
129
        std::lock_guard<decltype(mutex)> lock(mutex);
1739
130
1740
131
        if (session.has_state())
1741
132
            new_state = (MirTrustSessionState)session.state();
1742
133
1743
134
        error = session.error();
1744
135
    }
1745
136
    set_error_message(error);
1746
137
    set_state(new_state);
1747
138
1748
139
    callback(this, context);
1749
140
    start_wait_handle.result_received();
1750
141
}
1751
142
1752
143
void MirTrustSession::done_stop(mir_trust_session_callback callback, void* context)
1753
144
{
1754
145
    set_state(mir_trust_session_state_stopped);
1755
146
1756
147
    callback(this, context);
1757
148
    stop_wait_handle.result_received();
1758
149
}
1759
150
1760
151
void MirTrustSession::done_add_trusted_session(mir_trust_session_add_trusted_session_callback callback, void* context)
1761
152
{
1762
153
    MirTrustSessionAddTrustResult result = static_cast<MirTrustSessionAddTrustResult>(add_result.result());
1763
154
    if (add_result.has_error())
1764
155
    {
1765
156
        set_error_message(add_result.error());
1766
157
        result = mir_trust_session_add_tust_failed;
1767
158
    }
1768
159
    callback(this, result, context);
1769
160
    add_result_wait_handle.result_received();
1770
161
}
1771
162
1772
163
char const* MirTrustSession::get_error_message()
1773
164
{
1774
165
    std::lock_guard<decltype(mutex)> lock(mutex);
1775
166
1776
167
    if (session.has_error())
1777
168
    {
1778
169
        return session.error().c_str();
1779
170
    }
1780
171
    else
1781
172
    {
1782
173
        return error_message.c_str();
1783
174
    }
1784
175
}
1785
176
1786
177
void MirTrustSession::set_error_message(std::string const& error)
1787
178
{
1788
179
    std::lock_guard<decltype(mutex)> lock(mutex);
1789
180
1790
181
    error_message = error;
1791
182
}
1792
0
183
1793
=== added file 'src/client/mir_trust_session.h'
1794
--- src/client/mir_trust_session.h	1970-01-01 00:00:00 +0000
1795
+++ src/client/mir_trust_session.h	2014-05-09 12:26:43 +0000
1796
@@ -0,0 +1,88 @@
1797
1
/*
1798
2
 * Copyright © 2014 Canonical Ltd.
1799
3
 *
1800
4
 * This program is free software: you can redistribute it and/or modify it
1801
5
 * under the terms of the GNU Lesser General Public License version 3,
1802
6
 * as published by the Free Software Foundation.
1803
7
 *
1804
8
 * This program is distributed in the hope that it will be useful,
1805
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1806
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1807
11
 * GNU Lesser General Public License for more details.
1808
12
 *
1809
13
 * You should have received a copy of the GNU Lesser General Public License
1810
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1811
15
 *
1812
16
 * Authored by: Nick Dedekind <nick.dedekind@gmail.com>
1813
17
 */
1814
18
1815
19
#ifndef MIR_CLIENT_MIR_TRUST_SESSION_H_
1816
20
#define MIR_CLIENT_MIR_TRUST_SESSION_H_
1817
21
1818
22
#include "mir_toolkit/mir_client_library.h"
1819
23
1820
24
#include "mir_protobuf.pb.h"
1821
25
#include "mir_wait_handle.h"
1822
26
1823
27
#include <mutex>
1824
28
#include <memory>
1825
29
#include <atomic>
1826
30
1827
31
namespace mir
1828
32
{
1829
33
/// The client-side library implementation namespace
1830
34
namespace client
1831
35
{
1832
36
class EventDistributor;
1833
37
}
1834
38
}
1835
39
1836
40
struct MirTrustSession
1837
41
{
1838
42
public:
1839
43
    MirTrustSession(mir::protobuf::DisplayServer& server,
1840
44
                    std::shared_ptr<mir::client::EventDistributor> const& event_distributor);
1841
45
1842
46
    ~MirTrustSession();
1843
47
1844
48
    MirTrustSession(MirTrustSession const&) = delete;
1845
49
    MirTrustSession& operator=(MirTrustSession const&) = delete;
1846
50
1847
51
    MirWaitHandle* start(pid_t pid, mir_trust_session_callback callback, void* context);
1848
52
    MirWaitHandle* stop(mir_trust_session_callback callback, void* context);
1849
53
    MirWaitHandle* add_trusted_session(pid_t pid, mir_trust_session_add_trusted_session_callback callback, void* context);
1850
54
1851
55
    void register_trust_session_event_callback(mir_trust_session_event_callback callback, void* context);
1852
56
1853
57
    char const* get_error_message();
1854
58
    void set_error_message(std::string const& error);
1855
59
1856
60
    MirTrustSessionState get_state() const;
1857
61
    void set_state(MirTrustSessionState new_state);
1858
62
1859
63
private:
1860
64
    mutable std::mutex mutex; // Protects members of *this
1861
65
    mutable std::mutex mutex_event_handler; // Need another mutex for callback access to members
1862
66
1863
67
    mir::protobuf::DisplayServer& server;
1864
68
    mir::protobuf::TrustSession session;
1865
69
    mir::protobuf::TrustSessionAddResult add_result;
1866
70
    mir::protobuf::Void protobuf_void;
1867
71
    std::string error_message;
1868
72
1869
73
    std::shared_ptr<mir::client::EventDistributor> const event_distributor;
1870
74
    std::function<void(MirTrustSessionState)> handle_trust_session_event;
1871
75
    int event_distributor_fn_id;
1872
76
1873
77
    MirWaitHandle start_wait_handle;
1874
78
    MirWaitHandle stop_wait_handle;
1875
79
    MirWaitHandle add_result_wait_handle;
1876
80
    MirTrustSessionState state;
1877
81
1878
82
    void done_start(mir_trust_session_callback callback, void* context);
1879
83
    void done_stop(mir_trust_session_callback callback, void* context);
1880
84
    void done_add_trusted_session(mir_trust_session_add_trusted_session_callback callback, void* context);
1881
85
};
1882
86
1883
87
#endif /* MIR_CLIENT_MIR_TRUST_SESSION_H_ */
1884
88
1885
0
89
1886
=== added file 'src/client/mir_trust_session_api.cpp'
1887
--- src/client/mir_trust_session_api.cpp	1970-01-01 00:00:00 +0000
1888
+++ src/client/mir_trust_session_api.cpp	2014-05-09 12:26:43 +0000
1889
@@ -0,0 +1,133 @@
1890
1
/*
1891
2
 * Copyright © 2014 Canonical Ltd.
1892
3
 *
1893
4
 * This program is free software: you can redistribute it and/or modify it
1894
5
 * under the terms of the GNU Lesser General Public License version 3,
1895
6
 * as published by the Free Software Foundation.
1896
7
 *
1897
8
 * This program is distributed in the hope that it will be useful,
1898
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1899
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1900
11
 * GNU Lesser General Public License for more details.
1901
12
 *
1902
13
 * You should have received a copy of the GNU Lesser General Public License
1903
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1904
15
 */
1905
16
1906
17
#include "mir_toolkit/mir_trust_session.h"
1907
18
#include "mir_trust_session.h"
1908
19
#include "mir_connection.h"
1909
20
1910
21
#include <stdexcept>
1911
22
#include <boost/throw_exception.hpp>
1912
23
1913
24
namespace
1914
25
{
1915
26
1916
27
// assign_result is compatible with all 2-parameter callbacks
1917
28
void assign_result(void *result, void **context)
1918
29
{
1919
30
    if (context)
1920
31
        *context = result;
1921
32
}
1922
33
1923
34
void add_trusted_session_callback(MirTrustSession*,
1924
35
                                  MirTrustSessionAddTrustResult result,
1925
36
                                  void* context)
1926
37
{
1927
38
    if (context)
1928
39
        *(MirTrustSessionAddTrustResult*)context = result;
1929
40
}
1930
41
1931
42
}
1932
43
1933
44
MirWaitHandle *mir_connection_start_trust_session(MirConnection* connection,
1934
45
                                                  pid_t base_session_pid,
1935
46
                                                  mir_trust_session_callback start_callback,
1936
47
                                                  mir_trust_session_event_callback event_callback,
1937
48
                                                  void* context)
1938
49
{
1939
50
    auto trust_session = connection->create_trust_session();
1940
51
    if (event_callback)
1941
52
        trust_session->register_trust_session_event_callback(event_callback, context);
1942
53
    return trust_session->start(base_session_pid, start_callback, context);
1943
54
}
1944
55
1945
56
MirTrustSession *mir_connection_start_trust_session_sync(MirConnection* connection,
1946
57
                                                         pid_t base_session_pid,
1947
58
                                                         mir_trust_session_event_callback event_callback,
1948
59
                                                         void* context)
1949
60
{
1950
61
    auto trust_session = connection->create_trust_session();
1951
62
    if (event_callback)
1952
63
        trust_session->register_trust_session_event_callback(event_callback, context);
1953
64
1954
65
    mir_wait_for(trust_session->start(base_session_pid,
1955
66
                                      reinterpret_cast<mir_trust_session_callback>(assign_result),
1956
67
                                      nullptr));
1957
68
    return trust_session;
1958
69
}
1959
70
1960
71
MirTrustSession* mir_connection_create_trust_session(MirConnection* connection)
1961
72
{
1962
73
    return connection->create_trust_session();
1963
74
}
1964
75
1965
76
MirWaitHandle *mir_trust_session_add_trusted_session(MirTrustSession *trust_session,
1966
77
                                                     pid_t session_pid,
1967
78
                                                     mir_trust_session_add_trusted_session_callback callback,
1968
79
                                                     void* context)
1969
80
{
1970
81
    try
1971
82
    {
1972
83
        return trust_session->add_trusted_session(session_pid, callback, context);
1973
84
    }
1974
85
    catch (std::exception const&)
1975
86
    {
1976
87
        // TODO callback with an error
1977
88
        return nullptr;
1978
89
    }
1979
90
}
1980
91
1981
92
MirTrustSessionAddTrustResult mir_trust_session_add_trusted_session_sync(MirTrustSession *trust_session, pid_t base_session_pid)
1982
93
{
1983
94
    MirTrustSessionAddTrustResult result;
1984
95
    mir_wait_for(mir_trust_session_add_trusted_session(trust_session,
1985
96
        base_session_pid,
1986
97
        add_trusted_session_callback,
1987
98
        &result));
1988
99
    return result;
1989
100
}
1990
101
1991
102
MirWaitHandle *mir_trust_session_stop(MirTrustSession *trust_session,
1992
103
                                      mir_trust_session_callback callback,
1993
104
                                      void* context)
1994
105
{
1995
106
    try
1996
107
    {
1997
108
        return trust_session->stop(callback, context);
1998
109
    }
1999
110
    catch (std::exception const&)
2000
111
    {
2001
112
        // TODO callback with an error
2002
113
        return nullptr;
2003
114
    }
2004
115
}
2005
116
2006
117
MirBool mir_trust_session_stop_sync(MirTrustSession *trust_session)
2007
118
{
2008
119
    mir_wait_for(mir_trust_session_stop(trust_session,
2009
120
        reinterpret_cast<mir_trust_session_callback>(assign_result),
2010
121
        NULL));
2011
122
    return trust_session->get_state() == mir_trust_session_state_stopped ? mir_true : mir_false;
2012
123
}
2013
124
2014
125
MirTrustSessionState mir_trust_session_get_state(MirTrustSession *trust_session)
2015
126
{
2016
127
    return trust_session->get_state();
2017
128
}
2018
129
2019
130
void mir_trust_session_release(MirTrustSession* trust_session)
2020
131
{
2021
132
    delete trust_session;
2022
133
}
2023
0
134
2024
=== modified file 'src/client/rpc/make_rpc_channel.h'
2025
--- src/client/rpc/make_rpc_channel.h	2014-03-06 06:05:17 +0000
2026
+++ src/client/rpc/make_rpc_channel.h	2014-05-09 12:26:43 +0000
2027
@@ -29,6 +29,7 @@
2028
29
class SurfaceMap;
29
class SurfaceMap;
2029
30
class DisplayConfiguration;
30
class DisplayConfiguration;
2030
31
class LifecycleControl;
31
class LifecycleControl;
2031
32
class EventDistributor;
2032
32
33
2033
33
namespace rpc
34
namespace rpc
2034
34
{
35
{
2035
@@ -39,7 +40,8 @@
2036
39
                 std::shared_ptr<SurfaceMap> const& map,
40
                 std::shared_ptr<SurfaceMap> const& map,
2037
40
                 std::shared_ptr<DisplayConfiguration> const& disp_conf,
41
                 std::shared_ptr<DisplayConfiguration> const& disp_conf,
2038
41
                 std::shared_ptr<RpcReport> const& rpc_report,
42
                 std::shared_ptr<RpcReport> const& rpc_report,
2040
42
                 std::shared_ptr<LifecycleControl> const& lifecycle_control);
43
                 std::shared_ptr<LifecycleControl> const& lifecycle_control,
2041
44
                 std::shared_ptr<EventDistributor> const& event_distributor);
2042
43
}
45
}
2043
44
}
46
}
2044
45
}
47
}
2045
46
48
2046
=== modified file 'src/client/rpc/make_socket_rpc_channel.cpp'
2047
--- src/client/rpc/make_socket_rpc_channel.cpp	2014-03-06 06:05:17 +0000
2048
+++ src/client/rpc/make_socket_rpc_channel.cpp	2014-05-09 12:26:43 +0000
2049
@@ -44,13 +44,14 @@
2050
44
                       std::shared_ptr<mcl::SurfaceMap> const& map,
44
                       std::shared_ptr<mcl::SurfaceMap> const& map,
2051
45
                       std::shared_ptr<mcl::DisplayConfiguration> const& disp_conf,
45
                       std::shared_ptr<mcl::DisplayConfiguration> const& disp_conf,
2052
46
                       std::shared_ptr<RpcReport> const& rpc_report,
46
                       std::shared_ptr<RpcReport> const& rpc_report,
2054
47
                       std::shared_ptr<mcl::LifecycleControl> const& lifecycle_control)
47
                       std::shared_ptr<mcl::LifecycleControl> const& lifecycle_control,
2055
48
                       std::shared_ptr<mcl::EventDistributor> const& event_distributor)
2056
48
{
49
{
2057
49
    if (fd_prefix.is_start_of(name))
50
    if (fd_prefix.is_start_of(name))
2058
50
    {
51
    {
2059
51
        auto const fd = atoi(name.c_str()+fd_prefix.size);
52
        auto const fd = atoi(name.c_str()+fd_prefix.size);
2061
52
        return std::make_shared<MirSocketRpcChannel>(fd, map, disp_conf, rpc_report, lifecycle_control);
53
        return std::make_shared<MirSocketRpcChannel>(fd, map, disp_conf, rpc_report, lifecycle_control, event_distributor);
2062
53
    }
54
    }
2063
54
55
2065
55
    return std::make_shared<MirSocketRpcChannel>(name, map, disp_conf, rpc_report, lifecycle_control);
56
    return std::make_shared<MirSocketRpcChannel>(name, map, disp_conf, rpc_report, lifecycle_control, event_distributor);
2066
56
}
57
}
2067
57
58
2068
=== modified file 'src/client/rpc/mir_socket_rpc_channel.cpp'
2069
--- src/client/rpc/mir_socket_rpc_channel.cpp	2014-05-06 14:53:36 +0000
2070
+++ src/client/rpc/mir_socket_rpc_channel.cpp	2014-05-09 12:26:43 +0000
2071
@@ -24,6 +24,7 @@
2072
24
#include "../mir_surface.h"
24
#include "../mir_surface.h"
2073
25
#include "../display_configuration.h"
25
#include "../display_configuration.h"
2074
26
#include "../lifecycle_control.h"
26
#include "../lifecycle_control.h"
2075
27
#include "../event_distributor.h"
2076
27
28
2077
28
#include "mir_protobuf.pb.h"  // For Buffer frig
29
#include "mir_protobuf.pb.h"  // For Buffer frig
2078
29
#include "mir_protobuf_wire.pb.h"
30
#include "mir_protobuf_wire.pb.h"
2079
@@ -49,7 +50,8 @@
2080
49
    std::shared_ptr<mcl::SurfaceMap> const& surface_map,
50
    std::shared_ptr<mcl::SurfaceMap> const& surface_map,
2081
50
    std::shared_ptr<DisplayConfiguration> const& disp_config,
51
    std::shared_ptr<DisplayConfiguration> const& disp_config,
2082
51
    std::shared_ptr<RpcReport> const& rpc_report,
52
    std::shared_ptr<RpcReport> const& rpc_report,
2084
52
    std::shared_ptr<LifecycleControl> const& lifecycle_control) :
53
    std::shared_ptr<LifecycleControl> const& lifecycle_control,
2085
54
    std::shared_ptr<EventDistributor> const& event_distributor) :
2086
53
    rpc_report(rpc_report),
55
    rpc_report(rpc_report),
2087
54
    pending_calls(rpc_report),
56
    pending_calls(rpc_report),
2088
55
    work(io_service),
57
    work(io_service),
2089
@@ -57,6 +59,7 @@
2090
57
    surface_map(surface_map),
59
    surface_map(surface_map),
2091
58
    display_configuration(disp_config),
60
    display_configuration(disp_config),
2092
59
    lifecycle_control(lifecycle_control),
61
    lifecycle_control(lifecycle_control),
2093
62
    event_distributor(event_distributor),
2094
60
    disconnected(false)
63
    disconnected(false)
2095
61
{
64
{
2096
62
    socket.connect(endpoint);
65
    socket.connect(endpoint);
2097
@@ -68,7 +71,8 @@
2098
68
    std::shared_ptr<mcl::SurfaceMap> const& surface_map,
71
    std::shared_ptr<mcl::SurfaceMap> const& surface_map,
2099
69
    std::shared_ptr<DisplayConfiguration> const& disp_config,
72
    std::shared_ptr<DisplayConfiguration> const& disp_config,
2100
70
    std::shared_ptr<RpcReport> const& rpc_report,
73
    std::shared_ptr<RpcReport> const& rpc_report,
2102
71
    std::shared_ptr<LifecycleControl> const& lifecycle_control) :
74
    std::shared_ptr<LifecycleControl> const& lifecycle_control,
2103
75
    std::shared_ptr<EventDistributor> const& event_distributor) :
2104
72
    rpc_report(rpc_report),
76
    rpc_report(rpc_report),
2105
73
    pending_calls(rpc_report),
77
    pending_calls(rpc_report),
2106
74
    work(io_service),
78
    work(io_service),
2107
@@ -76,6 +80,7 @@
2108
76
    surface_map(surface_map),
80
    surface_map(surface_map),
2109
77
    display_configuration(disp_config),
81
    display_configuration(disp_config),
2110
78
    lifecycle_control(lifecycle_control),
82
    lifecycle_control(lifecycle_control),
2111
83
    event_distributor(event_distributor),
2112
79
    disconnected(false)
84
    disconnected(false)
2113
80
{
85
{
2114
81
    socket.assign(boost::asio::local::stream_protocol(), native_socket);
86
    socket.assign(boost::asio::local::stream_protocol(), native_socket);
2115
@@ -405,11 +410,25 @@
2116
405
410
2117
406
                rpc_report->event_parsing_succeeded(e);
411
                rpc_report->event_parsing_succeeded(e);
2118
407
412
2124
408
                surface_map->with_surface_do(e.surface.id,
413
                event_distributor->handle_event(e);
2125
409
                    [&e](MirSurface* surface)
414
2126
410
                    {
415
                // todo - surfaces should register with the event distributor.
2127
411
                        surface->handle_event(e);
416
                if (e.type == mir_event_type_surface)
2128
412
                    });
417
                {
2129
418
                    surface_map->with_surface_do(e.surface.id,
2130
419
                        [&e](MirSurface* surface)
2131
420
                        {
2132
421
                            surface->handle_event(e);
2133
422
                        });
2134
423
                }
2135
424
                else if (e.type == mir_event_type_resize)
2136
425
                {
2137
426
                    surface_map->with_surface_do(e.resize.surface_id,
2138
427
                        [&e](MirSurface* surface)
2139
428
                        {
2140
429
                            surface->handle_event(e);
2141
430
                        });
2142
431
                }
2143
413
            }
432
            }
2144
414
            else
433
            else
2145
415
            {
434
            {
2146
416
435
2147
=== modified file 'src/client/rpc/mir_socket_rpc_channel.h'
2148
--- src/client/rpc/mir_socket_rpc_channel.h	2014-05-05 03:36:45 +0000
2149
+++ src/client/rpc/mir_socket_rpc_channel.h	2014-05-09 12:26:43 +0000
2150
@@ -44,6 +44,7 @@
2151
44
class DisplayConfiguration;
44
class DisplayConfiguration;
2152
45
class SurfaceMap;
45
class SurfaceMap;
2153
46
class LifecycleControl;
46
class LifecycleControl;
2154
47
class EventDistributor;
2155
47
namespace rpc
48
namespace rpc
2156
48
{
49
{
2157
49
50
2158
@@ -56,13 +57,15 @@
2159
56
                        std::shared_ptr<SurfaceMap> const& surface_map,
57
                        std::shared_ptr<SurfaceMap> const& surface_map,
2160
57
                        std::shared_ptr<DisplayConfiguration> const& disp_config,
58
                        std::shared_ptr<DisplayConfiguration> const& disp_config,
2161
58
                        std::shared_ptr<RpcReport> const& rpc_report,
59
                        std::shared_ptr<RpcReport> const& rpc_report,
2163
59
                        std::shared_ptr<LifecycleControl> const& lifecycle_control);
60
                        std::shared_ptr<LifecycleControl> const& lifecycle_control,
2164
61
                        std::shared_ptr<EventDistributor> const& event_distributor);
2165
60
62
2166
61
    MirSocketRpcChannel(int native_socket,
63
    MirSocketRpcChannel(int native_socket,
2167
62
                        std::shared_ptr<SurfaceMap> const& surface_map,
64
                        std::shared_ptr<SurfaceMap> const& surface_map,
2168
63
                        std::shared_ptr<DisplayConfiguration> const& disp_config,
65
                        std::shared_ptr<DisplayConfiguration> const& disp_config,
2169
64
                        std::shared_ptr<RpcReport> const& rpc_report,
66
                        std::shared_ptr<RpcReport> const& rpc_report,
2171
65
                        std::shared_ptr<LifecycleControl> const& lifecycle_control);
67
                        std::shared_ptr<LifecycleControl> const& lifecycle_control,
2172
68
                        std::shared_ptr<EventDistributor> const& event_distributor);
2173
66
    ~MirSocketRpcChannel();
69
    ~MirSocketRpcChannel();
2174
67
70
2175
68
private:
71
private:
2176
@@ -102,6 +105,7 @@
2177
102
    std::shared_ptr<SurfaceMap> surface_map;
105
    std::shared_ptr<SurfaceMap> surface_map;
2178
103
    std::shared_ptr<DisplayConfiguration> display_configuration;
106
    std::shared_ptr<DisplayConfiguration> display_configuration;
2179
104
    std::shared_ptr<LifecycleControl> lifecycle_control;
107
    std::shared_ptr<LifecycleControl> lifecycle_control;
2180
108
    std::shared_ptr<EventDistributor> event_distributor;
2181
105
    std::atomic<bool> disconnected;
109
    std::atomic<bool> disconnected;
2182
106
};
110
};
2183
107
111
2184
108
112
2185
=== modified file 'src/server/default_server_configuration.cpp'
2186
--- src/server/default_server_configuration.cpp	2014-05-05 03:36:45 +0000
2187
+++ src/server/default_server_configuration.cpp	2014-05-09 12:26:43 +0000
2188
@@ -36,6 +36,7 @@
2189
36
#include "mir/time/high_resolution_clock.h"
36
#include "mir/time/high_resolution_clock.h"
2190
37
#include "mir/geometry/rectangles.h"
37
#include "mir/geometry/rectangles.h"
2191
38
#include "mir/default_configuration.h"
38
#include "mir/default_configuration.h"
2192
39
#include "mir/scene/null_trust_session_listener.h"
2193
39
40
2194
40
#include <map>
41
#include <map>
2195
41
42
2196
@@ -87,6 +88,16 @@
2197
87
        });
88
        });
2198
88
}
89
}
2199
89
90
2200
91
std::shared_ptr<ms::TrustSessionListener>
2201
92
mir::DefaultServerConfiguration::the_trust_session_listener()
2202
93
{
2203
94
    return trust_session_listener(
2204
95
        [this]
2205
96
        {
2206
97
            return std::make_shared<ms::NullTrustSessionListener>();
2207
98
        });
2208
99
}
2209
100
2210
90
std::shared_ptr<mi::CursorListener>
101
std::shared_ptr<mi::CursorListener>
2211
91
mir::DefaultServerConfiguration::the_cursor_listener()
102
mir::DefaultServerConfiguration::the_cursor_listener()
2212
92
{
103
{
2213
93
104
2214
=== modified file 'src/server/frontend/protobuf_connection_creator.cpp'
2215
=== modified file 'src/server/frontend/protobuf_message_processor.cpp'
2216
--- src/server/frontend/protobuf_message_processor.cpp	2014-05-06 16:54:43 +0000
2217
+++ src/server/frontend/protobuf_message_processor.cpp	2014-05-09 12:26:43 +0000
2218
@@ -174,10 +174,29 @@
2219
174
        {
174
        {
2220
175
            invoke(this, display_server.get(), &protobuf::DisplayServer::release_screencast, invocation);
175
            invoke(this, display_server.get(), &protobuf::DisplayServer::release_screencast, invocation);
2221
176
        }
176
        }
2226
177
        else if ("new_fds_for_trusted_clients" == invocation.method_name())
177
<<<<<<< TREE
2227
178
        {
178
        else if ("new_fds_for_trusted_clients" == invocation.method_name())
2228
179
            invoke(this, display_server.get(), &protobuf::DisplayServer::new_fds_for_trusted_clients, invocation);
179
        {
2229
180
        }
180
            invoke(this, display_server.get(), &protobuf::DisplayServer::new_fds_for_trusted_clients, invocation);
2230
181
        }
2231
182
=======
2232
183
        else if ("new_fds_for_trusted_clients" == invocation.method_name())
2233
184
        {
2234
185
            invoke(this, display_server.get(), &protobuf::DisplayServer::new_fds_for_trusted_clients, invocation);
2235
186
        }
2236
187
        else if ("start_trust_session" == invocation.method_name())
2237
188
        {
2238
189
            invoke(this, display_server.get(), &protobuf::DisplayServer::start_trust_session, invocation);
2239
190
        }
2240
191
        else if ("add_trusted_session" == invocation.method_name())
2241
192
        {
2242
193
            invoke(this, display_server.get(), &protobuf::DisplayServer::add_trusted_session, invocation);
2243
194
        }
2244
195
        else if ("stop_trust_session" == invocation.method_name())
2245
196
        {
2246
197
            invoke(this, display_server.get(), &protobuf::DisplayServer::stop_trust_session, invocation);
2247
198
        }
2248
199
>>>>>>> MERGE-SOURCE
2249
181
        else if ("disconnect" == invocation.method_name())
200
        else if ("disconnect" == invocation.method_name())
2250
182
        {
201
        {
2251
183
            invoke(this, display_server.get(), &protobuf::DisplayServer::disconnect, invocation);
202
            invoke(this, display_server.get(), &protobuf::DisplayServer::disconnect, invocation);
2252
184
203
2253
=== modified file 'src/server/frontend/session_mediator.cpp'
2254
--- src/server/frontend/session_mediator.cpp	2014-05-09 11:01:53 +0000
2255
+++ src/server/frontend/session_mediator.cpp	2014-05-09 12:26:43 +0000
2256
@@ -40,6 +40,8 @@
2257
40
#include "mir/frontend/client_constants.h"
40
#include "mir/frontend/client_constants.h"
2258
41
#include "mir/frontend/event_sink.h"
41
#include "mir/frontend/event_sink.h"
2259
42
#include "mir/frontend/screencast.h"
42
#include "mir/frontend/screencast.h"
2260
43
#include "mir/frontend/trust_session.h"
2261
44
#include "mir/scene/trust_session_creation_parameters.h"
2262
43
45
2263
44
#include "mir/geometry/rectangles.h"
46
#include "mir/geometry/rectangles.h"
2264
45
#include "client_buffer_tracker.h"
47
#include "client_buffer_tracker.h"
2265
@@ -416,6 +418,7 @@
2266
416
    done->Run();
418
    done->Run();
2267
417
}
419
}
2268
418
420
2269
421
<<<<<<< TREE
2270
419
void mf::SessionMediator::new_fds_for_trusted_clients(
422
void mf::SessionMediator::new_fds_for_trusted_clients(
2271
420
    ::google::protobuf::RpcController* ,
423
    ::google::protobuf::RpcController* ,
2272
421
    ::mir::protobuf::SocketFDRequest const* parameters,
424
    ::mir::protobuf::SocketFDRequest const* parameters,
2273
@@ -448,6 +451,51 @@
2274
448
    done->Run();
451
    done->Run();
2275
449
}
452
}
2276
450
453
2277
454
=======
2278
455
void mf::SessionMediator::new_fds_for_trusted_clients(
2279
456
    ::google::protobuf::RpcController* ,
2280
457
    ::mir::protobuf::SocketFDRequest const* parameters,
2281
458
    ::mir::protobuf::SocketFD* response,
2282
459
    ::google::protobuf::Closure* done)
2283
460
{
2284
461
    {
2285
462
        std::unique_lock<std::mutex> lock(session_mutex);
2286
463
        auto session = weak_session.lock();
2287
464
2288
465
        if (session.get() == nullptr)
2289
466
            BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
2290
467
2291
468
        auto trust_session = weak_trust_session.lock();
2292
469
        if (trust_session.get() == nullptr)
2293
470
            BOOST_THROW_EXCEPTION(std::logic_error("Invalid trust session"));
2294
471
2295
472
        // TODO write a handler that connects the new session to our trust session
2296
473
        auto const connect_handler = [this](std::shared_ptr<frontend::Session> const& session)
2297
474
        {
2298
475
            auto trust_session = weak_trust_session.lock();
2299
476
            if (trust_session.get() == nullptr)
2300
477
                BOOST_THROW_EXCEPTION(std::logic_error("Invalid trust session"));
2301
478
2302
479
            shell->add_trusted_session_for(trust_session, session->process_id());
2303
480
        };
2304
481
2305
482
        auto const fds_requested = parameters->number();
2306
483
2307
484
        // < 1 is illogical, > 42 is unreasonable
2308
485
        if (fds_requested < 1 || fds_requested > 42)
2309
486
            BOOST_THROW_EXCEPTION(std::runtime_error("number of fds requested out of range"));
2310
487
2311
488
        for (auto i  = 0; i != fds_requested; ++i)
2312
489
        {
2313
490
            auto const fd = connection_context.fd_for_new_client(connect_handler);
2314
491
            response->add_fd(fd);
2315
492
        }
2316
493
    }
2317
494
2318
495
    done->Run();
2319
496
}
2320
497
2321
498
>>>>>>> MERGE-SOURCE
2322
451
void mf::SessionMediator::drm_auth_magic(
499
void mf::SessionMediator::drm_auth_magic(
2323
452
    google::protobuf::RpcController* /*controller*/,
500
    google::protobuf::RpcController* /*controller*/,
2324
453
    const mir::protobuf::DRMMagic* request,
501
    const mir::protobuf::DRMMagic* request,
2325
@@ -487,6 +535,91 @@
2326
487
    done->Run();
535
    done->Run();
2327
488
}
536
}
2328
489
537
2329
538
void mf::SessionMediator::start_trust_session(::google::protobuf::RpcController*,
2330
539
    const ::mir::protobuf::TrustSessionParameters* request,
2331
540
    ::mir::protobuf::TrustSession* response,
2332
541
    ::google::protobuf::Closure* done)
2333
542
{
2334
543
    {
2335
544
        std::unique_lock<std::mutex> lock(session_mutex);
2336
545
        auto session = weak_session.lock();
2337
546
2338
547
        if (session.get() == nullptr)
2339
548
            BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
2340
549
2341
550
        ms::TrustSessionCreationParameters parameters;
2342
551
        parameters.set_base_process_id(request->base_trusted_session().pid());
2343
552
2344
553
        std::ostringstream stream;
2345
554
        stream << "process id: " << parameters.base_process_id;
2346
555
        report->session_start_trust_session_called(session->name(), stream.str());
2347
556
2348
557
        auto current_trust_session = weak_trust_session.lock();
2349
558
        if (current_trust_session.get() != nullptr)
2350
559
            BOOST_THROW_EXCEPTION(std::runtime_error("Cannot start another trust session"));
2351
560
2352
561
        auto trust_session = shell->start_trust_session_for(session, parameters);
2353
562
        weak_trust_session = trust_session;
2354
563
2355
564
        if (trust_session)
2356
565
        {
2357
566
            response->set_state(trust_session->get_state());
2358
567
        }
2359
568
    }
2360
569
    done->Run();
2361
570
}
2362
571
2363
572
void mf::SessionMediator::add_trusted_session(::google::protobuf::RpcController*,
2364
573
    const ::mir::protobuf::TrustedSession* request,
2365
574
    ::mir::protobuf::TrustSessionAddResult* response,
2366
575
    ::google::protobuf::Closure* done)
2367
576
{
2368
577
    {
2369
578
        std::unique_lock<std::mutex> lock(session_mutex);
2370
579
        auto session = weak_session.lock();
2371
580
2372
581
        if (session.get() == nullptr)
2373
582
            BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
2374
583
2375
584
        auto trust_session = weak_trust_session.lock();
2376
585
2377
586
        if (trust_session.get() == nullptr)
2378
587
            BOOST_THROW_EXCEPTION(std::logic_error("Invalid trust session"));
2379
588
2380
589
        std::ostringstream stream;
2381
590
        stream << "process id: " << request->pid();
2382
591
        report->session_add_trusted_session_called(session->name(), stream.str());
2383
592
2384
593
        response->set_result(shell->add_trusted_session_for(trust_session, request->pid()));
2385
594
    }
2386
595
    done->Run();
2387
596
}
2388
597
2389
598
void mf::SessionMediator::stop_trust_session(::google::protobuf::RpcController*,
2390
599
    const ::mir::protobuf::Void*,
2391
600
    ::mir::protobuf::Void*,
2392
601
    ::google::protobuf::Closure* done)
2393
602
{
2394
603
    {
2395
604
        std::unique_lock<std::mutex> lock(session_mutex);
2396
605
        auto session = weak_session.lock();
2397
606
2398
607
        if (session.get() == nullptr)
2399
608
            BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
2400
609
2401
610
        auto trust_session = weak_trust_session.lock();
2402
611
        weak_trust_session.reset();
2403
612
2404
613
        if (trust_session.get() == nullptr)
2405
614
            BOOST_THROW_EXCEPTION(std::logic_error("Invalid trusted session"));
2406
615
2407
616
        report->session_stop_trust_session_called(session->name());
2408
617
2409
618
        shell->stop_trust_session(trust_session);
2410
619
    }
2411
620
    done->Run();
2412
621
}
2413
622
2414
490
void mf::SessionMediator::pack_protobuf_buffer(
623
void mf::SessionMediator::pack_protobuf_buffer(
2415
491
    protobuf::Buffer& protobuf_buffer,
624
    protobuf::Buffer& protobuf_buffer,
2416
492
    graphics::Buffer* graphics_buffer,
625
    graphics::Buffer* graphics_buffer,
2417
493
626
2418
=== modified file 'src/server/frontend/session_mediator.h'
2419
--- src/server/frontend/session_mediator.h	2014-05-06 16:54:43 +0000
2420
+++ src/server/frontend/session_mediator.h	2014-05-09 12:26:43 +0000
2421
@@ -53,6 +53,7 @@
2422
53
class EventSink;
53
class EventSink;
2423
54
class DisplayChanger;
54
class DisplayChanger;
2424
55
class Screencast;
55
class Screencast;
2425
56
class TrustSession;
2426
56
57
2427
57
// SessionMediator relays requests from the client process into the server.
58
// SessionMediator relays requests from the client process into the server.
2428
58
class SessionMediator : public mir::protobuf::DisplayServer
59
class SessionMediator : public mir::protobuf::DisplayServer
2429
@@ -123,7 +124,26 @@
2430
123
    void screencast_buffer(google::protobuf::RpcController*,
124
    void screencast_buffer(google::protobuf::RpcController*,
2431
124
                           const mir::protobuf::ScreencastId*,
125
                           const mir::protobuf::ScreencastId*,
2432
125
                           mir::protobuf::Buffer*,
126
                           mir::protobuf::Buffer*,
2434
126
                           google::protobuf::Closure* done) override;
127
<<<<<<< TREE
2435
128
                           google::protobuf::Closure* done) override;
2436
129
=======
2437
130
                           google::protobuf::Closure* done) override;
2438
131
2439
132
    void start_trust_session(::google::protobuf::RpcController* controller,
2440
133
                            const ::mir::protobuf::TrustSessionParameters* request,
2441
134
                            ::mir::protobuf::TrustSession* response,
2442
135
                            ::google::protobuf::Closure* done);
2443
136
2444
137
    void add_trusted_session(::google::protobuf::RpcController* controller,
2445
138
                             const ::mir::protobuf::TrustedSession* request,
2446
139
                             ::mir::protobuf::TrustSessionAddResult* response,
2447
140
                             ::google::protobuf::Closure* done);
2448
141
2449
142
    void stop_trust_session(::google::protobuf::RpcController* controller,
2450
143
                            const ::mir::protobuf::Void* request,
2451
144
                            ::mir::protobuf::Void* response,
2452
145
                            ::google::protobuf::Closure* done);
2453
146
>>>>>>> MERGE-SOURCE
2454
127
147
2455
128
    /* Platform specific requests */
148
    /* Platform specific requests */
2456
129
    void drm_auth_magic(google::protobuf::RpcController* controller,
149
    void drm_auth_magic(google::protobuf::RpcController* controller,
2457
@@ -160,8 +180,14 @@
2458
160
180
2459
161
    std::mutex session_mutex;
181
    std::mutex session_mutex;
2460
162
    std::weak_ptr<Session> weak_session;
182
    std::weak_ptr<Session> weak_session;
2463
163
183
<<<<<<< TREE
2464
164
    ConnectionContext const connection_context;
184
2465
185
    ConnectionContext const connection_context;
2466
186
=======
2467
187
    std::weak_ptr<TrustSession> weak_trust_session;
2468
188
2469
189
    ConnectionContext const connection_context;
2470
190
>>>>>>> MERGE-SOURCE
2471
165
};
191
};
2472
166
192
2473
167
}
193
}
2474
168
194
2475
=== modified file 'src/server/report/logging/session_mediator_report.cpp'
2476
--- src/server/report/logging/session_mediator_report.cpp	2014-03-06 06:05:17 +0000
2477
+++ src/server/report/logging/session_mediator_report.cpp	2014-05-09 12:26:43 +0000
2478
@@ -73,6 +73,21 @@
2479
73
    log->log(ml::Logger::informational, "session_configure_display_called(\"" + app_name + "\")", component);
73
    log->log(ml::Logger::informational, "session_configure_display_called(\"" + app_name + "\")", component);
2480
74
}
74
}
2481
75
75
2482
76
void mrl::SessionMediatorReport::session_start_trust_session_called(std::string const& app_name, std::string const& trust_info)
2483
77
{
2484
78
    log->log(ml::Logger::informational, "session_start_trust_session_called(\"" + app_name + "\"):\n" + trust_info, component);
2485
79
}
2486
80
2487
81
void mrl::SessionMediatorReport::session_add_trusted_session_called(std::string const& app_name, std::string const& trust_info)
2488
82
{
2489
83
    log->log(ml::Logger::informational, "session_add_trusted_session_called(\"" + app_name + "\"):\n" + trust_info, component);
2490
84
}
2491
85
2492
86
void mrl::SessionMediatorReport::session_stop_trust_session_called(std::string const& app_name)
2493
87
{
2494
88
    log->log(ml::Logger::informational, "session_stop_trust_session_called(\"" + app_name + "\")", component);
2495
89
}
2496
90
2497
76
void mrl::SessionMediatorReport::session_error(
91
void mrl::SessionMediatorReport::session_error(
2498
77
        std::string const& app_name,
92
        std::string const& app_name,
2499
78
        char const* method,
93
        char const* method,
2500
79
94
2501
=== modified file 'src/server/report/logging/session_mediator_report.h'
2502
--- src/server/report/logging/session_mediator_report.h	2014-03-06 06:05:17 +0000
2503
+++ src/server/report/logging/session_mediator_report.h	2014-05-09 12:26:43 +0000
2504
@@ -57,6 +57,12 @@
2505
57
57
2506
58
    virtual void session_configure_display_called(std::string const& app_name);
58
    virtual void session_configure_display_called(std::string const& app_name);
2507
59
59
2508
60
    virtual void session_start_trust_session_called(std::string const& app_name, std::string const& trust_info);
2509
61
2510
62
    virtual void session_add_trusted_session_called(std::string const& app_name, std::string const& trust_info);
2511
63
2512
64
    virtual void session_stop_trust_session_called(std::string const& app_name);
2513
65
2514
60
    virtual void session_error(
66
    virtual void session_error(
2515
61
        std::string const& app_name,
67
        std::string const& app_name,
2516
62
        char const* method,
68
        char const* method,
2517
63
69
2518
=== modified file 'src/server/report/lttng/session_mediator_report.cpp'
2519
--- src/server/report/lttng/session_mediator_report.cpp	2014-02-09 16:18:16 +0000
2520
+++ src/server/report/lttng/session_mediator_report.cpp	2014-05-09 12:26:43 +0000
2521
@@ -38,6 +38,17 @@
2522
38
MIR_SESSION_MEDIATOR_EVENT_METHOD(session_drm_auth_magic_called)
38
MIR_SESSION_MEDIATOR_EVENT_METHOD(session_drm_auth_magic_called)
2523
39
MIR_SESSION_MEDIATOR_EVENT_METHOD(session_configure_surface_called)
39
MIR_SESSION_MEDIATOR_EVENT_METHOD(session_configure_surface_called)
2524
40
MIR_SESSION_MEDIATOR_EVENT_METHOD(session_configure_display_called)
40
MIR_SESSION_MEDIATOR_EVENT_METHOD(session_configure_display_called)
2525
41
MIR_SESSION_MEDIATOR_EVENT_METHOD(session_stop_trust_session_called)
2526
42
2527
43
void mir::report::lttng::SessionMediatorReport::session_start_trust_session_called(std::string const& app_name, std::string const& trust_info)
2528
44
{
2529
45
    mir_tracepoint(mir_server_session_mediator, session_start_trust_session_called, app_name.c_str(), trust_info.c_str());
2530
46
}
2531
47
2532
48
void mir::report::lttng::SessionMediatorReport::session_add_trusted_session_called(std::string const& app_name, std::string const& trust_info)
2533
49
{
2534
50
    mir_tracepoint(mir_server_session_mediator, session_add_trusted_session_called, app_name.c_str(), trust_info.c_str());
2535
51
}
2536
41
52
2537
42
void mir::report::lttng::SessionMediatorReport::session_error(std::string const& app_name, char const* method, std::string const& what)
53
void mir::report::lttng::SessionMediatorReport::session_error(std::string const& app_name, char const* method, std::string const& what)
2538
43
{
54
{
2539
44
55
2540
=== modified file 'src/server/report/lttng/session_mediator_report.h'
2541
--- src/server/report/lttng/session_mediator_report.h	2014-02-09 16:18:16 +0000
2542
+++ src/server/report/lttng/session_mediator_report.h	2014-05-09 12:26:43 +0000
2543
@@ -41,6 +41,9 @@
2544
41
    void session_drm_auth_magic_called(std::string const& app_name) override;
41
    void session_drm_auth_magic_called(std::string const& app_name) override;
2545
42
    void session_configure_surface_called(std::string const& app_name) override;
42
    void session_configure_surface_called(std::string const& app_name) override;
2546
43
    void session_configure_display_called(std::string const& app_name) override;
43
    void session_configure_display_called(std::string const& app_name) override;
2547
44
    void session_start_trust_session_called(std::string const& app_name, std::string const& trust_info) override;
2548
45
    void session_add_trusted_session_called(std::string const& app_name, std::string const& trust_info) override;
2549
46
    void session_stop_trust_session_called(std::string const& app_name) override;
2550
44
47
2551
45
    void session_error(std::string const& app_name, char const* method, std::string const& what) override;
48
    void session_error(std::string const& app_name, char const* method, std::string const& what) override;
2552
46
private:
49
private:
2553
47
50
2554
=== modified file 'src/server/report/lttng/session_mediator_report_tp.h'
2555
--- src/server/report/lttng/session_mediator_report_tp.h	2014-02-03 11:44:32 +0000
2556
+++ src/server/report/lttng/session_mediator_report_tp.h	2014-05-09 12:26:43 +0000
2557
@@ -47,6 +47,27 @@
2558
47
MIR_SESSION_MEDIATOR_EVENT(session_drm_auth_magic_called)
47
MIR_SESSION_MEDIATOR_EVENT(session_drm_auth_magic_called)
2559
48
MIR_SESSION_MEDIATOR_EVENT(session_configure_surface_called)
48
MIR_SESSION_MEDIATOR_EVENT(session_configure_surface_called)
2560
49
MIR_SESSION_MEDIATOR_EVENT(session_configure_display_called)
49
MIR_SESSION_MEDIATOR_EVENT(session_configure_display_called)
2561
50
MIR_SESSION_MEDIATOR_EVENT(session_stop_trust_session_called)
2562
51
2563
52
TRACEPOINT_EVENT(
2564
53
    mir_server_session_mediator,
2565
54
    session_start_trust_session_called,
2566
55
    TP_ARGS(char const*, application, char const*, trust_info),
2567
56
    TP_FIELDS(
2568
57
        ctf_string(application, application)
2569
58
        ctf_string(trust_info, trust_info)
2570
59
        )
2571
60
    )
2572
61
2573
62
TRACEPOINT_EVENT(
2574
63
    mir_server_session_mediator,
2575
64
    session_add_trusted_session_called,
2576
65
    TP_ARGS(char const*, application, char const*, trust_info),
2577
66
    TP_FIELDS(
2578
67
        ctf_string(application, application)
2579
68
        ctf_string(trust_info, trust_info)
2580
69
        )
2581
70
    )
2582
50
71
2583
51
TRACEPOINT_EVENT(
72
TRACEPOINT_EVENT(
2584
52
    mir_server_session_mediator,
73
    mir_server_session_mediator,
2585
53
74
2586
=== modified file 'src/server/report/null/session_mediator_report.cpp'
2587
--- src/server/report/null/session_mediator_report.cpp	2014-03-06 06:05:17 +0000
2588
+++ src/server/report/null/session_mediator_report.cpp	2014-05-09 12:26:43 +0000
2589
@@ -50,6 +50,18 @@
2590
50
{
50
{
2591
51
}
51
}
2592
52
52
2593
53
void mir::report::null::SessionMediatorReport::session_start_trust_session_called(std::string const&, std::string const&)
2594
54
{
2595
55
}
2596
56
2597
57
void mir::report::null::SessionMediatorReport::session_add_trusted_session_called(std::string const&, std::string const&)
2598
58
{
2599
59
}
2600
60
2601
61
void mir::report::null::SessionMediatorReport::session_stop_trust_session_called(std::string const&)
2602
62
{
2603
63
}
2604
64
2605
53
void mir::report::null::SessionMediatorReport::session_error(
65
void mir::report::null::SessionMediatorReport::session_error(
2606
54
        std::string const&,
66
        std::string const&,
2607
55
        char const* ,
67
        char const* ,
2608
56
68
2609
=== modified file 'src/server/report/null/session_mediator_report.h'
2610
--- src/server/report/null/session_mediator_report.h	2014-02-09 16:18:16 +0000
2611
+++ src/server/report/null/session_mediator_report.h	2014-05-09 12:26:43 +0000
2612
@@ -51,6 +51,12 @@
2613
51
51
2614
52
    void session_configure_display_called(std::string const& app_name) override;
52
    void session_configure_display_called(std::string const& app_name) override;
2615
53
53
2616
54
    void session_start_trust_session_called(std::string const& app_name, std::string const& trust_info) override;
2617
55
2618
56
    void session_add_trusted_session_called(std::string const& app_name, std::string const& trust_info) override;
2619
57
2620
58
    void session_stop_trust_session_called(std::string const& app_name) override;
2621
59
2622
54
    void session_error(
60
    void session_error(
2623
55
        std::string const& app_name,
61
        std::string const& app_name,
2624
56
        char const* method,
62
        char const* method,
2625
57
63
2626
=== modified file 'src/server/scene/CMakeLists.txt'
2627
--- src/server/scene/CMakeLists.txt	2014-05-06 03:33:05 +0000
2628
+++ src/server/scene/CMakeLists.txt	2014-05-09 12:26:43 +0000
2629
@@ -20,4 +20,7 @@
2630
20
  threaded_snapshot_strategy.cpp
20
  threaded_snapshot_strategy.cpp
2631
21
  legacy_scene_change_notification.cpp
21
  legacy_scene_change_notification.cpp
2632
22
  legacy_surface_change_notification.cpp
22
  legacy_surface_change_notification.cpp
2633
23
  trust_session_impl.cpp
2634
24
  trust_session_container.cpp
2635
25
  trust_session_creation_parameters.cpp
2636
23
)
26
)
2637
24
27
2638
=== modified file 'src/server/scene/application_session.cpp'
2639
--- src/server/scene/application_session.cpp	2014-05-06 16:54:43 +0000
2640
+++ src/server/scene/application_session.cpp	2014-05-09 12:26:43 +0000
2641
@@ -23,6 +23,7 @@
2642
23
#include "snapshot_strategy.h"
23
#include "snapshot_strategy.h"
2643
24
#include "mir/scene/session_listener.h"
24
#include "mir/scene/session_listener.h"
2644
25
#include "mir/frontend/event_sink.h"
25
#include "mir/frontend/event_sink.h"
2645
26
#include "default_session_container.h"
2646
26
27
2647
27
#include <boost/throw_exception.hpp>
28
#include <boost/throw_exception.hpp>
2648
28
29
2649
@@ -30,6 +31,7 @@
2650
30
#include <memory>
31
#include <memory>
2651
31
#include <cassert>
32
#include <cassert>
2652
32
#include <algorithm>
33
#include <algorithm>
2653
34
#include <cstring>
2654
33
35
2655
34
namespace mf = mir::frontend;
36
namespace mf = mir::frontend;
2656
35
namespace ms = mir::scene;
37
namespace ms = mir::scene;
2657
@@ -181,3 +183,22 @@
2658
181
{
183
{
2659
182
    event_sink->handle_lifecycle_event(state);
184
    event_sink->handle_lifecycle_event(state);
2660
183
}
185
}
2661
186
2662
187
void ms::ApplicationSession::begin_trust_session()
2663
188
{
2664
189
    // All sessions which are part of the trust session get this event.
2665
190
    MirEvent start_event;
2666
191
    memset(&start_event, 0, sizeof start_event);
2667
192
    start_event.type = mir_event_type_trust_session_state_change;
2668
193
    start_event.trust_session.new_state = mir_trust_session_state_started;
2669
194
    event_sink->handle_event(start_event);
2670
195
}
2671
196
2672
197
void ms::ApplicationSession::end_trust_session()
2673
198
{
2674
199
    MirEvent stop_event;
2675
200
    memset(&stop_event, 0, sizeof stop_event);
2676
201
    stop_event.type = mir_event_type_trust_session_state_change;
2677
202
    stop_event.trust_session.new_state = mir_trust_session_state_stopped;
2678
203
    event_sink->handle_event(stop_event);
2679
204
}
2680
184
205
2681
=== modified file 'src/server/scene/application_session.h'
2682
--- src/server/scene/application_session.h	2014-05-06 16:54:43 +0000
2683
+++ src/server/scene/application_session.h	2014-05-09 12:26:43 +0000
2684
@@ -71,6 +71,9 @@
2685
71
71
2686
72
    void set_lifecycle_state(MirLifecycleState state);
72
    void set_lifecycle_state(MirLifecycleState state);
2687
73
73
2688
74
    void begin_trust_session() override;
2689
75
    void end_trust_session() override;
2690
76
2691
74
protected:
77
protected:
2692
75
    ApplicationSession(ApplicationSession const&) = delete;
78
    ApplicationSession(ApplicationSession const&) = delete;
2693
76
    ApplicationSession& operator=(ApplicationSession const&) = delete;
79
    ApplicationSession& operator=(ApplicationSession const&) = delete;
2694
77
80
2695
=== modified file 'src/server/scene/default_configuration.cpp'
2696
--- src/server/scene/default_configuration.cpp	2014-05-09 03:00:20 +0000
2697
+++ src/server/scene/default_configuration.cpp	2014-05-09 12:26:43 +0000
2698
@@ -25,12 +25,12 @@
2699
25
#include "mir/abnormal_exit.h"
25
#include "mir/abnormal_exit.h"
2700
26
#include "mir/scene/session.h"
26
#include "mir/scene/session.h"
2701
27
27
2702
28
#include "session_container.h"
2703
28
#include "broadcasting_session_event_sink.h"
29
#include "broadcasting_session_event_sink.h"
2704
29
#include "default_session_container.h"
30
#include "default_session_container.h"
2705
30
#include "gl_pixel_buffer.h"
31
#include "gl_pixel_buffer.h"
2706
31
#include "global_event_sender.h"
32
#include "global_event_sender.h"
2707
32
#include "mediating_display_changer.h"
33
#include "mediating_display_changer.h"
2708
33
#include "session_container.h"
2709
34
#include "session_manager.h"
34
#include "session_manager.h"
2710
35
#include "surface_allocator.h"
35
#include "surface_allocator.h"
2711
36
#include "surface_controller.h"
36
#include "surface_controller.h"
2712
@@ -184,7 +184,8 @@
2713
184
                the_shell_focus_setter(),
184
                the_shell_focus_setter(),
2714
185
                the_snapshot_strategy(),
185
                the_snapshot_strategy(),
2715
186
                the_session_event_sink(),
186
                the_session_event_sink(),
2717
187
                the_session_listener());
187
                the_session_listener(),
2718
188
                the_trust_session_listener());
2719
188
        });
189
        });
2720
189
}
190
}
2721
190
191
2722
191
192
2723
=== modified file 'src/server/scene/session_manager.cpp'
2724
--- src/server/scene/session_manager.cpp	2014-04-15 05:31:19 +0000
2725
+++ src/server/scene/session_manager.cpp	2014-05-09 12:26:43 +0000
2726
@@ -24,6 +24,12 @@
2727
24
#include "mir/scene/session.h"
24
#include "mir/scene/session.h"
2728
25
#include "mir/scene/session_listener.h"
25
#include "mir/scene/session_listener.h"
2729
26
#include "session_event_sink.h"
26
#include "session_event_sink.h"
2730
27
#include "mir/scene/trust_session_creation_parameters.h"
2731
28
#include "trust_session_impl.h"
2732
29
#include "trust_session_container.h"
2733
30
#include "mir/scene/trust_session_listener.h"
2734
31
2735
32
#include <boost/throw_exception.hpp>
2736
27
33
2737
28
#include <memory>
34
#include <memory>
2738
29
#include <cassert>
35
#include <cassert>
2739
@@ -38,13 +44,16 @@
2740
38
    std::shared_ptr<msh::FocusSetter> const& focus_setter,
44
    std::shared_ptr<msh::FocusSetter> const& focus_setter,
2741
39
    std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
45
    std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
2742
40
    std::shared_ptr<SessionEventSink> const& session_event_sink,
46
    std::shared_ptr<SessionEventSink> const& session_event_sink,
2744
41
    std::shared_ptr<SessionListener> const& session_listener) :
47
    std::shared_ptr<SessionListener> const& session_listener,
2745
48
    std::shared_ptr<TrustSessionListener> const& trust_session_listener) :
2746
42
    surface_coordinator(surface_factory),
49
    surface_coordinator(surface_factory),
2747
43
    app_container(container),
50
    app_container(container),
2748
44
    focus_setter(focus_setter),
51
    focus_setter(focus_setter),
2749
45
    snapshot_strategy(snapshot_strategy),
52
    snapshot_strategy(snapshot_strategy),
2750
46
    session_event_sink(session_event_sink),
53
    session_event_sink(session_event_sink),
2752
47
    session_listener(session_listener)
54
    session_listener(session_listener),
2753
55
    trust_session_listener(trust_session_listener),
2754
56
    trust_session_container(std::make_shared<TrustSessionContainer>())
2755
48
{
57
{
2756
49
    assert(surface_factory);
58
    assert(surface_factory);
2757
50
    assert(container);
59
    assert(container);
2758
@@ -85,6 +94,16 @@
2759
85
94
2760
86
    session_listener->starting(new_session);
95
    session_listener->starting(new_session);
2761
87
96
2762
97
    {
2763
98
        trust_session_container->for_each_trust_session_for_process(client_pid,
2764
99
            [client_pid, new_session](std::shared_ptr<frontend::TrustSession> const& trust_session)
2765
100
            {
2766
101
                auto scene_trust_session = std::dynamic_pointer_cast<ms::TrustSession>(trust_session);
2767
102
2768
103
                scene_trust_session->add_trusted_child(new_session);
2769
104
            });
2770
105
    }
2771
106
2772
88
    set_focus_to(new_session);
107
    set_focus_to(new_session);
2773
89
108
2774
90
    return new_session;
109
    return new_session;
2775
@@ -122,12 +141,45 @@
2776
122
    scene_session->force_requests_to_complete();
141
    scene_session->force_requests_to_complete();
2777
123
142
2778
124
    session_event_sink->handle_session_stopping(scene_session);
143
    session_event_sink->handle_session_stopping(scene_session);
2779
144
2780
145
    {
2781
146
        std::unique_lock<std::mutex> lock(trust_sessions_mutex);
2782
147
2783
148
        std::vector<std::shared_ptr<frontend::TrustSession>> trust_sessions;
2784
149
        trust_session_container->for_each_trust_session_for_process(scene_session->process_id(),
2785
150
            [&](std::shared_ptr<frontend::TrustSession> const& trust_session)
2786
151
            {
2787
152
                trust_sessions.push_back(trust_session);
2788
153
            });
2789
154
2790
155
        for(auto trust_session : trust_sessions)
2791
156
        {
2792
157
            auto scene_trust_session = std::dynamic_pointer_cast<ms::TrustSession>(trust_session);
2793
158
2794
159
            if (scene_trust_session->get_trusted_helper().lock() == scene_session)
2795
160
            {
2796
161
                stop_trust_session_locked(lock, scene_trust_session);
2797
162
            }
2798
163
            else
2799
164
            {
2800
165
                scene_trust_session->remove_trusted_child(scene_session);
2801
166
2802
167
                trust_session_container->remove_process(scene_session->process_id());
2803
168
            }
2804
169
        }
2805
170
    }
2806
171
2807
125
    session_listener->stopping(scene_session);
172
    session_listener->stopping(scene_session);
2808
126
173
2809
127
    app_container->remove_session(scene_session);
174
    app_container->remove_session(scene_session);
2810
128
175
2811
129
    std::unique_lock<std::mutex> lock(mutex);
176
    std::unique_lock<std::mutex> lock(mutex);
2813
130
    set_focus_to_locked(lock, app_container->successor_of(std::shared_ptr<Session>()));
177
    auto old_focus = focus_application.lock();
2814
178
    if (old_focus == scene_session)
2815
179
    {
2816
180
        // only reset the focus if this session had focus
2817
181
        set_focus_to_locked(lock, app_container->successor_of(std::shared_ptr<ms::Session>()));
2818
182
    }
2819
131
}
183
}
2820
132
184
2821
133
void ms::SessionManager::focus_next()
185
void ms::SessionManager::focus_next()
2822
@@ -169,3 +221,73 @@
2823
169
{
221
{
2824
170
    set_focus_to(std::dynamic_pointer_cast<Session>(session));
222
    set_focus_to(std::dynamic_pointer_cast<Session>(session));
2825
171
}
223
}
2826
224
2827
225
std::shared_ptr<mf::TrustSession> ms::SessionManager::start_trust_session_for(std::shared_ptr<mf::Session> const& session,
2828
226
    TrustSessionCreationParameters const& params)
2829
227
{
2830
228
    std::unique_lock<std::mutex> lock(trust_sessions_mutex);
2831
229
2832
230
    auto shell_session = std::dynamic_pointer_cast<ms::Session>(session);
2833
231
2834
232
    auto const trust_session = std::make_shared<TrustSessionImpl>(shell_session, params, trust_session_listener);
2835
233
2836
234
    trust_session_container->insert(trust_session, shell_session->process_id());
2837
235
2838
236
    trust_session->start();
2839
237
    trust_session_listener->starting(*(trust_session.get()));
2840
238
2841
239
    add_trusted_session_for_locked(lock, trust_session, params.base_process_id);
2842
240
    return trust_session;
2843
241
}
2844
242
2845
243
MirTrustSessionAddTrustResult ms::SessionManager::add_trusted_session_for(std::shared_ptr<mf::TrustSession> const& trust_session,
2846
244
    pid_t session_pid)
2847
245
{
2848
246
    std::unique_lock<std::mutex> lock(trust_sessions_mutex);
2849
247
2850
248
    return add_trusted_session_for_locked(lock, trust_session, session_pid);
2851
249
}
2852
250
2853
251
MirTrustSessionAddTrustResult ms::SessionManager::add_trusted_session_for_locked(std::unique_lock<std::mutex> const&,
2854
252
    std::shared_ptr<mf::TrustSession> const& trust_session,
2855
253
    pid_t session_pid)
2856
254
{
2857
255
    auto scene_trust_session = std::dynamic_pointer_cast<ms::TrustSession>(trust_session);
2858
256
2859
257
    trust_session_container->insert(trust_session, session_pid);
2860
258
2861
259
    bool added = false;
2862
260
    app_container->for_each(
2863
261
        [&](std::shared_ptr<ms::Session> const& container_session)
2864
262
        {
2865
263
            if (container_session->process_id() == session_pid)
2866
264
            {
2867
265
                added |= scene_trust_session->add_trusted_child(container_session);
2868
266
            }
2869
267
        });
2870
268
2871
269
    if (!added)
2872
270
        BOOST_THROW_EXCEPTION(std::runtime_error("failed to add trusted session"));
2873
271
2874
272
    return mir_trust_session_add_tust_succeeded;
2875
273
}
2876
274
2877
275
void ms::SessionManager::stop_trust_session(std::shared_ptr<mf::TrustSession> const& trust_session)
2878
276
{
2879
277
    std::unique_lock<std::mutex> lock(trust_sessions_mutex);
2880
278
2881
279
    stop_trust_session_locked(lock, trust_session);
2882
280
}
2883
281
2884
282
void ms::SessionManager::stop_trust_session_locked(std::unique_lock<std::mutex> const&,
2885
283
    std::shared_ptr<mf::TrustSession> const& trust_session)
2886
284
{
2887
285
    auto scene_trust_session = std::dynamic_pointer_cast<ms::TrustSession>(trust_session);
2888
286
2889
287
    trust_session->stop();
2890
288
2891
289
    trust_session_container->remove_trust_session(trust_session);
2892
290
2893
291
    trust_session_listener->stopping(*(scene_trust_session).get());
2894
292
}
2895
293
2896
172
294
2897
=== modified file 'src/server/scene/session_manager.h'
2898
--- src/server/scene/session_manager.h	2014-04-15 05:31:19 +0000
2899
+++ src/server/scene/session_manager.h	2014-05-09 12:26:43 +0000
2900
@@ -26,6 +26,7 @@
2901
26
#include <mutex>
26
#include <mutex>
2902
27
#include <memory>
27
#include <memory>
2903
28
#include <vector>
28
#include <vector>
2904
29
#include <map>
2905
29
30
2906
30
namespace mir
31
namespace mir
2907
31
{
32
{
2908
@@ -42,6 +43,8 @@
2909
42
class SessionListener;
43
class SessionListener;
2910
43
class SnapshotStrategy;
44
class SnapshotStrategy;
2911
44
class SurfaceCoordinator;
45
class SurfaceCoordinator;
2912
46
class TrustSessionContainer;
2913
47
class TrustSessionListener;
2914
45
48
2915
46
class SessionManager : public frontend::Shell, public shell::FocusController
49
class SessionManager : public frontend::Shell, public shell::FocusController
2916
47
{
50
{
2917
@@ -51,7 +54,8 @@
2918
51
                            std::shared_ptr<shell::FocusSetter> const& focus_setter,
54
                            std::shared_ptr<shell::FocusSetter> const& focus_setter,
2919
52
                            std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
55
                            std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
2920
53
                            std::shared_ptr<SessionEventSink> const& session_event_sink,
56
                            std::shared_ptr<SessionEventSink> const& session_event_sink,
2922
54
                            std::shared_ptr<SessionListener> const& session_listener);
57
                            std::shared_ptr<SessionListener> const& session_listener,
2923
58
                            std::shared_ptr<TrustSessionListener> const& trust_session_listener);
2924
55
    virtual ~SessionManager();
59
    virtual ~SessionManager();
2925
56
60
2926
57
    virtual std::shared_ptr<frontend::Session> open_session(
61
    virtual std::shared_ptr<frontend::Session> open_session(
2927
@@ -71,6 +75,12 @@
2928
71
75
2929
72
    void handle_surface_created(std::shared_ptr<frontend::Session> const& session) override;
76
    void handle_surface_created(std::shared_ptr<frontend::Session> const& session) override;
2930
73
77
2931
78
    std::shared_ptr<frontend::TrustSession> start_trust_session_for(std::shared_ptr<frontend::Session> const& session,
2932
79
                                                  TrustSessionCreationParameters const& params) override;
2933
80
    MirTrustSessionAddTrustResult add_trusted_session_for(std::shared_ptr<frontend::TrustSession> const& trust_session,
2934
81
                                                          pid_t session_pid) override;
2935
82
    void stop_trust_session(std::shared_ptr<frontend::TrustSession> const& trust_session) override;
2936
83
2937
74
protected:
84
protected:
2938
75
    SessionManager(const SessionManager&) = delete;
85
    SessionManager(const SessionManager&) = delete;
2939
76
    SessionManager& operator=(const SessionManager&) = delete;
86
    SessionManager& operator=(const SessionManager&) = delete;
2940
@@ -82,11 +92,20 @@
2941
82
    std::shared_ptr<SnapshotStrategy> const snapshot_strategy;
92
    std::shared_ptr<SnapshotStrategy> const snapshot_strategy;
2942
83
    std::shared_ptr<SessionEventSink> const session_event_sink;
93
    std::shared_ptr<SessionEventSink> const session_event_sink;
2943
84
    std::shared_ptr<SessionListener> const session_listener;
94
    std::shared_ptr<SessionListener> const session_listener;
2944
95
    std::shared_ptr<TrustSessionListener> const trust_session_listener;
2945
96
    std::shared_ptr<TrustSessionContainer> trust_session_container;
2946
85
97
2947
86
    std::mutex mutex;
98
    std::mutex mutex;
2948
87
    std::weak_ptr<Session> focus_application;
99
    std::weak_ptr<Session> focus_application;
2949
88
100
2950
89
    void set_focus_to_locked(std::unique_lock<std::mutex> const& lock, std::shared_ptr<Session> const& next_focus);
101
    void set_focus_to_locked(std::unique_lock<std::mutex> const& lock, std::shared_ptr<Session> const& next_focus);
2951
102
2952
103
    MirTrustSessionAddTrustResult add_trusted_session_for_locked(std::unique_lock<std::mutex> const&,
2953
104
                                                                 std::shared_ptr<frontend::TrustSession> const& trust_session,
2954
105
                                                                 pid_t session_pid);
2955
106
    void stop_trust_session_locked(std::unique_lock<std::mutex> const& lock,
2956
107
                                   std::shared_ptr<frontend::TrustSession> const& trust_session);
2957
108
    std::mutex mutable trust_sessions_mutex;
2958
90
};
109
};
2959
91
110
2960
92
}
111
}
2961
93
112
2962
=== added file 'src/server/scene/trust_session_container.cpp'
2963
--- src/server/scene/trust_session_container.cpp	1970-01-01 00:00:00 +0000
2964
+++ src/server/scene/trust_session_container.cpp	2014-05-09 12:26:43 +0000
2965
@@ -0,0 +1,95 @@
2966
1
/*
2967
2
 * Copyright © 2014 Canonical Ltd.
2968
3
 *
2969
4
 * This program is free software: you can redistribute it and/or modify it
2970
5
 * under the terms of the GNU General Public License version 3,
2971
6
 * as published by the Free Software Foundation.
2972
7
 *
2973
8
 * This program is distributed in the hope that it will be useful,
2974
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2975
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2976
11
 * GNU General Public License for more details.
2977
12
 *
2978
13
 * You should have received a copy of the GNU General Public License
2979
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2980
15
 *
2981
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
2982
17
 */
2983
18
2984
19
#include "trust_session_container.h"
2985
20
2986
21
namespace ms = mir::scene;
2987
22
namespace mf = mir::frontend;
2988
23
2989
24
uint insertion_order = 0;
2990
25
2991
26
ms::TrustSessionContainer::TrustSessionContainer()
2992
27
    : trust_session_index(process_map)
2993
28
    , process_index(get<1>(process_map))
2994
29
{
2995
30
}
2996
31
2997
32
bool ms::TrustSessionContainer::insert(std::shared_ptr<mf::TrustSession> const& trust_session, ClientProcess const& process)
2998
33
{
2999
34
    std::unique_lock<std::mutex> lk(mutex);
3000
35
3001
36
    object_by_trust_session::iterator it;
3002
37
    bool valid = false;
3003
38
3004
39
    Object obj{trust_session, process, insertion_order++};
3005
40
    boost::tie(it,valid) = process_map.insert(obj);
3006
41
3007
42
    return valid;
3008
43
}
3009
44
3010
45
void ms::TrustSessionContainer::for_each_process_for_trust_session(
3011
46
    std::shared_ptr<mf::TrustSession> const& trust_session,
3012
47
    std::function<void(ClientProcess const& id)> f)
3013
48
{
3014
49
    std::unique_lock<std::mutex> lk(mutex);
3015
50
3016
51
    object_by_trust_session::iterator it,end;
3017
52
    boost::tie(it,end) = trust_session_index.equal_range(trust_session);
3018
53
3019
54
    for (; it != end; ++it)
3020
55
    {
3021
56
        Object const& obj = *it;
3022
57
        f(obj.client_process);
3023
58
    }
3024
59
}
3025
60
3026
61
void ms::TrustSessionContainer::for_each_trust_session_for_process(
3027
62
    ClientProcess const& process,
3028
63
    std::function<void(std::shared_ptr<mf::TrustSession> const&)> f)
3029
64
{
3030
65
    std::unique_lock<std::mutex> lk(mutex);
3031
66
3032
67
    object_by_process::iterator it,end;
3033
68
    boost::tie(it,end) = process_index.equal_range(process);
3034
69
3035
70
    for (; it != end; ++it)
3036
71
    {
3037
72
        Object const& obj = *it;
3038
73
        f(obj.trust_session);
3039
74
    }
3040
75
}
3041
76
3042
77
void ms::TrustSessionContainer::remove_trust_session(std::shared_ptr<frontend::TrustSession> const& trust_session)
3043
78
{
3044
79
    std::unique_lock<std::mutex> lk(mutex);
3045
80
3046
81
    object_by_trust_session::iterator it,end;
3047
82
    boost::tie(it,end) = trust_session_index.equal_range(trust_session);
3048
83
3049
84
    trust_session_index.erase(it, end);
3050
85
}
3051
86
3052
87
void ms::TrustSessionContainer::remove_process(ClientProcess const& process)
3053
88
{
3054
89
    std::unique_lock<std::mutex> lk(mutex);
3055
90
3056
91
    object_by_process::iterator it,end;
3057
92
    boost::tie(it,end) = process_index.equal_range(process);
3058
93
3059
94
    process_index.erase(it, end);
3060
95
}
3061
0
96
3062
=== added file 'src/server/scene/trust_session_container.h'
3063
--- src/server/scene/trust_session_container.h	1970-01-01 00:00:00 +0000
3064
+++ src/server/scene/trust_session_container.h	2014-05-09 12:26:43 +0000
3065
@@ -0,0 +1,103 @@
3066
1
/*
3067
2
 * Copyright © 2014 Canonical Ltd.
3068
3
 *
3069
4
 * This program is free software: you can redistribute it and/or modify it
3070
5
 * under the terms of the GNU General Public License version 3,
3071
6
 * as published by the Free Software Foundation.
3072
7
 *
3073
8
 * This program is distributed in the hope that it will be useful,
3074
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3075
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3076
11
 * GNU General Public License for more details.
3077
12
 *
3078
13
 * You should have received a copy of the GNU General Public License
3079
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3080
15
 *
3081
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
3082
17
 */
3083
18
3084
19
#ifndef MIR_SCENE_TRUST_SESSION_CONTAINER_H_
3085
20
#define MIR_SCENE_TRUST_SESSION_CONTAINER_H_
3086
21
3087
22
#include <sys/types.h>
3088
23
#include <mutex>
3089
24
#include <map>
3090
25
3091
26
#include <boost/multi_index_container.hpp>
3092
27
#include <boost/multi_index/member.hpp>
3093
28
#include <boost/multi_index/ordered_index.hpp>
3094
29
#include <boost/multi_index/hashed_index.hpp>
3095
30
#include <boost/multi_index/composite_key.hpp>
3096
31
3097
32
namespace mir
3098
33
{
3099
34
namespace frontend
3100
35
{
3101
36
class TrustSession;
3102
37
class Session;
3103
38
}
3104
39
3105
40
using boost::multi_index_container;
3106
41
using namespace boost::multi_index;
3107
42
3108
43
namespace scene
3109
44
{
3110
45
3111
46
class TrustSessionContainer
3112
47
{
3113
48
public:
3114
49
    TrustSessionContainer();
3115
50
    virtual ~TrustSessionContainer() = default;
3116
51
3117
52
    typedef pid_t ClientProcess;
3118
53
3119
54
    bool insert(std::shared_ptr<frontend::TrustSession> const& trust_session, ClientProcess const& process);
3120
55
3121
56
    void for_each_process_for_trust_session(std::shared_ptr<frontend::TrustSession> const& trust_session, std::function<void(ClientProcess const&)> f);
3122
57
    void for_each_trust_session_for_process(ClientProcess const& process, std::function<void(std::shared_ptr<frontend::TrustSession> const&)> f);
3123
58
3124
59
    void remove_trust_session(std::shared_ptr<frontend::TrustSession> const& trust_session);
3125
60
    void remove_process(ClientProcess const& process);
3126
61
3127
62
private:
3128
63
    std::mutex mutable mutex;
3129
64
3130
65
    typedef struct {
3131
66
        std::shared_ptr<frontend::TrustSession> trust_session;
3132
67
        ClientProcess client_process;
3133
68
        uint insert_order;
3134
69
    } Object;
3135
70
3136
71
    typedef multi_index_container<
3137
72
        Object,
3138
73
        indexed_by<
3139
74
            ordered_non_unique<
3140
75
                composite_key<
3141
76
                    Object,
3142
77
                    member<Object, std::shared_ptr<frontend::TrustSession>, &Object::trust_session>,
3143
78
                    member<Object, uint, &Object::insert_order>
3144
79
                >
3145
80
            >,
3146
81
            ordered_unique<
3147
82
                composite_key<
3148
83
                    Object,
3149
84
                    member<Object, ClientProcess, &Object::client_process>,
3150
85
                    member<Object, std::shared_ptr<frontend::TrustSession>, &Object::trust_session>
3151
86
                >
3152
87
            >
3153
88
        >
3154
89
    > TrustSessionsProcesses;
3155
90
3156
91
    typedef nth_index<TrustSessionsProcesses,0>::type object_by_trust_session;
3157
92
    typedef nth_index<TrustSessionsProcesses,1>::type object_by_process;
3158
93
3159
94
3160
95
    TrustSessionsProcesses process_map;
3161
96
    object_by_trust_session& trust_session_index;
3162
97
    object_by_process& process_index;
3163
98
};
3164
99
3165
100
}
3166
101
}
3167
102
3168
103
#endif // MIR_SCENE_TRUST_SESSION_CONTAINER_H_
3169
0
104
3170
=== added file 'src/server/scene/trust_session_creation_parameters.cpp'
3171
--- src/server/scene/trust_session_creation_parameters.cpp	1970-01-01 00:00:00 +0000
3172
+++ src/server/scene/trust_session_creation_parameters.cpp	2014-05-09 12:26:43 +0000
3173
@@ -0,0 +1,51 @@
3174
1
/*
3175
2
 * Copyright © 2014 Canonical Ltd.
3176
3
 *
3177
4
 * This program is free software: you can redistribute it and/or modify it
3178
5
 * under the terms of the GNU General Public License version 3,
3179
6
 * as published by the Free Software Foundation.
3180
7
 *
3181
8
 * This program is distributed in the hope that it will be useful,
3182
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3183
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3184
11
 * GNU General Public License for more details.
3185
12
 *
3186
13
 * You should have received a copy of the GNU General Public License
3187
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3188
15
 *
3189
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
3190
17
 */
3191
18
3192
19
#include "mir/scene/trust_session_creation_parameters.h"
3193
20
3194
21
namespace ms = mir::scene;
3195
22
3196
23
ms::TrustSessionCreationParameters::TrustSessionCreationParameters()
3197
24
    : base_process_id(0)
3198
25
{
3199
26
}
3200
27
3201
28
ms::TrustSessionCreationParameters& ms::TrustSessionCreationParameters::set_base_process_id(pid_t process_id)
3202
29
{
3203
30
    base_process_id = process_id;
3204
31
    return *this;
3205
32
}
3206
33
3207
34
bool ms::operator==(
3208
35
    const TrustSessionCreationParameters& lhs,
3209
36
    const TrustSessionCreationParameters& rhs)
3210
37
{
3211
38
    return lhs.base_process_id == rhs.base_process_id;
3212
39
}
3213
40
3214
41
bool ms::operator!=(
3215
42
    const TrustSessionCreationParameters& lhs,
3216
43
    const TrustSessionCreationParameters& rhs)
3217
44
{
3218
45
    return !(lhs == rhs);
3219
46
}
3220
47
3221
48
ms::TrustSessionCreationParameters ms::a_trust_session()
3222
49
{
3223
50
    return TrustSessionCreationParameters();
3224
51
}
3225
0
52
3226
=== added file 'src/server/scene/trust_session_impl.cpp'
3227
--- src/server/scene/trust_session_impl.cpp	1970-01-01 00:00:00 +0000
3228
+++ src/server/scene/trust_session_impl.cpp	2014-05-09 12:26:43 +0000
3229
@@ -0,0 +1,187 @@
3230
1
/*
3231
2
 * Copyright © 2014 Canonical Ltd.
3232
3
 *
3233
4
 * This program is free software: you can redistribute it and/or modify it
3234
5
 * under the terms of the GNU General Public License version 3,
3235
6
 * as published by the Free Software Foundation.
3236
7
 *
3237
8
 * This program is distributed in the hope that it will be useful,
3238
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3239
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3240
11
 * GNU General Public License for more details.
3241
12
 *
3242
13
 * You should have received a copy of the GNU General Public License
3243
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3244
15
 *
3245
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
3246
17
 */
3247
18
3248
19
#include "trust_session_impl.h"
3249
20
#include "mir/scene/session.h"
3250
21
#include "mir/scene/trust_session_creation_parameters.h"
3251
22
#include "mir/scene/trust_session_listener.h"
3252
23
#include "session_container.h"
3253
24
3254
25
#include <sstream>
3255
26
#include <algorithm>
3256
27
3257
28
namespace ms = mir::scene;
3258
29
3259
30
int next_unique_id = 0;
3260
31
3261
32
ms::TrustSessionImpl::TrustSessionImpl(
3262
33
    std::weak_ptr<ms::Session> const& session,
3263
34
    TrustSessionCreationParameters const&,
3264
35
    std::shared_ptr<TrustSessionListener> const& trust_session_listener) :
3265
36
    trusted_helper(session),
3266
37
    trust_session_listener(trust_session_listener),
3267
38
    state(mir_trust_session_state_stopped)
3268
39
{
3269
40
}
3270
41
3271
42
ms::TrustSessionImpl::~TrustSessionImpl()
3272
43
{
3273
44
    TrustSessionImpl::stop();
3274
45
}
3275
46
3276
47
MirTrustSessionState ms::TrustSessionImpl::get_state() const
3277
48
{
3278
49
    std::lock_guard<decltype(mutex)> lock(mutex);
3279
50
3280
51
    return state;
3281
52
}
3282
53
3283
54
std::weak_ptr<ms::Session> ms::TrustSessionImpl::get_trusted_helper() const
3284
55
{
3285
56
    std::lock_guard<decltype(mutex)> lock(mutex);
3286
57
3287
58
    return trusted_helper;
3288
59
}
3289
60
3290
61
void ms::TrustSessionImpl::start()
3291
62
{
3292
63
    std::lock_guard<decltype(mutex)> lock(mutex);
3293
64
3294
65
    if (state == mir_trust_session_state_started)
3295
66
        return;
3296
67
3297
68
    state = mir_trust_session_state_started;
3298
69
3299
70
    auto helper = trusted_helper.lock();
3300
71
    if (helper) {
3301
72
        helper->begin_trust_session();
3302
73
    }
3303
74
}
3304
75
3305
76
void ms::TrustSessionImpl::stop()
3306
77
{
3307
78
    std::lock_guard<decltype(mutex)> lock(mutex);
3308
79
3309
80
    if (state == mir_trust_session_state_stopped)
3310
81
        return;
3311
82
3312
83
    state = mir_trust_session_state_stopped;
3313
84
3314
85
    auto helper = trusted_helper.lock();
3315
86
    if (helper) {
3316
87
        helper->end_trust_session();
3317
88
    }
3318
89
3319
90
    std::vector<std::shared_ptr<ms::Session>> children;
3320
91
    {
3321
92
        std::lock_guard<decltype(mutex_children)> child_lock(mutex_children);
3322
93
3323
94
        for (auto rit = trusted_children.rbegin(); rit != trusted_children.rend(); ++rit)
3324
95
        {
3325
96
            auto session = (*rit).lock();
3326
97
            if (session)
3327
98
            {
3328
99
                children.push_back(session);
3329
100
            }
3330
101
        }
3331
102
        trusted_children.clear();
3332
103
    }
3333
104
3334
105
    for (auto session : children)
3335
106
    {
3336
107
        trust_session_listener->trusted_session_ending(*this, *(session).get());
3337
108
    }
3338
109
}
3339
110
3340
111
bool ms::TrustSessionImpl::add_trusted_child(std::shared_ptr<ms::Session> const& session)
3341
112
{
3342
113
    std::lock_guard<decltype(mutex)> lock(mutex);
3343
114
3344
115
    if (state == mir_trust_session_state_stopped)
3345
116
        return false;
3346
117
3347
118
    {
3348
119
        std::lock_guard<decltype(mutex_children)> child_lock(mutex_children);
3349
120
3350
121
        if (std::find_if(trusted_children.begin(), trusted_children.end(),
3351
122
                [session](std::weak_ptr<ms::Session> const& child)
3352
123
                {
3353
124
                    return child.lock() == session;
3354
125
                }) != trusted_children.end())
3355
126
        {
3356
127
            return false;
3357
128
        }
3358
129
3359
130
        trusted_children.push_back(session);
3360
131
    }
3361
132
3362
133
    trust_session_listener->trusted_session_beginning(*this, *(session).get());
3363
134
    return true;
3364
135
}
3365
136
3366
137
void ms::TrustSessionImpl::remove_trusted_child(std::shared_ptr<ms::Session> const& session)
3367
138
{
3368
139
    std::lock_guard<decltype(mutex)> lock(mutex);
3369
140
3370
141
    if (state == mir_trust_session_state_stopped)
3371
142
        return;
3372
143
3373
144
    bool found = false;
3374
145
    {
3375
146
        std::lock_guard<decltype(mutex_children)> child_lock(mutex_children);
3376
147
3377
148
        for (auto it = trusted_children.begin(); it != trusted_children.end(); ++it)
3378
149
        {
3379
150
            auto trusted_child = (*it).lock();
3380
151
            if (trusted_child && trusted_child == session) {
3381
152
                found = true;
3382
153
                trusted_children.erase(it);
3383
154
                break;
3384
155
            }
3385
156
        }
3386
157
    }
3387
158
3388
159
    if (found)
3389
160
    {
3390
161
        trust_session_listener->trusted_session_ending(*this, *(session).get());
3391
162
    }
3392
163
}
3393
164
3394
165
void ms::TrustSessionImpl::for_each_trusted_child(
3395
166
    std::function<void(std::shared_ptr<ms::Session> const&)> f,
3396
167
    bool reverse) const
3397
168
{
3398
169
    std::lock_guard<decltype(mutex_children)> child_lock(mutex_children);
3399
170
3400
171
    if (reverse)
3401
172
    {
3402
173
        for (auto rit = trusted_children.rbegin(); rit != trusted_children.rend(); ++rit)
3403
174
        {
3404
175
            if (auto trusted_child = (*rit).lock())
3405
176
                f(trusted_child);
3406
177
        }
3407
178
    }
3408
179
    else
3409
180
    {
3410
181
        for (auto it = trusted_children.begin(); it != trusted_children.end(); ++it)
3411
182
        {
3412
183
            if (auto trusted_child = (*it).lock())
3413
184
                f(trusted_child);
3414
185
        }
3415
186
    }
3416
187
}
3417
0
188
3418
=== added file 'src/server/scene/trust_session_impl.h'
3419
--- src/server/scene/trust_session_impl.h	1970-01-01 00:00:00 +0000
3420
+++ src/server/scene/trust_session_impl.h	2014-05-09 12:26:43 +0000
3421
@@ -0,0 +1,74 @@
3422
1
/*
3423
2
 * Copyright © 2014 Canonical Ltd.
3424
3
 *
3425
4
 * This program is free software: you can redistribute it and/or modify it
3426
5
 * under the terms of the GNU General Public License version 3,
3427
6
 * as published by the Free Software Foundation.
3428
7
 *
3429
8
 * This program is distributed in the hope that it will be useful,
3430
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3431
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3432
11
 * GNU General Public License for more details.
3433
12
 *
3434
13
 * You should have received a copy of the GNU General Public License
3435
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3436
15
 *
3437
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
3438
17
 */
3439
18
3440
19
#ifndef MIR_SCENE_TRUST_SESSION_IMPL_H_
3441
20
#define MIR_SCENE_TRUST_SESSION_IMPL_H_
3442
21
3443
22
#include "mir/scene/trust_session.h"
3444
23
3445
24
#include <vector>
3446
25
#include <atomic>
3447
26
#include <mutex>
3448
27
3449
28
namespace mir
3450
29
{
3451
30
3452
31
namespace scene
3453
32
{
3454
33
class SessionContainer;
3455
34
class TrustSessionCreationParameters;
3456
35
class TrustSessionListener;
3457
36
3458
37
class TrustSessionImpl : public TrustSession
3459
38
{
3460
39
public:
3461
40
    TrustSessionImpl(std::weak_ptr<Session> const& session,
3462
41
                 TrustSessionCreationParameters const& parameters,
3463
42
                 std::shared_ptr<TrustSessionListener> const& trust_session_listener);
3464
43
    ~TrustSessionImpl();
3465
44
3466
45
    MirTrustSessionState get_state() const override;
3467
46
    std::weak_ptr<Session> get_trusted_helper() const override;
3468
47
3469
48
    void start() override;
3470
49
    void stop() override;
3471
50
3472
51
    bool add_trusted_child(std::shared_ptr<Session> const& session);
3473
52
    void remove_trusted_child(std::shared_ptr<Session> const& session);
3474
53
    void for_each_trusted_child(std::function<void(std::shared_ptr<Session> const&)> f, bool reverse) const;
3475
54
3476
55
protected:
3477
56
    TrustSessionImpl(const TrustSessionImpl&) = delete;
3478
57
    TrustSessionImpl& operator=(const TrustSessionImpl&) = delete;
3479
58
3480
59
private:
3481
60
    std::weak_ptr<Session> const trusted_helper;
3482
61
    std::shared_ptr<TrustSessionListener> const trust_session_listener;
3483
62
    MirTrustSessionState state;
3484
63
    std::string cookie;
3485
64
    std::mutex mutable mutex;
3486
65
3487
66
    std::mutex mutable mutex_children;
3488
67
    std::vector<pid_t> client_processes;
3489
68
    std::vector<std::weak_ptr<Session>> trusted_children;
3490
69
};
3491
70
3492
71
}
3493
72
}
3494
73
3495
74
#endif // MIR_SCENE_TRUST_SESSION_H_
3496
0
75
3497
=== modified file 'src/shared/protobuf/mir_protobuf.proto'
3498
--- src/shared/protobuf/mir_protobuf.proto	2014-05-06 16:54:43 +0000
3499
+++ src/shared/protobuf/mir_protobuf.proto	2014-05-09 12:26:43 +0000
3500
@@ -100,7 +100,7 @@
3501
100
  optional int32 pixel_format = 4;
100
  optional int32 pixel_format = 4;
3502
101
  optional int32 buffer_usage = 5;
101
  optional int32 buffer_usage = 5;
3503
102
  optional Buffer buffer = 6;
102
  optional Buffer buffer = 6;
3505
103
  
103
3506
104
  repeated sint32 fd = 7;
104
  repeated sint32 fd = 7;
3507
105
  optional int32 fds_on_side_channel = 8;
105
  optional int32 fds_on_side_channel = 8;
3508
106
106
3509
@@ -175,18 +175,50 @@
3510
175
  optional string error = 127;
175
  optional string error = 127;
3511
176
}
176
}
3512
177
177
3525
178
message SocketFDRequest {
178
<<<<<<< TREE
3526
179
  required int32 number = 1;
179
message SocketFDRequest {
3527
180
}
180
  required int32 number = 1;
3528
181
181
}
3529
182
182
3530
183
message SocketFD {
183
3531
184
  repeated sint32 fd = 1;
184
message SocketFD {
3532
185
  optional int32  fds_on_side_channel = 2;
185
  repeated sint32 fd = 1;
3533
186
186
  optional int32  fds_on_side_channel = 2;
3534
187
  optional string error = 127;
187
3535
188
}
188
  optional string error = 127;
3536
189
189
}
3537
190
3538
191
=======
3539
192
message SocketFDRequest {
3540
193
  required int32 number = 1;
3541
194
}
3542
195
3543
196
message SocketFD {
3544
197
  repeated sint32 fd = 1;
3545
198
  optional int32  fds_on_side_channel = 2;
3546
199
3547
200
  optional string error = 127;
3548
201
}
3549
202
3550
203
message TrustedSession {
3551
204
  required int32 pid = 1;
3552
205
}
3553
206
3554
207
message TrustSessionParameters {
3555
208
  required TrustedSession base_trusted_session = 1;
3556
209
}
3557
210
3558
211
message TrustSession {
3559
212
  optional uint32 state = 1;
3560
213
  optional string error = 127;
3561
214
}
3562
215
3563
216
message TrustSessionAddResult {
3564
217
  required int32 result = 1;
3565
218
  optional string error = 127;
3566
219
}
3567
220
3568
221
>>>>>>> MERGE-SOURCE
3569
190
service DisplayServer {
222
service DisplayServer {
3570
191
  // Platform independent requests
223
  // Platform independent requests
3571
192
  rpc connect(ConnectParameters) returns (Connection);
224
  rpc connect(ConnectParameters) returns (Connection);
3572
@@ -206,5 +238,13 @@
3573
206
  rpc create_screencast(ScreencastParameters) returns (Screencast);
238
  rpc create_screencast(ScreencastParameters) returns (Screencast);
3574
207
  rpc screencast_buffer(ScreencastId) returns (Buffer);
239
  rpc screencast_buffer(ScreencastId) returns (Buffer);
3575
208
  rpc release_screencast(ScreencastId) returns (Void);
240
  rpc release_screencast(ScreencastId) returns (Void);
3577
209
  rpc new_fds_for_trusted_clients(SocketFDRequest) returns (SocketFD);
241
<<<<<<< TREE
3578
242
  rpc new_fds_for_trusted_clients(SocketFDRequest) returns (SocketFD);
3579
243
=======
3580
244
  rpc new_fds_for_trusted_clients(SocketFDRequest) returns (SocketFD);
3581
245
3582
246
  rpc start_trust_session(TrustSessionParameters) returns (TrustSession);
3583
247
  rpc add_trusted_session(TrustedSession) returns (TrustSessionAddResult);
3584
248
  rpc stop_trust_session(Void) returns (Void);
3585
249
>>>>>>> MERGE-SOURCE
3586
210
}
250
}
3587
211
251
3588
=== modified file 'tests/acceptance-tests/CMakeLists.txt'
3589
--- tests/acceptance-tests/CMakeLists.txt	2014-05-07 14:00:57 +0000
3590
+++ tests/acceptance-tests/CMakeLists.txt	2014-05-09 12:26:43 +0000
3591
@@ -28,6 +28,7 @@
3592
28
  test_surfaces_with_output_id.cpp
28
  test_surfaces_with_output_id.cpp
3593
29
  test_server_disconnect.cpp
29
  test_server_disconnect.cpp
3594
30
  test_client_library_drm.cpp
30
  test_client_library_drm.cpp
3595
31
  test_client_trust_session_api.cpp
3596
31
  test_protobuf.cpp
32
  test_protobuf.cpp
3597
32
  test_client_screencast.cpp
33
  test_client_screencast.cpp
3598
33
  test_client_surface_swap_buffers.cpp
34
  test_client_surface_swap_buffers.cpp
3599
34
35
3600
=== added file 'tests/acceptance-tests/test_client_trust_session_api.cpp'
3601
--- tests/acceptance-tests/test_client_trust_session_api.cpp	1970-01-01 00:00:00 +0000
3602
+++ tests/acceptance-tests/test_client_trust_session_api.cpp	2014-05-09 12:26:43 +0000
3603
@@ -0,0 +1,106 @@
3604
1
/*
3605
2
 * Copyright © 2013 Canonical Ltd.
3606
3
 *
3607
4
 * This program is free software: you can redistribute it and/or modify
3608
5
 * it under the terms of the GNU General Public License version 3 as
3609
6
 * published by the Free Software Foundation.
3610
7
 *
3611
8
 * This program is distributed in the hope that it will be useful,
3612
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3613
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3614
11
 * GNU General Public License for more details.
3615
12
 *
3616
13
 * You should have received a copy of the GNU General Public License
3617
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3618
15
 *
3619
16
 * Authored by: Nick Dedekind <nick.dedekind@canonical.com>
3620
17
 */
3621
18
3622
19
#include "mir_test_framework/display_server_test_fixture.h"
3623
20
3624
21
#include "mir_toolkit/mir_client_library.h"
3625
22
#include "mir_toolkit/mir_trust_session.h"
3626
23
3627
24
#include <gtest/gtest.h>
3628
25
3629
26
namespace mtf = mir_test_framework;
3630
27
3631
28
namespace
3632
29
{
3633
30
    char const* const mir_test_socket = mtf::test_socket_file().c_str();
3634
31
}
3635
32
3636
33
using MirClientTrustSessionAPITest = DefaultDisplayServerTestFixture;
3637
34
3638
35
namespace mir
3639
36
{
3640
37
namespace
3641
38
{
3642
39
struct ClientConfigCommon : TestingClientConfiguration
3643
40
{
3644
41
    ClientConfigCommon()
3645
42
        : connection(0)
3646
43
        , trust_session(0)
3647
44
        , started(0)
3648
45
        , stopped(0)
3649
46
    {
3650
47
    }
3651
48
3652
49
    static void connection_callback(MirConnection * connection, void * context)
3653
50
    {
3654
51
        ClientConfigCommon * config = reinterpret_cast<ClientConfigCommon *>(context);
3655
52
        config->connection = connection;
3656
53
    }
3657
54
3658
55
    virtual void connected(MirConnection * new_connection)
3659
56
    {
3660
57
        connection = new_connection;
3661
58
    }
3662
59
3663
60
    static void trust_session_start_callback(MirTrustSession * session, void * context)
3664
61
    {
3665
62
        ClientConfigCommon * config = reinterpret_cast<ClientConfigCommon *>(context);
3666
63
        config->trust_session = session;
3667
64
        config->started++;
3668
65
    }
3669
66
3670
67
    static void trust_session_stop_callback(MirTrustSession * /* session */, void * context)
3671
68
    {
3672
69
        ClientConfigCommon * config = reinterpret_cast<ClientConfigCommon *>(context);
3673
70
        config->stopped++;
3674
71
    }
3675
72
3676
73
    MirConnection* connection;
3677
74
    MirTrustSession* trust_session;
3678
75
    int started;
3679
76
    int stopped;
3680
77
};
3681
78
}
3682
79
3683
80
TEST_F(MirClientTrustSessionAPITest, client_trust_session_api)
3684
81
{
3685
82
    struct ClientConfig : ClientConfigCommon
3686
83
    {
3687
84
        void exec()
3688
85
        {
3689
86
            mir_wait_for(mir_connect(mir_test_socket, __PRETTY_FUNCTION__, connection_callback, this));
3690
87
3691
88
            ASSERT_TRUE(connection != NULL);
3692
89
            EXPECT_TRUE(mir_connection_is_valid(connection));
3693
90
            EXPECT_STREQ("", mir_connection_get_error_message(connection));
3694
91
3695
92
            mir_wait_for(mir_connection_start_trust_session(connection, __LINE__, trust_session_start_callback, NULL, this));
3696
93
            ASSERT_TRUE(trust_session != NULL);
3697
94
            EXPECT_EQ(started, 1);
3698
95
3699
96
            mir_wait_for(mir_trust_session_stop(trust_session, trust_session_stop_callback, this));
3700
97
            EXPECT_EQ(stopped, 1);
3701
98
3702
99
            mir_connection_release(connection);
3703
100
        }
3704
101
    } client_config;
3705
102
3706
103
    launch_client_process(client_config);
3707
104
}
3708
105
3709
106
}
3710
0
107
3711
=== modified file 'tests/acceptance-tests/test_nested_mir.cpp'
3712
--- tests/acceptance-tests/test_nested_mir.cpp	2014-03-06 06:05:17 +0000
3713
+++ tests/acceptance-tests/test_nested_mir.cpp	2014-05-09 12:26:43 +0000
3714
@@ -56,6 +56,9 @@
3715
56
    MOCK_METHOD1(session_next_buffer_called, void (std::string const&));
56
    MOCK_METHOD1(session_next_buffer_called, void (std::string const&));
3716
57
    MOCK_METHOD1(session_release_surface_called, void (std::string const&));
57
    MOCK_METHOD1(session_release_surface_called, void (std::string const&));
3717
58
    MOCK_METHOD1(session_disconnect_called, void (std::string const&));
58
    MOCK_METHOD1(session_disconnect_called, void (std::string const&));
3718
59
    MOCK_METHOD2(session_start_trust_session_called, void (std::string const&, std::string const&));
3719
60
    MOCK_METHOD2(session_add_trusted_session_called, void (std::string const&, std::string const&));
3720
61
    MOCK_METHOD1(session_stop_trust_session_called, void (std::string const&));
3721
59
62
3722
60
    void session_drm_auth_magic_called(const std::string&) override {};
63
    void session_drm_auth_magic_called(const std::string&) override {};
3723
61
    void session_configure_surface_called(std::string const&) override {};
64
    void session_configure_surface_called(std::string const&) override {};
3724
62
65
3725
=== modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
3726
--- tests/acceptance-tests/test_server_shutdown.cpp	2014-05-09 03:00:20 +0000
3727
+++ tests/acceptance-tests/test_server_shutdown.cpp	2014-05-09 12:26:43 +0000
3728
@@ -117,6 +117,7 @@
3729
117
    std::string const flag_file;
117
    std::string const flag_file;
3730
118
};
118
};
3731
119
119
3732
120
<<<<<<< TREE
3733
120
struct FakeEventHubServerConfig : TestingServerConfiguration
121
struct FakeEventHubServerConfig : TestingServerConfiguration
3734
121
{
122
{
3735
122
    std::shared_ptr<mi::InputConfiguration> the_input_configuration() override
123
    std::shared_ptr<mi::InputConfiguration> the_input_configuration() override
3736
@@ -157,6 +158,48 @@
3737
157
    std::shared_ptr<mtd::FakeEventHubInputConfiguration> input_configuration;
158
    std::shared_ptr<mtd::FakeEventHubInputConfiguration> input_configuration;
3738
158
};
159
};
3739
159
160
3740
161
=======
3741
162
struct FakeEventHubServerConfig : TestingServerConfiguration
3742
163
{
3743
164
    std::shared_ptr<mi::InputConfiguration> the_input_configuration() override
3744
165
    {
3745
166
        if (!input_configuration)
3746
167
        {
3747
168
            input_configuration =
3748
169
                std::make_shared<mtd::FakeEventHubInputConfiguration>(
3749
170
                    the_composite_event_filter(),
3750
171
                    the_input_region(),
3751
172
                    std::shared_ptr<mi::CursorListener>(),
3752
173
                    the_input_report());
3753
174
        }
3754
175
3755
176
        return input_configuration;
3756
177
    }
3757
178
3758
179
    std::shared_ptr<mi::InputManager> the_input_manager() override
3759
180
    {
3760
181
        return DefaultServerConfiguration::the_input_manager();
3761
182
    }
3762
183
3763
184
    std::shared_ptr<mir::shell::InputTargeter> the_input_targeter() override
3764
185
    {
3765
186
        return DefaultServerConfiguration::the_input_targeter();
3766
187
    }
3767
188
    std::shared_ptr<mir::scene::InputRegistrar> the_input_registrar() override
3768
189
    {
3769
190
        return DefaultServerConfiguration::the_input_registrar();
3770
191
    }
3771
192
3772
193
    mia::FakeEventHub* the_fake_event_hub()
3773
194
    {
3774
195
        the_input_configuration();
3775
196
        return input_configuration->the_fake_event_hub();
3776
197
    }
3777
198
3778
199
    std::shared_ptr<mtd::FakeEventHubInputConfiguration> input_configuration;
3779
200
};
3780
201
3781
202
>>>>>>> MERGE-SOURCE
3782
160
}
203
}
3783
161
204
3784
162
using ServerShutdown = BespokeDisplayServerTestFixture;
205
using ServerShutdown = BespokeDisplayServerTestFixture;
3785
163
206
3786
=== modified file 'tests/integration-tests/frontend/test_application_mediator_report.cpp'
3787
--- tests/integration-tests/frontend/test_application_mediator_report.cpp	2014-03-06 06:05:17 +0000
3788
+++ tests/integration-tests/frontend/test_application_mediator_report.cpp	2014-05-09 12:26:43 +0000
3789
@@ -50,6 +50,12 @@
3790
50
50
3791
51
        EXPECT_CALL(*this, session_disconnect_called(testing::_)).
51
        EXPECT_CALL(*this, session_disconnect_called(testing::_)).
3792
52
            Times(testing::AtLeast(0));
52
            Times(testing::AtLeast(0));
3793
53
3794
54
        EXPECT_CALL(*this, session_start_trust_session_called(testing::_, testing::_)).
3795
55
            Times(testing::AtLeast(0));
3796
56
3797
57
        EXPECT_CALL(*this, session_stop_trust_session_called(testing::_)).
3798
58
            Times(testing::AtLeast(0));
3799
53
    }
59
    }
3800
54
60
3801
55
    MOCK_METHOD1(session_connect_called, void (std::string const&));
61
    MOCK_METHOD1(session_connect_called, void (std::string const&));
3802
@@ -57,6 +63,9 @@
3803
57
    MOCK_METHOD1(session_next_buffer_called, void (std::string const&));
63
    MOCK_METHOD1(session_next_buffer_called, void (std::string const&));
3804
58
    MOCK_METHOD1(session_release_surface_called, void (std::string const&));
64
    MOCK_METHOD1(session_release_surface_called, void (std::string const&));
3805
59
    MOCK_METHOD1(session_disconnect_called, void (std::string const&));
65
    MOCK_METHOD1(session_disconnect_called, void (std::string const&));
3806
66
    MOCK_METHOD2(session_start_trust_session_called, void (std::string const&, std::string const&));
3807
67
    MOCK_METHOD2(session_add_trusted_session_called, void (std::string const&, std::string const&));
3808
68
    MOCK_METHOD1(session_stop_trust_session_called, void (std::string const&));
3809
60
69
3810
61
    void session_drm_auth_magic_called(const std::string&) override {};
70
    void session_drm_auth_magic_called(const std::string&) override {};
3811
62
    void session_configure_surface_called(std::string const&) override {};
71
    void session_configure_surface_called(std::string const&) override {};
3812
@@ -358,3 +367,175 @@
3813
358
367
3814
359
    launch_client_process(client_process);
368
    launch_client_process(client_process);
3815
360
}
369
}
3816
370
3817
371
TEST_F(ApplicationMediatorReport, trust_session_start_called)
3818
372
{
3819
373
    struct Server : TestingServerConfiguration
3820
374
    {
3821
375
        std::shared_ptr<mf::SessionMediatorReport>
3822
376
        the_application_mediator_report()
3823
377
        {
3824
378
            auto result = std::make_shared<MockApplicationMediatorReport>();
3825
379
3826
380
            EXPECT_CALL(*result, session_start_trust_session_called(testing::_, testing::_)).
3827
381
                Times(1);
3828
382
3829
383
            return result;
3830
384
        }
3831
385
    } server_processing;
3832
386
3833
387
    launch_server_process(server_processing);
3834
388
3835
389
    struct Client: TestingClientConfiguration
3836
390
    {
3837
391
        void exec()
3838
392
        {
3839
393
            mt::TestProtobufClient client(mtf::test_socket_file(), rpc_timeout_ms);
3840
394
3841
395
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
3842
396
            EXPECT_CALL(client, connect_done()).
3843
397
                Times(testing::AtLeast(0));
3844
398
            EXPECT_CALL(client, trust_session_start_done()).
3845
399
                Times(testing::AtLeast(0));
3846
400
3847
401
            client.display_server.connect(
3848
402
                0,
3849
403
                &client.connect_parameters,
3850
404
                &client.connection,
3851
405
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::connect_done));
3852
406
3853
407
            client.wait_for_connect_done();
3854
408
3855
409
            client.display_server.start_trust_session(
3856
410
                0,
3857
411
                &client.trust_session_parameters,
3858
412
                &client.trust_session,
3859
413
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::trust_session_start_done));
3860
414
            client.wait_for_trust_session_start_done();
3861
415
3862
416
        }
3863
417
    } client_process;
3864
418
3865
419
    launch_client_process(client_process);
3866
420
}
3867
421
3868
422
TEST_F(ApplicationMediatorReport, trust_session_add_trusted_session_called)
3869
423
{
3870
424
    struct Server : TestingServerConfiguration
3871
425
    {
3872
426
        std::shared_ptr<mf::SessionMediatorReport>
3873
427
        the_application_mediator_report()
3874
428
        {
3875
429
            auto result = std::make_shared<MockApplicationMediatorReport>();
3876
430
3877
431
            EXPECT_CALL(*result, session_start_trust_session_called(testing::_, testing::_)).
3878
432
                Times(1);
3879
433
3880
434
            return result;
3881
435
        }
3882
436
    } server_processing;
3883
437
3884
438
    launch_server_process(server_processing);
3885
439
3886
440
    struct Client: TestingClientConfiguration
3887
441
    {
3888
442
        void exec()
3889
443
        {
3890
444
            mt::TestProtobufClient client(mtf::test_socket_file(), rpc_timeout_ms);
3891
445
3892
446
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
3893
447
            EXPECT_CALL(client, connect_done()).
3894
448
                Times(testing::AtLeast(0));
3895
449
            EXPECT_CALL(client, trust_session_start_done()).
3896
450
                Times(testing::AtLeast(0));
3897
451
            EXPECT_CALL(client, trust_session_add_trusted_session_done()).
3898
452
                Times(testing::AtLeast(0));
3899
453
3900
454
            client.display_server.connect(
3901
455
                0,
3902
456
                &client.connect_parameters,
3903
457
                &client.connection,
3904
458
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::connect_done));
3905
459
3906
460
            client.wait_for_connect_done();
3907
461
3908
462
            client.display_server.start_trust_session(
3909
463
                0,
3910
464
                &client.trust_session_parameters,
3911
465
                &client.trust_session,
3912
466
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::trust_session_start_done));
3913
467
            client.wait_for_trust_session_start_done();
3914
468
3915
469
            client.display_server.add_trusted_session(
3916
470
                0,
3917
471
                &client.trusted_session,
3918
472
                &client.add_trust_result,
3919
473
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::trust_session_add_trusted_session_done));
3920
474
            client.wait_for_trust_session_add_trusted_session_done();
3921
475
3922
476
        }
3923
477
    } client_process;
3924
478
3925
479
    launch_client_process(client_process);
3926
480
}
3927
481
3928
482
TEST_F(ApplicationMediatorReport, trust_session_stop_called)
3929
483
{
3930
484
    struct Server : TestingServerConfiguration
3931
485
    {
3932
486
        std::shared_ptr<mf::SessionMediatorReport>
3933
487
        the_application_mediator_report()
3934
488
        {
3935
489
            auto result = std::make_shared<MockApplicationMediatorReport>();
3936
490
3937
491
            EXPECT_CALL(*result, session_stop_trust_session_called(testing::_)).
3938
492
                Times(1);
3939
493
3940
494
            return result;
3941
495
        }
3942
496
    } server_processing;
3943
497
3944
498
    launch_server_process(server_processing);
3945
499
3946
500
    struct Client: TestingClientConfiguration
3947
501
    {
3948
502
        void exec()
3949
503
        {
3950
504
            mt::TestProtobufClient client(mtf::test_socket_file(), rpc_timeout_ms);
3951
505
3952
506
            client.connect_parameters.set_application_name(__PRETTY_FUNCTION__);
3953
507
            EXPECT_CALL(client, connect_done()).
3954
508
                Times(testing::AtLeast(0));
3955
509
            EXPECT_CALL(client, trust_session_start_done()).
3956
510
                Times(testing::AtLeast(0));
3957
511
            EXPECT_CALL(client, trust_session_stop_done()).
3958
512
                Times(testing::AtLeast(0));
3959
513
3960
514
            client.display_server.connect(
3961
515
                0,
3962
516
                &client.connect_parameters,
3963
517
                &client.connection,
3964
518
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::connect_done));
3965
519
3966
520
            client.wait_for_connect_done();
3967
521
3968
522
            client.display_server.start_trust_session(
3969
523
                0,
3970
524
                &client.trust_session_parameters,
3971
525
                &client.trust_session,
3972
526
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::trust_session_start_done));
3973
527
            client.wait_for_trust_session_start_done();
3974
528
3975
529
            client.display_server.stop_trust_session(
3976
530
                0,
3977
531
                &client.ignored,
3978
532
                &client.ignored,
3979
533
                google::protobuf::NewCallback(&client, &mt::TestProtobufClient::trust_session_stop_done));
3980
534
            client.wait_for_trust_session_stop_done();
3981
535
        }
3982
536
    } client_process;
3983
537
3984
538
    launch_client_process(client_process);
3985
539
}
3986
540
3987
541
3988
361
542
3989
=== modified file 'tests/integration-tests/test_display_server_main_loop_events.cpp'
3990
=== modified file 'tests/integration-tests/test_session_manager.cpp'
3991
--- tests/integration-tests/test_session_manager.cpp	2014-04-15 05:31:19 +0000
3992
+++ tests/integration-tests/test_session_manager.cpp	2014-05-09 12:26:43 +0000
3993
@@ -24,6 +24,7 @@
3994
24
#include "mir/compositor/buffer_stream.h"
24
#include "mir/compositor/buffer_stream.h"
3995
25
#include "src/server/scene/basic_surface.h"
25
#include "src/server/scene/basic_surface.h"
3996
26
#include "mir/scene/surface_creation_parameters.h"
26
#include "mir/scene/surface_creation_parameters.h"
3997
27
#include "mir/scene/null_trust_session_listener.h"
3998
27
28
3999
28
#include "mir_test/gmock_fixes.h"
29
#include "mir_test/gmock_fixes.h"
4000
29
#include "mir_test/fake_shared.h"
30
#include "mir_test/fake_shared.h"
4001
@@ -55,7 +56,8 @@
4002
55
              mt::fake_shared(focus_setter),
56
              mt::fake_shared(focus_setter),
4003
56
              std::make_shared<mtd::NullSnapshotStrategy>(),
57
              std::make_shared<mtd::NullSnapshotStrategy>(),
4004
57
              std::make_shared<mtd::NullSessionEventSink>(),
58
              std::make_shared<mtd::NullSessionEventSink>(),
4006
58
              mt::fake_shared(session_listener))
59
              mt::fake_shared(session_listener),
4007
60
              std::make_shared<ms::NullTrustSessionListener>())
4008
59
    {
61
    {
4009
60
62
4010
61
    }
63
    }
4011
62
64
4012
=== modified file 'tests/mir_test_doubles/test_protobuf_client.cpp'
4013
--- tests/mir_test_doubles/test_protobuf_client.cpp	2014-03-06 06:05:17 +0000
4014
+++ tests/mir_test_doubles/test_protobuf_client.cpp	2014-05-09 12:26:43 +0000
4015
@@ -22,6 +22,7 @@
4016
22
#include "src/client/connection_surface_map.h"
22
#include "src/client/connection_surface_map.h"
4017
23
#include "src/client/display_configuration.h"
23
#include "src/client/display_configuration.h"
4018
24
#include "src/client/lifecycle_control.h"
24
#include "src/client/lifecycle_control.h"
4019
25
#include "src/client/event_distributor.h"
4020
25
#include "src/client/rpc/make_rpc_channel.h"
26
#include "src/client/rpc/make_rpc_channel.h"
4021
26
#include "src/client/rpc/mir_basic_rpc_channel.h"
27
#include "src/client/rpc/mir_basic_rpc_channel.h"
4022
27
28
4023
@@ -38,7 +39,8 @@
4024
38
        std::make_shared<mir::client::ConnectionSurfaceMap>(),
39
        std::make_shared<mir::client::ConnectionSurfaceMap>(),
4025
39
        std::make_shared<mir::client::DisplayConfiguration>(),
40
        std::make_shared<mir::client::DisplayConfiguration>(),
4026
40
        rpc_report,
41
        rpc_report,
4028
41
        std::make_shared<mir::client::LifecycleControl>())),
42
        std::make_shared<mir::client::LifecycleControl>(),
4029
43
        std::make_shared<mir::client::EventDistributor>())),
4030
42
    display_server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
44
    display_server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
4031
43
    maxwait(timeout_ms),
45
    maxwait(timeout_ms),
4032
44
    connect_done_called(false),
46
    connect_done_called(false),
4033
@@ -59,6 +61,9 @@
4034
59
    surface_parameters.set_buffer_usage(0);
61
    surface_parameters.set_buffer_usage(0);
4035
60
    surface_parameters.set_output_id(mir_display_output_id_invalid);
62
    surface_parameters.set_output_id(mir_display_output_id_invalid);
4036
61
63
4037
64
    trusted_session.set_pid(__LINE__);
4038
65
    trust_session_parameters.mutable_base_trusted_session()->set_pid(__LINE__);
4039
66
4040
62
    ON_CALL(*this, connect_done())
67
    ON_CALL(*this, connect_done())
4041
63
        .WillByDefault(testing::Invoke(this, &TestProtobufClient::on_connect_done));
68
        .WillByDefault(testing::Invoke(this, &TestProtobufClient::on_connect_done));
4042
64
    ON_CALL(*this, create_surface_done())
69
    ON_CALL(*this, create_surface_done())
4043
@@ -73,6 +78,12 @@
4044
73
        .WillByDefault(testing::Invoke(this, &TestProtobufClient::on_drm_auth_magic_done));
78
        .WillByDefault(testing::Invoke(this, &TestProtobufClient::on_drm_auth_magic_done));
4045
74
    ON_CALL(*this, display_configure_done())
79
    ON_CALL(*this, display_configure_done())
4046
75
        .WillByDefault(testing::Invoke(this, &TestProtobufClient::on_configure_display_done));
80
        .WillByDefault(testing::Invoke(this, &TestProtobufClient::on_configure_display_done));
4047
81
    ON_CALL(*this, trust_session_start_done())
4048
82
        .WillByDefault(testing::Invoke(&wc_trust_session_start, &WaitCondition::wake_up_everyone));
4049
83
    ON_CALL(*this, trust_session_add_trusted_session_done())
4050
84
        .WillByDefault(testing::Invoke(&wc_trust_session_add, &WaitCondition::wake_up_everyone));
4051
85
    ON_CALL(*this, trust_session_stop_done())
4052
86
        .WillByDefault(testing::Invoke(&wc_trust_session_stop, &WaitCondition::wake_up_everyone));
4053
76
}
87
}
4054
77
88
4055
78
void mir::test::TestProtobufClient::on_connect_done()
89
void mir::test::TestProtobufClient::on_connect_done()
4056
@@ -225,3 +236,18 @@
4057
225
    }
236
    }
4058
226
    tfd_done_called.store(false);
237
    tfd_done_called.store(false);
4059
227
}
238
}
4060
239
4061
240
void mir::test::TestProtobufClient::wait_for_trust_session_start_done()
4062
241
{
4063
242
    wc_trust_session_start.wait_for_at_most_seconds(maxwait);
4064
243
}
4065
244
4066
245
void mir::test::TestProtobufClient::wait_for_trust_session_add_trusted_session_done()
4067
246
{
4068
247
    wc_trust_session_add.wait_for_at_most_seconds(maxwait);
4069
248
}
4070
249
4071
250
void mir::test::TestProtobufClient::wait_for_trust_session_stop_done()
4072
251
{
4073
252
    wc_trust_session_stop.wait_for_at_most_seconds(maxwait);
4074
253
}
4075
228
254
4076
=== modified file 'tests/unit-tests/client/CMakeLists.txt'
4077
--- tests/unit-tests/client/CMakeLists.txt	2014-03-06 06:05:17 +0000
4078
+++ tests/unit-tests/client/CMakeLists.txt	2014-05-09 12:26:43 +0000
4079
@@ -8,6 +8,7 @@
4080
8
  ${CMAKE_CURRENT_SOURCE_DIR}/test_wait_handle.cpp
8
  ${CMAKE_CURRENT_SOURCE_DIR}/test_wait_handle.cpp
4081
9
  ${CMAKE_CURRENT_SOURCE_DIR}/test_client_display_conf.cpp
9
  ${CMAKE_CURRENT_SOURCE_DIR}/test_client_display_conf.cpp
4082
10
  ${CMAKE_CURRENT_SOURCE_DIR}/test_mir_screencast.cpp
10
  ${CMAKE_CURRENT_SOURCE_DIR}/test_mir_screencast.cpp
4083
11
  ${CMAKE_CURRENT_SOURCE_DIR}/test_mir_trust_session.cpp
4084
11
)
12
)
4085
12
13
4086
13
if(MIR_TEST_PLATFORM STREQUAL "android")
14
if(MIR_TEST_PLATFORM STREQUAL "android")
4087
14
15
4088
=== added file 'tests/unit-tests/client/test_mir_trust_session.cpp'
4089
--- tests/unit-tests/client/test_mir_trust_session.cpp	1970-01-01 00:00:00 +0000
4090
+++ tests/unit-tests/client/test_mir_trust_session.cpp	2014-05-09 12:26:43 +0000
4091
@@ -0,0 +1,244 @@
4092
1
/*
4093
2
 * Copyright © 2014 Canonical Ltd.
4094
3
 *
4095
4
 * This program is free software: you can redistribute it and/or modify it
4096
5
 * under the terms of the GNU General Public License version 3,
4097
6
 * as published by the Free Software Foundation.
4098
7
 *
4099
8
 * This program is distributed in the hope that it will be useful,
4100
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4101
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4102
11
 * GNU General Public License for more details.
4103
12
 *
4104
13
 * You should have received a copy of the GNU General Public License
4105
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4106
15
 *
4107
16
 * Authored by: Nick Dedekind <nick.dedekind <nick.dedekind@canonical.com>
4108
17
 */
4109
18
4110
19
#include "src/client/mir_trust_session.h"
4111
20
#include "src/client/event_distributor.h"
4112
21
4113
22
#include <gtest/gtest.h>
4114
23
#include <gmock/gmock.h>
4115
24
4116
25
#include <thread>
4117
26
4118
27
namespace mcl = mir::client;
4119
28
4120
29
namespace google
4121
30
{
4122
31
namespace protobuf
4123
32
{
4124
33
class RpcController;
4125
34
}
4126
35
}
4127
36
4128
37
namespace
4129
38
{
4130
39
4131
40
struct MockProtobufServer : mir::protobuf::DisplayServer
4132
41
{
4133
42
4134
43
    MOCK_METHOD4(start_trust_session,
4135
44
                 void(::google::protobuf::RpcController* /*controller*/,
4136
45
                      ::mir::protobuf::TrustSessionParameters const* /*request*/,
4137
46
                      ::mir::protobuf::TrustSession* /*response*/,
4138
47
                      ::google::protobuf::Closure* /*done*/));
4139
48
4140
49
    MOCK_METHOD4(add_trusted_session,
4141
50
                 void(::google::protobuf::RpcController* /*controller*/,
4142
51
                      const ::mir::protobuf::TrustedSession* /*request*/,
4143
52
                      ::mir::protobuf::TrustSessionAddResult* /*response*/,
4144
53
                      ::google::protobuf::Closure* /*done*/));
4145
54
4146
55
    MOCK_METHOD4(stop_trust_session,
4147
56
                 void(::google::protobuf::RpcController* /*controller*/,
4148
57
                      ::mir::protobuf::Void const* /*request*/,
4149
58
                      ::mir::protobuf::Void* /*response*/,
4150
59
                      ::google::protobuf::Closure* /*done*/));
4151
60
};
4152
61
4153
62
class StubProtobufServer : public mir::protobuf::DisplayServer
4154
63
{
4155
64
public:
4156
65
    void start_trust_session(::google::protobuf::RpcController* /*controller*/,
4157
66
                             ::mir::protobuf::TrustSessionParameters const* /*request*/,
4158
67
                             ::mir::protobuf::TrustSession* response,
4159
68
                             ::google::protobuf::Closure* done) override
4160
69
    {
4161
70
        if (server_thread.joinable())
4162
71
            server_thread.join();
4163
72
        server_thread = std::thread{
4164
73
            [response, done, this]
4165
74
            {
4166
75
                response->clear_error();
4167
76
                done->Run();
4168
77
            }};
4169
78
    }
4170
79
4171
80
    void add_trusted_session(::google::protobuf::RpcController* /*controller*/,
4172
81
                             const ::mir::protobuf::TrustedSession* /*request*/,
4173
82
                             ::mir::protobuf::TrustSessionAddResult* /*response*/,
4174
83
                             ::google::protobuf::Closure* done)
4175
84
    {
4176
85
        if (server_thread.joinable())
4177
86
            server_thread.join();
4178
87
        server_thread = std::thread{[done, this] { done->Run(); }};
4179
88
    }
4180
89
4181
90
    void stop_trust_session(::google::protobuf::RpcController* /*controller*/,
4182
91
                            mir::protobuf::Void const* /*request*/,
4183
92
                            ::mir::protobuf::Void* /*response*/,
4184
93
                            ::google::protobuf::Closure* done) override
4185
94
    {
4186
95
        if (server_thread.joinable())
4187
96
            server_thread.join();
4188
97
        server_thread = std::thread{[done, this] { done->Run(); }};
4189
98
    }
4190
99
4191
100
    StubProtobufServer()
4192
101
    {
4193
102
    }
4194
103
4195
104
    ~StubProtobufServer()
4196
105
    {
4197
106
        if (server_thread.joinable())
4198
107
            server_thread.join();
4199
108
    }
4200
109
4201
110
private:
4202
111
    std::thread server_thread;
4203
112
};
4204
113
4205
114
class MirTrustSessionTest : public testing::Test
4206
115
{
4207
116
public:
4208
117
    MirTrustSessionTest()
4209
118
        : event_distributor{std::make_shared<mcl::EventDistributor>()}
4210
119
    {
4211
120
    }
4212
121
4213
122
    static void trust_session_event(MirTrustSession*, MirTrustSessionState new_state, void* context)
4214
123
    {
4215
124
        MirTrustSessionTest* test = static_cast<MirTrustSessionTest*>(context);
4216
125
        test->state_updated(new_state);
4217
126
    }
4218
127
4219
128
    MOCK_METHOD1(state_updated, void(MirTrustSessionState));
4220
129
4221
130
    testing::NiceMock<MockProtobufServer> mock_server;
4222
131
    StubProtobufServer stub_server;
4223
132
    std::shared_ptr<mcl::EventDistributor> event_distributor;
4224
133
};
4225
134
4226
135
struct MockCallback
4227
136
{
4228
137
    MOCK_METHOD2(call, void(void*, void*));
4229
138
};
4230
139
4231
140
void mock_callback_func(MirTrustSession* trust_session, void* context)
4232
141
{
4233
142
    auto mock_cb = static_cast<MockCallback*>(context);
4234
143
    mock_cb->call(trust_session, context);
4235
144
}
4236
145
4237
146
void null_callback_func(MirTrustSession*, void*)
4238
147
{
4239
148
}
4240
149
4241
150
ACTION(RunClosure)
4242
151
{
4243
152
    arg3->Run();
4244
153
}
4245
154
4246
155
}
4247
156
4248
157
TEST_F(MirTrustSessionTest, start_trust_session)
4249
158
{
4250
159
    using namespace testing;
4251
160
4252
161
    EXPECT_CALL(mock_server,
4253
162
                start_trust_session(_,_,_,_))
4254
163
        .WillOnce(RunClosure());
4255
164
4256
165
    MirTrustSession trust_session{
4257
166
        mock_server,
4258
167
        event_distributor};
4259
168
    trust_session.start(__LINE__, null_callback_func, nullptr);
4260
169
}
4261
170
4262
171
TEST_F(MirTrustSessionTest, stop_trust_session)
4263
172
{
4264
173
    using namespace testing;
4265
174
4266
175
    EXPECT_CALL(mock_server,
4267
176
                stop_trust_session(_,_,_,_))
4268
177
        .WillOnce(RunClosure());
4269
178
4270
179
    MirTrustSession trust_session{
4271
180
        mock_server,
4272
181
        event_distributor};
4273
182
    trust_session.stop(null_callback_func, nullptr);
4274
183
}
4275
184
4276
185
TEST_F(MirTrustSessionTest, executes_callback_on_start)
4277
186
{
4278
187
    using namespace testing;
4279
188
4280
189
    MockCallback mock_cb;
4281
190
    EXPECT_CALL(mock_cb, call(_, &mock_cb));
4282
191
4283
192
    MirTrustSession trust_session{
4284
193
        stub_server,
4285
194
        event_distributor};
4286
195
    trust_session.start(__LINE__, mock_callback_func, &mock_cb)->wait_for_all();
4287
196
}
4288
197
4289
198
TEST_F(MirTrustSessionTest, executes_callback_on_stop)
4290
199
{
4291
200
    using namespace testing;
4292
201
4293
202
    MockCallback mock_cb;
4294
203
    EXPECT_CALL(mock_cb, call(_, &mock_cb));
4295
204
4296
205
    MirTrustSession trust_session{
4297
206
        stub_server,
4298
207
        event_distributor};
4299
208
    trust_session.stop(mock_callback_func, &mock_cb)->wait_for_all();
4300
209
}
4301
210
4302
211
TEST_F(MirTrustSessionTest, state_change_event_handler_started)
4303
212
{
4304
213
    using namespace testing;
4305
214
4306
215
    MirTrustSession trust_session{
4307
216
        mock_server,
4308
217
        event_distributor};
4309
218
    trust_session.register_trust_session_event_callback(&MirTrustSessionTest::trust_session_event, this);
4310
219
4311
220
    EXPECT_CALL(*this, state_updated(mir_trust_session_state_started)).Times(1);
4312
221
4313
222
    MirEvent e;
4314
223
    e.type = mir_event_type_trust_session_state_change;
4315
224
    e.trust_session.new_state = mir_trust_session_state_started;
4316
225
    event_distributor->handle_event(e);
4317
226
}
4318
227
4319
228
TEST_F(MirTrustSessionTest, state_change_event_handler_stopped)
4320
229
{
4321
230
    using namespace testing;
4322
231
4323
232
    MirTrustSession trust_session{
4324
233
        mock_server,
4325
234
        event_distributor};
4326
235
    trust_session.register_trust_session_event_callback(&MirTrustSessionTest::trust_session_event, this);
4327
236
4328
237
    EXPECT_CALL(*this, state_updated(mir_trust_session_state_stopped)).Times(1);
4329
238
4330
239
    MirEvent e;
4331
240
    e.type = mir_event_type_trust_session_state_change;
4332
241
    e.trust_session.new_state = mir_trust_session_state_stopped;
4333
242
    event_distributor->handle_event(e);
4334
243
}
4335
244
4336
0
245
4337
=== modified file 'tests/unit-tests/frontend/stress_protobuf_communicator.cpp'
4338
--- tests/unit-tests/frontend/stress_protobuf_communicator.cpp	2014-03-06 06:05:17 +0000
4339
+++ tests/unit-tests/frontend/stress_protobuf_communicator.cpp	2014-05-09 12:26:43 +0000
4340
@@ -28,6 +28,7 @@
4341
28
#include "src/client/connection_surface_map.h"
28
#include "src/client/connection_surface_map.h"
4342
29
#include "src/client/display_configuration.h"
29
#include "src/client/display_configuration.h"
4343
30
#include "src/client/lifecycle_control.h"
30
#include "src/client/lifecycle_control.h"
4344
31
#include "src/client/event_distributor.h"
4345
31
#include "src/client/rpc/null_rpc_report.h"
32
#include "src/client/rpc/null_rpc_report.h"
4346
32
#include "src/client/rpc/make_rpc_channel.h"
33
#include "src/client/rpc/make_rpc_channel.h"
4347
33
#include "src/client/rpc/mir_basic_rpc_channel.h"
34
#include "src/client/rpc/mir_basic_rpc_channel.h"
4348
@@ -178,7 +179,8 @@
4349
178
        std::make_shared<mir::client::ConnectionSurfaceMap>(),
179
        std::make_shared<mir::client::ConnectionSurfaceMap>(),
4350
179
        std::make_shared<mir::client::DisplayConfiguration>(),
180
        std::make_shared<mir::client::DisplayConfiguration>(),
4351
180
        rpc_report,
181
        rpc_report,
4353
181
        std::make_shared<mir::client::LifecycleControl>())),
182
        std::make_shared<mir::client::LifecycleControl>(),
4354
183
        std::make_shared<mir::client::EventDistributor>())),
4355
182
    display_server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
184
    display_server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
4356
183
    maxwait(timeout_ms),
185
    maxwait(timeout_ms),
4357
184
    connect_done_called(false),
186
    connect_done_called(false),
4358
185
187
4359
=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
4360
--- tests/unit-tests/frontend/test_session_mediator.cpp	2014-05-09 11:01:53 +0000
4361
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2014-05-09 12:26:43 +0000
4362
@@ -713,6 +713,7 @@
4363
713
    EXPECT_EQ(stub_buffer.id().as_uint32_t(),
713
    EXPECT_EQ(stub_buffer.id().as_uint32_t(),
4364
714
              protobuf_buffer.buffer_id());
714
              protobuf_buffer.buffer_id());
4365
715
}
715
}
4366
716
<<<<<<< TREE
4367
716
717
4368
717
TEST_F(SessionMediatorTest, client_socket_fd_calls_connector_client_socket_fd)
718
TEST_F(SessionMediatorTest, client_socket_fd_calls_connector_client_socket_fd)
4369
718
{
719
{
4370
@@ -762,3 +763,54 @@
4371
762
763
4372
763
    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
764
    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
4373
764
}
765
}
4374
766
=======
4375
767
4376
768
TEST_F(SessionMediatorTest, client_socket_fd_calls_connector_client_socket_fd)
4377
769
{
4378
770
    const int fd_count = 1;
4379
771
    const int dummy_fd = __LINE__;
4380
772
4381
773
    mp::ConnectParameters connect_parameters;
4382
774
    mp::Connection connection;
4383
775
4384
776
    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
4385
777
4386
778
    ::mir::protobuf::SocketFDRequest request;
4387
779
    ::mir::protobuf::SocketFD response;
4388
780
    request.set_number(1);
4389
781
4390
782
    using namespace ::testing;
4391
783
4392
784
    EXPECT_CALL(connector, client_socket_fd(_)).Times(1).WillOnce(Return(dummy_fd));
4393
785
    mediator.new_fds_for_trusted_clients(nullptr, &request, &response, null_callback.get());
4394
786
4395
787
    EXPECT_THAT(response.fd_size(), Eq(fd_count));
4396
788
    EXPECT_THAT(response.fd(0), Eq(dummy_fd));
4397
789
4398
790
    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
4399
791
}
4400
792
4401
793
TEST_F(SessionMediatorTest, client_socket_fd_allocates_requested_number_of_fds)
4402
794
{
4403
795
    const int fd_count = 11;
4404
796
    const int dummy_fd = __LINE__;
4405
797
4406
798
    mp::ConnectParameters connect_parameters;
4407
799
    mp::Connection connection;
4408
800
4409
801
    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
4410
802
4411
803
    ::mir::protobuf::SocketFDRequest request;
4412
804
    ::mir::protobuf::SocketFD response;
4413
805
    request.set_number(fd_count);
4414
806
4415
807
    using namespace ::testing;
4416
808
4417
809
    EXPECT_CALL(connector, client_socket_fd(_)).Times(fd_count).WillRepeatedly(Return(dummy_fd));
4418
810
    mediator.new_fds_for_trusted_clients(nullptr, &request, &response, null_callback.get());
4419
811
4420
812
    EXPECT_THAT(response.fd_size(), Eq(fd_count));
4421
813
4422
814
    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
4423
815
}
4424
816
>>>>>>> MERGE-SOURCE
4425
765
817
4426
=== added file 'tests/unit-tests/graphics/mesa/test_drm_helper.cpp.moved'
4427
--- tests/unit-tests/graphics/mesa/test_drm_helper.cpp.moved	1970-01-01 00:00:00 +0000
4428
+++ tests/unit-tests/graphics/mesa/test_drm_helper.cpp.moved	2014-05-09 12:26:43 +0000
4429
@@ -0,0 +1,65 @@
4430
1
/*
4431
2
 * Copyright © 2014 Canonical Ltd.
4432
3
 *
4433
4
 * This program is free software: you can redistribute it and/or modify
4434
5
 * it under the terms of the GNU General Public License version 3 as
4435
6
 * published by the Free Software Foundation.
4436
7
 *
4437
8
 * This program is distributed in the hope that it will be useful,
4438
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4439
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4440
11
 * GNU General Public License for more details.
4441
12
 *
4442
13
 * You should have received a copy of the GNU General Public License
4443
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4444
15
 *
4445
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
4446
17
 */
4447
18
4448
19
#include "src/platform/graphics/mesa/display_helpers.h"
4449
20
#include "mir/udev/wrapper.h"
4450
21
4451
22
#include "mir_test_framework/udev_environment.h"
4452
23
#include "mir_test_doubles/mock_drm.h"
4453
24
4454
25
#include <fcntl.h>
4455
26
4456
27
#include <gtest/gtest.h>
4457
28
#include <gmock/gmock.h>
4458
29
4459
30
namespace mgm = mir::graphics::mesa;
4460
31
namespace mtf = mir::mir_test_framework;
4461
32
namespace mtd = mir::test::doubles;
4462
33
                          
4463
34
namespace
4464
35
{
4465
36
4466
37
MATCHER_P(FlagSet, flag, "")
4467
38
{
4468
39
    return (arg & flag);
4469
40
}
4470
41
4471
42
class DRMHelperTest : public ::testing::Test
4472
43
{              
4473
44
public:        
4474
45
    DRMHelperTest()
4475
46
    {          
4476
47
        fake_devices.add_standard_device("standard-drm-devices");
4477
48
    }          
4478
49
               
4479
50
protected:       
4480
51
    ::testing::NiceMock<mtd::MockDRM> mock_drm;
4481
52
    mtf::UdevEnvironment fake_devices;
4482
53
};
4483
54
4484
55
}
4485
56
4486
57
TEST_F(DRMHelperTest, closes_drm_fd_on_exec)
4487
58
{   
4488
59
    using namespace testing;
4489
60
4490
61
    EXPECT_CALL(mock_drm, open(_, FlagSet(O_CLOEXEC), _));
4491
62
4492
63
    mgm::helpers::DRMHelper drm_helper;
4493
64
    drm_helper.setup(std::make_shared<mir::udev::Context>());
4494
65
}   
4495
0
66
4496
=== modified file 'tests/unit-tests/scene/CMakeLists.txt'
4497
--- tests/unit-tests/scene/CMakeLists.txt	2014-05-06 06:16:13 +0000
4498
+++ tests/unit-tests/scene/CMakeLists.txt	2014-05-09 12:26:43 +0000
4499
@@ -9,6 +9,7 @@
4500
9
  ${CMAKE_CURRENT_SOURCE_DIR}/test_the_session_container_implementation.cpp
9
  ${CMAKE_CURRENT_SOURCE_DIR}/test_the_session_container_implementation.cpp
4501
10
  ${CMAKE_CURRENT_SOURCE_DIR}/test_threaded_snapshot_strategy.cpp
10
  ${CMAKE_CURRENT_SOURCE_DIR}/test_threaded_snapshot_strategy.cpp
4502
11
  ${CMAKE_CURRENT_SOURCE_DIR}/test_mediating_display_changer.cpp
11
  ${CMAKE_CURRENT_SOURCE_DIR}/test_mediating_display_changer.cpp
4503
12
  ${CMAKE_CURRENT_SOURCE_DIR}/test_trust_session.cpp
4504
12
13
4505
13
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface.cpp
14
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface.cpp
4506
14
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_impl.cpp
15
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_impl.cpp
4507
15
16
4508
=== modified file 'tests/unit-tests/scene/test_application_session.cpp'
4509
--- tests/unit-tests/scene/test_application_session.cpp	2014-04-15 10:19:19 +0000
4510
+++ tests/unit-tests/scene/test_application_session.cpp	2014-05-09 12:26:43 +0000
4511
@@ -27,6 +27,7 @@
4512
27
#include "mir_test_doubles/stub_display_configuration.h"
27
#include "mir_test_doubles/stub_display_configuration.h"
4513
28
#include "mir_test_doubles/null_snapshot_strategy.h"
28
#include "mir_test_doubles/null_snapshot_strategy.h"
4514
29
#include "mir_test_doubles/null_event_sink.h"
29
#include "mir_test_doubles/null_event_sink.h"
4515
30
#include "mir_test_doubles/null_trust_session.h"
4516
30
31
4517
31
#include <gmock/gmock.h>
32
#include <gmock/gmock.h>
4518
32
#include <gtest/gtest.h>
33
#include <gtest/gtest.h>
4519
@@ -70,6 +71,10 @@
4520
70
           arg.stride == mir::geometry::Stride{} &&
71
           arg.stride == mir::geometry::Stride{} &&
4521
71
           arg.pixels == nullptr;
72
           arg.pixels == nullptr;
4522
72
}
73
}
4523
74
4524
75
MATCHER_P(EqTrustedEventState, state, "") {
4525
76
  return arg.type == mir_event_type_trust_session_state_change && arg.trust_session.new_state == state;
4526
77
}
4527
73
}
78
}
4528
74
79
4529
75
TEST(ApplicationSession, create_and_destroy_surface)
80
TEST(ApplicationSession, create_and_destroy_surface)
4530
@@ -380,3 +385,43 @@
4531
380
385
4532
381
    EXPECT_THAT(app_session.process_id(), Eq(pid));
386
    EXPECT_THAT(app_session.process_id(), Eq(pid));
4533
382
}
387
}
4534
388
4535
389
TEST(ApplicationSession, begin_trust_session)
4536
390
{
4537
391
    using namespace ::testing;
4538
392
4539
393
    mtd::MockSurfaceCoordinator surface_coordinator;
4540
394
    MockEventSink sender;
4541
395
4542
396
    ms::ApplicationSession app_session(
4543
397
        mt::fake_shared(surface_coordinator),
4544
398
        __LINE__,
4545
399
        "Foo",
4546
400
        std::make_shared<mtd::NullSnapshotStrategy>(),
4547
401
        std::make_shared<ms::NullSessionListener>(),
4548
402
        mt::fake_shared(sender));
4549
403
4550
404
    EXPECT_CALL(sender, handle_event(EqTrustedEventState(mir_trust_session_state_started))).Times(1);
4551
405
4552
406
    app_session.begin_trust_session();
4553
407
}
4554
408
4555
409
TEST(ApplicationSession, end_trust_session)
4556
410
{
4557
411
    using namespace ::testing;
4558
412
4559
413
    mtd::MockSurfaceCoordinator surface_coordinator;
4560
414
    MockEventSink sender;
4561
415
4562
416
    ms::ApplicationSession app_session(
4563
417
        mt::fake_shared(surface_coordinator),
4564
418
        __LINE__,
4565
419
        "Foo",
4566
420
        std::make_shared<mtd::NullSnapshotStrategy>(),
4567
421
        std::make_shared<ms::NullSessionListener>(),
4568
422
        mt::fake_shared(sender));
4569
423
4570
424
    EXPECT_CALL(sender, handle_event(EqTrustedEventState(mir_trust_session_state_stopped))).Times(1);
4571
425
4572
426
    app_session.end_trust_session();
4573
427
}
4574
383
428
4575
=== modified file 'tests/unit-tests/scene/test_session_manager.cpp'
4576
--- tests/unit-tests/scene/test_session_manager.cpp	2014-04-15 10:19:19 +0000
4577
+++ tests/unit-tests/scene/test_session_manager.cpp	2014-05-09 12:26:43 +0000
4578
@@ -27,6 +27,9 @@
4579
27
#include "src/server/scene/session_event_sink.h"
27
#include "src/server/scene/session_event_sink.h"
4580
28
#include "src/server/scene/basic_surface.h"
28
#include "src/server/scene/basic_surface.h"
4581
29
#include "src/server/report/null_report_factory.h"
29
#include "src/server/report/null_report_factory.h"
4582
30
#include "mir/scene/trust_session_creation_parameters.h"
4583
31
#include "mir/scene/null_trust_session_listener.h"
4584
32
#include "mir/scene/trust_session.h"
4585
30
33
4586
31
#include "mir_test/fake_shared.h"
34
#include "mir_test/fake_shared.h"
4587
32
#include "mir_test_doubles/mock_buffer_stream.h"
35
#include "mir_test_doubles/mock_buffer_stream.h"
4588
@@ -37,6 +40,8 @@
4589
37
#include "mir_test_doubles/null_snapshot_strategy.h"
40
#include "mir_test_doubles/null_snapshot_strategy.h"
4590
38
#include "mir_test_doubles/null_surface_configurator.h"
41
#include "mir_test_doubles/null_surface_configurator.h"
4591
39
#include "mir_test_doubles/null_session_event_sink.h"
42
#include "mir_test_doubles/null_session_event_sink.h"
4592
43
#include "mir_test_doubles/mock_trust_session_listener.h"
4593
44
#include "mir_test_doubles/null_event_sink.h"
4594
40
45
4595
41
#include <gmock/gmock.h>
46
#include <gmock/gmock.h>
4596
42
#include <gtest/gtest.h>
47
#include <gtest/gtest.h>
4597
@@ -44,7 +49,6 @@
4598
44
namespace mc = mir::compositor;
49
namespace mc = mir::compositor;
4599
45
namespace mf = mir::frontend;
50
namespace mf = mir::frontend;
4600
46
namespace mi = mir::input;
51
namespace mi = mir::input;
4601
47
namespace msh = mir::shell;
4602
48
namespace ms = mir::scene;
52
namespace ms = mir::scene;
4603
49
namespace geom = mir::geometry;
53
namespace geom = mir::geometry;
4604
50
namespace mt = mir::test;
54
namespace mt = mir::test;
4605
@@ -78,7 +82,8 @@
4606
78
                        mt::fake_shared(focus_setter),
82
                        mt::fake_shared(focus_setter),
4607
79
                        std::make_shared<mtd::NullSnapshotStrategy>(),
83
                        std::make_shared<mtd::NullSnapshotStrategy>(),
4608
80
                        std::make_shared<mtd::NullSessionEventSink>(),
84
                        std::make_shared<mtd::NullSessionEventSink>(),
4610
81
                        mt::fake_shared(session_listener))
85
                        mt::fake_shared(session_listener),
4611
86
                        std::make_shared<ms::NullTrustSessionListener>())
4612
82
    {
87
    {
4613
83
        using namespace ::testing;
88
        using namespace ::testing;
4614
84
        ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
89
        ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
4615
@@ -178,7 +183,8 @@
4616
178
                        mt::fake_shared(focus_setter),
183
                        mt::fake_shared(focus_setter),
4617
179
                        std::make_shared<mtd::NullSnapshotStrategy>(),
184
                        std::make_shared<mtd::NullSnapshotStrategy>(),
4618
180
                        std::make_shared<mtd::NullSessionEventSink>(),
185
                        std::make_shared<mtd::NullSessionEventSink>(),
4620
181
                        mt::fake_shared(session_listener))
186
                        mt::fake_shared(session_listener),
4621
187
                        std::make_shared<ms::NullTrustSessionListener>())
4622
182
    {
188
    {
4623
183
        using namespace ::testing;
189
        using namespace ::testing;
4624
184
        ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
190
        ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
4625
@@ -187,7 +193,7 @@
4626
187
    mtd::MockSurfaceCoordinator surface_coordinator;
193
    mtd::MockSurfaceCoordinator surface_coordinator;
4627
188
    testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
194
    testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
4628
189
    testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
195
    testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
4630
190
    mtd::MockSessionListener session_listener;
196
    testing::NiceMock<mtd::MockSessionListener> session_listener;
4631
191
197
4632
192
    ms::SessionManager session_manager;
198
    ms::SessionManager session_manager;
4633
193
};
199
};
4634
@@ -217,7 +223,8 @@
4635
217
                        mt::fake_shared(focus_setter),
223
                        mt::fake_shared(focus_setter),
4636
218
                        std::make_shared<mtd::NullSnapshotStrategy>(),
224
                        std::make_shared<mtd::NullSnapshotStrategy>(),
4637
219
                        mt::fake_shared(session_event_sink),
225
                        mt::fake_shared(session_event_sink),
4639
220
                        std::make_shared<ms::NullSessionListener>())
226
                        std::make_shared<ms::NullSessionListener>(),
4640
227
                        std::make_shared<ms::NullTrustSessionListener>())
4641
221
    {
228
    {
4642
222
        using namespace ::testing;
229
        using namespace ::testing;
4643
223
        ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
230
        ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
4644
@@ -257,3 +264,46 @@
4645
257
    session_manager.close_session(session1);
264
    session_manager.close_session(session1);
4646
258
    session_manager.close_session(session);
265
    session_manager.close_session(session);
4647
259
}
266
}
4648
267
4649
268
namespace
4650
269
{
4651
270
4652
271
struct SessionManagerTrustSessionListenerSetup : public testing::Test
4653
272
{
4654
273
    SessionManagerTrustSessionListenerSetup()
4655
274
      : session_manager(mt::fake_shared(surface_coordinator),
4656
275
                        mt::fake_shared(container),
4657
276
                        mt::fake_shared(focus_setter),
4658
277
                        std::make_shared<mtd::NullSnapshotStrategy>(),
4659
278
                        std::make_shared<mtd::NullSessionEventSink>(),
4660
279
                        std::make_shared<ms::NullSessionListener>(),
4661
280
                        mt::fake_shared(trust_session_listener))
4662
281
    {
4663
282
        using namespace ::testing;
4664
283
        ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
4665
284
    }
4666
285
4667
286
    mtd::MockSurfaceCoordinator surface_coordinator;
4668
287
    testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
4669
288
    testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
4670
289
    testing::NiceMock<mtd::MockTrustSessionListener> trust_session_listener;
4671
290
    mtd::NullEventSink event_sink;
4672
291
4673
292
    ms::SessionManager session_manager;
4674
293
};
4675
294
}
4676
295
4677
296
TEST_F(SessionManagerTrustSessionListenerSetup, trust_session_listener_is_notified_of_trust_session_start_and_stop)
4678
297
{
4679
298
    using namespace ::testing;
4680
299
4681
300
    EXPECT_CALL(trust_session_listener, starting(_)).Times(1);
4682
301
    EXPECT_CALL(trust_session_listener, stopping(_)).Times(1);
4683
302
4684
303
    auto helper = session_manager.open_session(__LINE__, "XPlane", mt::fake_shared(event_sink));
4685
304
4686
305
    ms::TrustSessionCreationParameters parameters;
4687
306
4688
307
    auto trust_session = session_manager.start_trust_session_for(helper, parameters);
4689
308
    session_manager.stop_trust_session(trust_session);
4690
309
}
4691
260
310
4692
=== added file 'tests/unit-tests/scene/test_trust_session.cpp'
4693
--- tests/unit-tests/scene/test_trust_session.cpp	1970-01-01 00:00:00 +0000
4694
+++ tests/unit-tests/scene/test_trust_session.cpp	2014-05-09 12:26:43 +0000
4695
@@ -0,0 +1,73 @@
4696
1
/*
4697
2
 * Copyright © 2014 Canonical Ltd.
4698
3
 *
4699
4
 * This program is free software: you can redistribute it and/or modify
4700
5
 * it under the terms of the GNU General Public License version 3 as
4701
6
 * published by the Free Software Foundation.
4702
7
 *
4703
8
 * This program is distributed in the hope that it will be useful,
4704
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4705
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4706
11
 * GNU General Public License for more details.
4707
12
 *
4708
13
 * You should have received a copy of the GNU General Public License
4709
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4710
15
 *
4711
16
 * Authored By: Nick Dedekind <nick.dedekind@canonical.com>
4712
17
 */
4713
18
4714
19
#include "mir/frontend/event_sink.h"
4715
20
#include "mir/scene/trust_session_creation_parameters.h"
4716
21
#include "src/server/scene/trust_session_impl.h"
4717
22
#include "mir_test/fake_shared.h"
4718
23
#include "mir_test_doubles/mock_scene_session.h"
4719
24
#include "mir_test_doubles/mock_trust_session_listener.h"
4720
25
4721
26
#include <gmock/gmock.h>
4722
27
#include <gtest/gtest.h>
4723
28
4724
29
namespace mf = mir::frontend;
4725
30
namespace ms = mir::scene;
4726
31
namespace mt = mir::test;
4727
32
namespace mtd = mir::test::doubles;
4728
33
4729
34
4730
35
namespace
4731
36
{
4732
37
4733
38
struct TrustSession : public testing::Test
4734
39
{
4735
40
    TrustSession()
4736
41
    {
4737
42
    }
4738
43
4739
44
    testing::NiceMock<mtd::MockTrustSessionListener> trust_session_listener;
4740
45
    testing::NiceMock<mtd::MockSceneSession> trusted_helper;
4741
46
    testing::NiceMock<mtd::MockSceneSession> trusted_app1;
4742
47
};
4743
48
}
4744
49
4745
50
TEST_F(TrustSession, start_and_stop)
4746
51
{
4747
52
    using namespace testing;
4748
53
4749
54
    EXPECT_CALL(trusted_helper, begin_trust_session()).Times(1);
4750
55
    EXPECT_CALL(trusted_helper, end_trust_session()).Times(1);
4751
56
4752
57
    EXPECT_CALL(trusted_app1, begin_trust_session()).Times(0);
4753
58
    EXPECT_CALL(trusted_app1, end_trust_session()).Times(0);
4754
59
4755
60
    EXPECT_CALL(trust_session_listener, trusted_session_beginning(_,_)).Times(1);
4756
61
    EXPECT_CALL(trust_session_listener, trusted_session_ending(_,_)).Times(1);
4757
62
4758
63
    auto shared_helper = mt::fake_shared(trusted_helper);
4759
64
    auto shared_app1 = mt::fake_shared(trusted_app1);
4760
65
4761
66
    ms::TrustSessionImpl trust_session(shared_helper,
4762
67
                                   ms::a_trust_session(),
4763
68
                                   mt::fake_shared(trust_session_listener));
4764
69
4765
70
    trust_session.start();
4766
71
    trust_session.add_trusted_child(shared_app1);
4767
72
    trust_session.stop();
4768
73
}
Status:	Superseded
Proposed branch:	lp:~nick-dedekind/mir/trusted_sessions
Merge into:	lp:mir
Diff against target:	4768 lines (+3439/-57) (has conflicts) 81 files modified examples/CMakeLists.txt (+6/-2) examples/demo-inprocess-surface-client/inprocess_egl_client.cpp (+1/-1) examples/trust_session.c (+249/-0) include/client/mir_toolkit/mir_trust_session.h (+119/-0) include/server/mir/default_server_configuration.h (+3/-0) include/server/mir/frontend/connection_context.h (+58/-0) include/server/mir/frontend/event_sink.h (+2/-0) include/server/mir/frontend/session.h (+1/-0) include/server/mir/frontend/session_mediator_report.h (+6/-0) include/server/mir/frontend/shell.h (+9/-0) include/server/mir/frontend/trust_session.h (+53/-0) include/server/mir/scene/null_trust_session_listener.h (+50/-0) include/server/mir/scene/session.h (+3/-1) include/server/mir/scene/trust_session.h (+43/-0) include/server/mir/scene/trust_session_creation_parameters.h (+46/-0) include/server/mir/scene/trust_session_listener.h (+52/-0) include/shared/mir_toolkit/client_types.h (+40/-0) include/shared/mir_toolkit/common.h (+17/-0) include/shared/mir_toolkit/event.h (+10/-1) include/test/mir_test/test_protobuf_client.h (+18/-0) include/test/mir_test_doubles/mock_scene_session.h (+3/-0) include/test/mir_test_doubles/mock_shell.h (+9/-0) include/test/mir_test_doubles/mock_trust_session_listener.h (+48/-0) include/test/mir_test_doubles/null_trust_session.h (+70/-0) include/test/mir_test_doubles/stub_scene_session.h (+8/-0) include/test/mir_test_doubles/stub_session.h (+4/-0) include/test/mir_test_doubles/stub_shell.h (+15/-0) src/client/CMakeLists.txt (+4/-1) src/client/connection_configuration.h (+2/-0) src/client/default_connection_configuration.cpp (+11/-1) src/client/default_connection_configuration.h (+2/-0) src/client/event_distributor.cpp (+57/-0) src/client/event_distributor.h (+52/-0) src/client/mir_connection.cpp (+9/-2) src/client/mir_connection.h (+5/-0) src/client/mir_trust_session.cpp (+182/-0) src/client/mir_trust_session.h (+88/-0) src/client/mir_trust_session_api.cpp (+133/-0) src/client/rpc/make_rpc_channel.h (+3/-1) src/client/rpc/make_socket_rpc_channel.cpp (+4/-3) src/client/rpc/mir_socket_rpc_channel.cpp (+26/-7) src/client/rpc/mir_socket_rpc_channel.h (+6/-2) src/server/default_server_configuration.cpp (+11/-0) src/server/frontend/protobuf_message_processor.cpp (+23/-4) src/server/frontend/session_mediator.cpp (+133/-0) src/server/frontend/session_mediator.h (+29/-3) src/server/report/logging/session_mediator_report.cpp (+15/-0) src/server/report/logging/session_mediator_report.h (+6/-0) src/server/report/lttng/session_mediator_report.cpp (+11/-0) src/server/report/lttng/session_mediator_report.h (+3/-0) src/server/report/lttng/session_mediator_report_tp.h (+21/-0) src/server/report/null/session_mediator_report.cpp (+12/-0) src/server/report/null/session_mediator_report.h (+6/-0) src/server/scene/CMakeLists.txt (+3/-0) src/server/scene/application_session.cpp (+21/-0) src/server/scene/application_session.h (+3/-0) src/server/scene/default_configuration.cpp (+3/-2) src/server/scene/session_manager.cpp (+125/-3) src/server/scene/session_manager.h (+20/-1) src/server/scene/trust_session_container.cpp (+95/-0) src/server/scene/trust_session_container.h (+103/-0) src/server/scene/trust_session_creation_parameters.cpp (+51/-0) src/server/scene/trust_session_impl.cpp (+187/-0) src/server/scene/trust_session_impl.h (+74/-0) src/shared/protobuf/mir_protobuf.proto (+54/-14) tests/acceptance-tests/CMakeLists.txt (+1/-0) tests/acceptance-tests/test_client_trust_session_api.cpp (+106/-0) tests/acceptance-tests/test_nested_mir.cpp (+3/-0) tests/acceptance-tests/test_server_shutdown.cpp (+43/-0) tests/integration-tests/frontend/test_application_mediator_report.cpp (+181/-0) tests/integration-tests/test_session_manager.cpp (+3/-1) tests/mir_test_doubles/test_protobuf_client.cpp (+27/-1) tests/unit-tests/client/CMakeLists.txt (+1/-0) tests/unit-tests/client/test_mir_trust_session.cpp (+244/-0) tests/unit-tests/frontend/stress_protobuf_communicator.cpp (+3/-1) tests/unit-tests/frontend/test_session_mediator.cpp (+52/-0) tests/unit-tests/graphics/mesa/test_drm_helper.cpp.moved (+65/-0) tests/unit-tests/scene/CMakeLists.txt (+1/-0) tests/unit-tests/scene/test_application_session.cpp (+45/-0) tests/unit-tests/scene/test_session_manager.cpp (+55/-5) tests/unit-tests/scene/test_trust_session.cpp (+73/-0) Text conflict in include/server/mir/frontend/connection_context.h Text conflict in include/shared/mir_toolkit/client_types.h Text conflict in src/server/frontend/protobuf_message_processor.cpp Text conflict in src/server/frontend/session_mediator.cpp Text conflict in src/server/frontend/session_mediator.h Text conflict in src/shared/protobuf/mir_protobuf.proto Text conflict in tests/acceptance-tests/test_server_shutdown.cpp Text conflict in tests/unit-tests/frontend/test_session_mediator.cpp
To merge this branch:	bzr merge lp:~nick-dedekind/mir/trusted_sessions
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Alan Griffiths		2014-03-04	Needs Fixing on 2014-04-23
Daniel van Vugt			Needs Fixing on 2014-04-01
PS Jenkins bot (community)	continuous-integration		Approve on 2014-03-26
Alexandros Frantzis (community)			Needs Fixing on 2014-03-11
Andreas Pokorny (community)			Needs Fixing on 2014-03-08
Review via email: mp+209224@code.launchpad.net