1
=== modified file 'benchmarks/benchmark_multiplexing_dispatchable.cpp'
2
--- benchmarks/benchmark_multiplexing_dispatchable.cpp	2015-06-17 05:20:42 +0000
3
+++ benchmarks/benchmark_multiplexing_dispatchable.cpp	2017-03-28 00:17:49 +0000
4
@@ -19,6 +19,7 @@
5
19
#include "mir/dispatch/multiplexing_dispatchable.h"
19
#include "mir/dispatch/multiplexing_dispatchable.h"
6
20
20
7
21
#include <iostream>
21
#include <iostream>
8
22
#include <thread>
9
22
#include <vector>
23
#include <vector>
10
23
#include <memory>
24
#include <memory>
11
24
#include <chrono>
25
#include <chrono>
12
25
26
13
=== modified file 'debian/control'
14
--- debian/control	2017-03-22 23:38:59 +0000
15
+++ debian/control	2017-03-28 00:17:49 +0000
16
@@ -288,6 +288,7 @@
17
288
Pre-Depends: ${misc:Pre-Depends}
288
Pre-Depends: ${misc:Pre-Depends}
18
289
Depends: ${misc:Depends},
289
Depends: ${misc:Depends},
19
290
         ${shlibs:Depends},
290
         ${shlibs:Depends},
20
291
         umockdev,
21
291
Recommends: mir-demos,
292
Recommends: mir-demos,
22
292
Description: Display Server for Ubuntu - stress tests and other test tools
293
Description: Display Server for Ubuntu - stress tests and other test tools
23
293
 Mir is a display server running on linux systems, with a focus on efficiency,
294
 Mir is a display server running on linux systems, with a focus on efficiency,
24
294
295
25
=== modified file 'examples/chain_jumping_buffers.c'
26
--- examples/chain_jumping_buffers.c	2017-03-10 19:47:57 +0000
27
+++ examples/chain_jumping_buffers.c	2017-03-28 00:17:49 +0000
28
@@ -268,8 +268,14 @@
29
268
    for (unsigned int i = 0u; i < num_buffers; i++)
268
    for (unsigned int i = 0u; i < num_buffers; i++)
30
269
        mir_buffer_release(buffer_available[i].buffer);
269
        mir_buffer_release(buffer_available[i].buffer);
31
270
    for (unsigned int i = 0u; i < num_chains; i++)
270
    for (unsigned int i = 0u; i < num_chains; i++)
32
271
<<<<<<< TREE
33
271
        mir_render_surface_release(render_surface[i]);
272
        mir_render_surface_release(render_surface[i]);
34
272
    mir_window_release_sync(window);
273
    mir_window_release_sync(window);
35
274
=======
36
275
        mir_render_surface_release_sync(render_surface[i]);
37
276
38
277
    mir_surface_release_sync(surface);
39
278
>>>>>>> MERGE-SOURCE
40
273
    mir_connection_release(connection);
279
    mir_connection_release(connection);
41
274
    return 0;
280
    return 0;
42
275
}
281
}
43
276
282
44
=== modified file 'examples/prerendered_frames.c'
45
--- examples/prerendered_frames.c	2017-03-10 19:47:57 +0000
46
+++ examples/prerendered_frames.c	2017-03-28 00:17:49 +0000
47
@@ -234,8 +234,13 @@
48
234
234
49
235
    for (i = 0u; i < num_prerendered_frames; i++)
235
    for (i = 0u; i < num_prerendered_frames; i++)
50
236
        mir_buffer_release(buffer_available[i].buffer);
236
        mir_buffer_release(buffer_available[i].buffer);
51
237
<<<<<<< TREE
52
237
    mir_render_surface_release(render_surface);
238
    mir_render_surface_release(render_surface);
53
238
    mir_window_release_sync(window);
239
    mir_window_release_sync(window);
54
240
=======
55
241
    mir_render_surface_release_sync(render_surface);
56
242
    mir_surface_release_sync(surface);
57
243
>>>>>>> MERGE-SOURCE
58
239
    mir_connection_release(connection);
244
    mir_connection_release(connection);
59
240
    return 0;
245
    return 0;
60
241
}
246
}
61
242
247
62
=== modified file 'examples/render_surface.cpp'
63
--- examples/render_surface.cpp	2017-03-10 19:47:57 +0000
64
+++ examples/render_surface.cpp	2017-03-28 00:17:49 +0000
65
@@ -23,6 +23,8 @@
66
23
#include <signal.h>
23
#include <signal.h>
67
24
#include <sys/signalfd.h>
24
#include <sys/signalfd.h>
68
25
#include <poll.h>
25
#include <poll.h>
69
26
#include <mutex>
70
27
#include <condition_variable>
71
26
28
72
27
#include "mir_toolkit/mir_client_library.h"
29
#include "mir_toolkit/mir_client_library.h"
73
28
#include "mir_toolkit/rs/mir_render_surface.h"
30
#include "mir_toolkit/rs/mir_render_surface.h"
74
@@ -207,14 +209,23 @@
75
207
    if (nformats == 0)
209
    if (nformats == 0)
76
208
        throw std::runtime_error("no pixel formats for buffer stream");
210
        throw std::runtime_error("no pixel formats for buffer stream");
77
209
    printf("Software Driver selected pixel format %d\n", pixel_format);
211
    printf("Software Driver selected pixel format %d\n", pixel_format);
78
212
<<<<<<< TREE
79
210
    auto buffer_stream = mir_render_surface_get_buffer_stream(
213
    auto buffer_stream = mir_render_surface_get_buffer_stream(
80
211
        render_surface, width, height, pixel_format);
214
        render_surface, width, height, pixel_format);
81
215
=======
82
216
83
217
    auto stream = mir_render_surface_get_buffer_stream_sync(
84
218
        render_surface,
85
219
        width, height,
86
220
        pixel_format,
87
221
        mir_buffer_usage_software);
88
222
>>>>>>> MERGE-SOURCE
89
212
223
90
213
    auto window = mir_create_window_sync(spec);
224
    auto window = mir_create_window_sync(spec);
91
214
    mir_window_spec_release(spec);
225
    mir_window_spec_release(spec);
92
215
226
95
216
    fill_stream_with(buffer_stream, 255, 0, 0, 128);
227
    fill_stream_with(stream, 255, 0, 0, 128);
96
217
    mir_buffer_stream_swap_buffers_sync(buffer_stream);
228
    mir_buffer_stream_swap_buffers_sync(stream);
97
218
229
98
219
    sigset_t halt_signals;
230
    sigset_t halt_signals;
99
220
    sigemptyset(&halt_signals);
231
    sigemptyset(&halt_signals);
100
@@ -235,13 +246,18 @@
101
235
    {
246
    {
102
236
        bounce_position(baseColour, dbase, 128, 255);
247
        bounce_position(baseColour, dbase, 128, 255);
103
237
248
105
238
        fill_stream_with(buffer_stream, baseColour, 0, 0, 128);
249
        fill_stream_with(stream, baseColour, 0, 0, 128);
106
239
250
108
240
        mir_buffer_stream_swap_buffers_sync(buffer_stream);
251
        mir_buffer_stream_swap_buffers_sync(stream);
109
241
    }
252
    }
110
242
253
111
254
<<<<<<< TREE
112
243
    mir_render_surface_release(render_surface);
255
    mir_render_surface_release(render_surface);
113
244
    mir_window_release_sync(window);
256
    mir_window_release_sync(window);
114
257
=======
115
258
    mir_render_surface_release_sync(render_surface);
116
259
    mir_surface_release_sync(surface);
117
260
>>>>>>> MERGE-SOURCE
118
245
    close(signal_watch);
261
    close(signal_watch);
119
246
262
120
247
    return 0;
263
    return 0;
121
248
264
122
=== modified file 'include/client/mir_toolkit/mir_connection.h'
123
--- include/client/mir_toolkit/mir_connection.h	2017-03-13 08:12:52 +0000
124
+++ include/client/mir_toolkit/mir_connection.h	2017-03-28 00:17:49 +0000
125
@@ -63,6 +63,54 @@
126
63
MirConnection *mir_connect_sync(char const *server, char const *app_name);
63
MirConnection *mir_connect_sync(char const *server, char const *app_name);
127
64
64
128
65
/**
65
/**
129
66
 * Request a connection to the Mir server.
130
67
 *
131
68
 * The client is responsible for handling event consumption via
132
69
 * mir_connection_dispatch(). Events will be available when the fd returned
133
70
 * by mir_connection_get_event_fd() becomes readable.
134
71
 *
135
72
 * All callbacks for this MirConnection and any objects created on it will be
136
73
 * called from the thread calling mir_connection_dispatch().
137
74
 *
138
75
 * \param [in] server       A string specifying the server to connect to.
139
76
 *                          Connection strings can either be path to the socket file on
140
77
 *                          the filesystem, or an open file descriptor fd://
141
78
 * \param [in] app_name     A name referring to the application
142
79
 * \param [in] callback     Callback function to be invoked when request
143
80
 *                          completes. mir_connection_is_valid() will return false
144
81
 *                          until this callback has completed.
145
82
 * \param [in,out] context  User data passed to the callback function
146
83
 * \returns                 The resulting MirConnection
147
84
 * \todo     Currently manual dispatch interacts awkwardly with *_sync() calls;
148
85
 *           Synchronous calls do *not* automatically dispatch, so unless client
149
86
 *           code has a separate thread running dispatch, any *_sync() call will
150
87
 *           deadlock. This restriction will be fixed in a later release.
151
88
 */
152
89
MirConnection* mir_connect_with_manual_dispatch(char const* server,
153
90
                                                char const* app_name,
154
91
                                                mir_connected_callback callback,
155
92
                                                void* context);
156
93
157
94
/**
158
95
 * Synchronously connect to the Mir server.
159
96
 *
160
97
 * The client is responsible for handling event consumption via
161
98
 * mir_connection_dispatch(). Events will be available when the fd returned
162
99
 * by mir_connection_get_event_fd() becomes readable.
163
100
 *
164
101
 * All callbacks for this MirConnection and any objects created on it will be
165
102
 * called from the thread calling mir_connection_dispatch().
166
103
 *
167
104
 * \param [in] server       A string specifying the server to connect to.
168
105
 *                          Connection strings can either be path to the socket file on
169
106
 *                          the filesystem, or an open file descriptor fd://
170
107
 * \param [in] app_name     A name referring to the application
171
108
 * \returns                 The resulting MirConnection
172
109
 */
173
110
MirConnection* mir_connect_with_manual_dispatch_sync(char const* server,
174
111
    char const* app_name);
175
112
176
113
/**
177
66
 * Test for a valid connection
114
 * Test for a valid connection
178
67
 * \param [in] connection  The connection
115
 * \param [in] connection  The connection
179
68
 * \return                 True if the supplied connection is valid, or
116
 * \return                 True if the supplied connection is valid, or
180
@@ -87,6 +135,28 @@
181
87
void mir_connection_release(MirConnection *connection);
135
void mir_connection_release(MirConnection *connection);
182
88
136
183
89
/**
137
/**
184
138
 * \brief Get the notification fd for this connection
185
139
 * \param [in] connection   The connection. This connection must have been created by
186
140
 *                          mir_connect_with_manual_dispatch().
187
141
 * \return                  A file descriptor that supports select/poll/epoll and similar
188
142
 *                          APIs that becomes readable when there are events to dispatch,
189
143
 *                          or -1 if \ref connection was not created by
190
144
 *                          mir_connect_with_manual_dispatch();
191
145
 * \note    This fd is owned by the MirConnection. Do not close the fd yourself.
192
146
 *          The fd remains valid until mir_connection_release() returns.
193
147
 */
194
148
int mir_connection_get_event_fd(MirConnection* connection);
195
149
196
150
/**
197
151
 * \brief Dispatch a single pending event on the connection
198
152
 * \param [in] connection   The connection. This connection must have been created by
199
153
 *                          mir_connect_with_manual_dispatch().
200
154
 * \note    It is an error to call this on a \ref connection not created by
201
155
 *          mir_connect_with_manual_dispatch().
202
156
 */
203
157
void mir_connection_dispatch(MirConnection* connection);
204
158
205
159
/**
206
90
 * Query platform-specific data and/or file descriptors that are required to
160
 * Query platform-specific data and/or file descriptors that are required to
207
91
 * initialize GL/EGL features.
161
 * initialize GL/EGL features.
208
92
 *   \param [in]  connection        The connection
162
 *   \param [in]  connection        The connection
209
93
163
210
=== modified file 'include/client/mir_toolkit/mir_wait.h'
211
--- include/client/mir_toolkit/mir_wait.h	2017-01-19 23:17:56 +0000
212
+++ include/client/mir_toolkit/mir_wait.h	2017-03-28 00:17:49 +0000
213
@@ -49,6 +49,7 @@
214
49
void mir_wait_for_one(MirWaitHandle *wait_handle)
49
void mir_wait_for_one(MirWaitHandle *wait_handle)
215
50
__attribute__ ((deprecated("No longer supported - use callbacks or wait for state changes")));
50
__attribute__ ((deprecated("No longer supported - use callbacks or wait for state changes")));
216
51
51
217
52
bool mir_wait_handle_ready(MirWaitHandle* wait_handle);
218
52
53
219
53
#ifdef __cplusplus
54
#ifdef __cplusplus
220
54
}
55
}
221
55
56
222
=== modified file 'include/client/mir_toolkit/rs/mir_render_surface.h'
223
--- include/client/mir_toolkit/rs/mir_render_surface.h	2017-03-14 04:41:33 +0000
224
+++ include/client/mir_toolkit/rs/mir_render_surface.h	2017-03-28 00:17:49 +0000
225
@@ -118,13 +118,30 @@
226
118
/**
118
/**
227
119
 * Release the specified render surface
119
 * Release the specified render surface
228
120
 *
120
 *
230
121
 * \param [in] render_surface                   The render surface to be released
121
 * \param [in] render_surface   The render surface to be released
231
122
 * \param [in] callback         Callback to be run when the operation completes
232
123
 * \param [in,out] ctx          Context passed to callback
233
122
 */
124
 */
234
123
void mir_render_surface_release(
125
void mir_render_surface_release(
235
126
<<<<<<< TREE
236
124
    MirRenderSurface* render_surface)
127
    MirRenderSurface* render_surface)
237
125
__attribute__((deprecated("This function is slated for rename due to MirRenderSurface-->MirSurface transition")));
128
__attribute__((deprecated("This function is slated for rename due to MirRenderSurface-->MirSurface transition")));
240
126
129
=======
241
127
/**
130
    MirRenderSurface* render_surface,
242
131
    mir_render_surface_callback callback,
243
132
    void* ctx);
244
133
245
134
/**
246
135
 * Release the specified render surface and wait for the operation to complete
247
136
 *
248
137
 * \param [in] render_surface   The render surface to be released
249
138
 */
250
139
void mir_render_surface_release_sync(
251
140
    MirRenderSurface* render_surface);
252
141
>>>>>>> MERGE-SOURCE
253
142
254
143
/**
255
144
<<<<<<< TREE
256
128
 * Obtain the buffer stream backing a given render surface.
145
 * Obtain the buffer stream backing a given render surface.
257
129
 * The MirBufferStream will contain buffers suitable for writing via the CPU. 
146
 * The MirBufferStream will contain buffers suitable for writing via the CPU. 
258
130
 *
147
 *
259
@@ -143,10 +160,57 @@
260
143
    int width, int height,
160
    int width, int height,
261
144
    MirPixelFormat format)
161
    MirPixelFormat format)
262
145
__attribute__((deprecated("This function is slated for rename due to MirRenderSurface-->MirSurface transition")));
162
__attribute__((deprecated("This function is slated for rename due to MirRenderSurface-->MirSurface transition")));
265
146
163
=======
266
147
/**
164
 * Obtain a buffer stream backing a given render surface
267
165
 *
268
166
 * \pre The MirRenderSurface does not have a backing object.
269
167
 *
270
168
 * \param [in] render_surface    The render surface
271
169
 * \param [in] width             Requested width
272
170
 * \param [in] height            Requested height
273
171
 * \param [in] format            Requested pixel format
274
172
 * \param [in] usage             Requested buffer usage
275
173
 * \param [in] callback         Callback to be run when operation completes
276
174
 * \param [in,out]  context     Context passed to callback
277
175
 */
278
176
void mir_render_surface_get_buffer_stream(
279
177
    MirRenderSurface* render_surface,
280
178
    int width,
281
179
    int height,
282
180
    MirPixelFormat format,
283
181
    MirBufferUsage usage,
284
182
    mir_buffer_stream_callback callback,
285
183
    void* context);
286
184
287
185
/**
288
186
 * Back the render surface with a buffer stream and wait for the operation to complete.
289
187
 *
290
188
 * \pre The MirRenderSurface does not have a backing object.
291
189
 *
292
190
 * \param [in] render_surface    The render surface
293
191
 * \param [in] width             Requested width
294
192
 * \param [in] height            Requested height
295
193
 * \param [in] format            Requested pixel format
296
194
 * \param [in] usage             Requested buffer usage
297
195
 * \return      The new MirBufferStream backing the MirRenderSurface.
298
196
 *              If a backing object for this MirRenderSurface has already been realised
299
197
 *              this returns NULL, otherwise it returns a non-null MirBufferStream
300
198
 */
301
199
MirBufferStream* mir_render_surface_get_buffer_stream_sync(
302
200
    MirRenderSurface* render_surface,
303
201
    int width,
304
202
    int height,
305
203
    MirPixelFormat format,
306
204
    MirBufferUsage usage);
307
205
>>>>>>> MERGE-SOURCE
308
206
309
207
/**
310
208
<<<<<<< TREE
311
148
 * Obtain the presentation chain backing a given render surface.
209
 * Obtain the presentation chain backing a given render surface.
312
149
 * The MirPresentationChain is created in mir_present_mode_fifo submission mode.
210
 * The MirPresentationChain is created in mir_present_mode_fifo submission mode.
313
211
=======
314
212
 * Obtain a presentation chain backing a given render surface
315
213
>>>>>>> MERGE-SOURCE
316
150
 *
214
 *
317
151
 * \return                       The chain contained in the given render surface
215
 * \return                       The chain contained in the given render surface
318
152
 *                               or 'nullptr' if it, or
216
 *                               or 'nullptr' if it, or
319
153
217
320
=== added file 'include/common/mir/dispatch/threaded_dispatcher.h.moved'
321
--- include/common/mir/dispatch/threaded_dispatcher.h.moved	1970-01-01 00:00:00 +0000
322
+++ include/common/mir/dispatch/threaded_dispatcher.h.moved	2017-03-28 00:17:49 +0000
323
@@ -0,0 +1,75 @@
324
1
/*
325
2
 * Copyright © 2015 Canonical Ltd.
326
3
 *
327
4
 * This program is free software: you can redistribute it and/or modify it
328
5
 * under the terms of the GNU Lesser General Public License version 3,
329
6
 * as published by the Free Software Foundation.
330
7
 *
331
8
 * This program is distributed in the hope that it will be useful,
332
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
333
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
334
11
 * GNU Lesser General Public License for more details.
335
12
 *
336
13
 * You should have received a copy of the GNU Lesser General Public License
337
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
338
15
 *
339
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
340
17
 */
341
18
342
19
#ifndef MIR_DISPATCH_SIMPLE_DISPATCH_THREAD_H_
343
20
#define MIR_DISPATCH_SIMPLE_DISPATCH_THREAD_H_
344
21
345
22
#include <string>
346
23
#include <memory>
347
24
#include <thread>
348
25
#include <vector>
349
26
#include <mutex>
350
27
#include <condition_variable>
351
28
352
29
#include "mir/dispatch/multiplexing_dispatchable.h"
353
30
#include "mir/fd.h"
354
31
355
32
namespace mir
356
33
{
357
34
namespace dispatch
358
35
{
359
36
class Dispatchable;
360
37
361
38
class ThreadedDispatcher
362
39
{
363
40
public:
364
41
    ThreadedDispatcher(std::string const& name, std::shared_ptr<Dispatchable> const& dispatchee);
365
42
    ThreadedDispatcher(std::string const& name,
366
43
                       std::shared_ptr<Dispatchable> const& dispatchee,
367
44
                       std::function<void()> const& exception_handler);
368
45
    ~ThreadedDispatcher() noexcept;
369
46
370
47
    void add_thread();
371
48
    void remove_thread();
372
49
373
50
private:
374
51
    class ThreadShutdownRequestHandler;
375
52
    friend class ThreadShutdownRequestHandler;
376
53
377
54
    std::string const name_base;
378
55
379
56
    std::shared_ptr<ThreadShutdownRequestHandler> thread_exiter;
380
57
    std::shared_ptr<MultiplexingDispatchable> dispatcher;
381
58
382
59
    std::mutex thread_pool_mutex;
383
60
    std::vector<std::thread> threadpool;
384
61
385
62
    std::function<void()> const exception_handler;
386
63
387
64
    static void dispatch_loop(std::string const& name,
388
65
                              std::shared_ptr<ThreadShutdownRequestHandler> thread_register,
389
66
                              std::shared_ptr<Dispatchable> dispatcher,
390
67
                              std::function<void()> const& exception_handler);
391
68
392
69
};
393
70
394
71
}
395
72
}
396
73
397
74
398
75
#endif // MIR_DISPATCH_SIMPLE_DISPATCH_THREAD_H_
399
0
76
400
=== renamed file 'tests/include/mir/test/fd_utils.h' => 'include/test/mir/test/fd_utils.h'
401
=== modified file 'include/test/mir/test/validity_matchers.h'
402
--- include/test/mir/test/validity_matchers.h	2017-01-18 02:29:37 +0000
403
+++ include/test/mir/test/validity_matchers.h	2017-03-28 00:17:49 +0000
404
@@ -23,6 +23,8 @@
405
23
23
406
24
#include "mir_toolkit/mir_client_library.h"
24
#include "mir_toolkit/mir_client_library.h"
407
25
25
408
26
class MirRenderSurface;
409
27
410
26
using ::testing::MakePolymorphicMatcher;
28
using ::testing::MakePolymorphicMatcher;
411
27
using ::testing::MatchResultListener;
29
using ::testing::MatchResultListener;
412
28
using ::testing::NotNull;
30
using ::testing::NotNull;
413
@@ -54,6 +56,12 @@
414
54
template<>
56
template<>
415
55
bool IsValidMatcher::MatchAndExplain(MirWindow* surface, MatchResultListener* listener) const;
57
bool IsValidMatcher::MatchAndExplain(MirWindow* surface, MatchResultListener* listener) const;
416
56
58
417
59
template<>
418
60
bool IsValidMatcher::MatchAndExplain(MirBufferStream* stream, MatchResultListener* listener) const;
419
61
420
62
template<>
421
63
bool IsValidMatcher::MatchAndExplain(MirRenderSurface* stream, MatchResultListener* listener) const;
422
64
423
57
// To construct a polymorphic matcher, pass an instance of the class
65
// To construct a polymorphic matcher, pass an instance of the class
424
58
// to MakePolymorphicMatcher().  Note the return type.
66
// to MakePolymorphicMatcher().  Note the return type.
425
59
inline PolymorphicMatcher<IsValidMatcher> IsValid()
67
inline PolymorphicMatcher<IsValidMatcher> IsValid()
426
60
68
427
=== modified file 'playground/egldiamond_render_surface.c'
428
--- playground/egldiamond_render_surface.c	2017-03-14 04:41:33 +0000
429
+++ playground/egldiamond_render_surface.c	2017-03-28 00:17:49 +0000
430
@@ -322,8 +322,13 @@
431
322
        future_driver_eglTerminate(egldisplay);
322
        future_driver_eglTerminate(egldisplay);
432
323
    else
323
    else
433
324
        eglTerminate(egldisplay);
324
        eglTerminate(egldisplay);
434
325
<<<<<<< TREE
435
325
    mir_render_surface_release(render_surface);
326
    mir_render_surface_release(render_surface);
436
326
    mir_window_release_sync(window);
327
    mir_window_release_sync(window);
437
328
=======
438
329
    mir_render_surface_release_sync(render_surface);
439
330
    mir_surface_release_sync(surface);
440
331
>>>>>>> MERGE-SOURCE
441
327
    mir_connection_release(connection);
332
    mir_connection_release(connection);
442
328
    return 0;
333
    return 0;
443
329
}
334
}
444
330
335
445
=== modified file 'playground/mir_egl_platform_shim.c'
446
--- playground/mir_egl_platform_shim.c	2017-03-10 19:47:57 +0000
447
+++ playground/mir_egl_platform_shim.c	2017-03-28 00:17:49 +0000
448
@@ -72,10 +72,19 @@
449
72
    MirPixelFormat pixel_format = mir_connection_get_egl_pixel_format(info->connection, display, config);
72
    MirPixelFormat pixel_format = mir_connection_get_egl_pixel_format(info->connection, display, config);
450
73
    //this particular [silly] driver has chosen the buffer stream as the way it wants to post
73
    //this particular [silly] driver has chosen the buffer stream as the way it wants to post
451
74
    //its hardware content. I'd think most drivers would want MirPresentationChain for flexibility
74
    //its hardware content. I'd think most drivers would want MirPresentationChain for flexibility
452
75
<<<<<<< TREE
453
75
    info->stream = ext->get_hardware_buffer_stream(surface,
76
    info->stream = ext->get_hardware_buffer_stream(surface,
454
76
        info->current_physical_width,
77
        info->current_physical_width,
455
77
        info->current_physical_height,
78
        info->current_physical_height,
456
78
        pixel_format);
79
        pixel_format);
457
80
=======
458
81
459
82
    info->stream = mir_render_surface_get_buffer_stream_sync(
460
83
        surface,
461
84
        info->current_physical_width, info->current_physical_height,
462
85
        pixel_format,
463
86
        mir_buffer_usage_hardware);
464
87
>>>>>>> MERGE-SOURCE
465
79
88
466
80
    printf("The driver chose pixel format %d.\n", pixel_format);
89
    printf("The driver chose pixel format %d.\n", pixel_format);
467
81
    return eglCreateWindowSurface(display, config, (EGLNativeWindowType) surface, attr);
90
    return eglCreateWindowSurface(display, config, (EGLNativeWindowType) surface, attr);
468
82
91
469
=== modified file 'src/client/CMakeLists.txt'
470
--- src/client/CMakeLists.txt	2017-03-21 05:51:47 +0000
471
+++ src/client/CMakeLists.txt	2017-03-28 00:17:49 +0000
472
@@ -81,12 +81,15 @@
473
81
  screencast_stream.cpp
81
  screencast_stream.cpp
474
82
  buffer_vault.cpp
82
  buffer_vault.cpp
475
83
  mir_buffer_stream_api.cpp
83
  mir_buffer_stream_api.cpp
476
84
  synchronous_helper.cpp
477
84
  error_stream.cpp
85
  error_stream.cpp
478
85
  error_render_surface.cpp
86
  error_render_surface.cpp
479
86
  buffer.cpp
87
  buffer.cpp
480
87
  error_buffer.cpp
88
  error_buffer.cpp
481
88
  mir_render_surface_api.cpp
89
  mir_render_surface_api.cpp
482
89
  render_surface.cpp
90
  render_surface.cpp
483
91
  mir_render_surface.h
484
92
  ${CMAKE_SOURCE_DIR}/src/include/client/mir_toolkit/mir_render_surface.h
485
90
  presentation_chain.cpp
93
  presentation_chain.cpp
486
91
  mir_presentation_chain_api.cpp
94
  mir_presentation_chain_api.cpp
487
92
  mir_buffer_api.cpp
95
  mir_buffer_api.cpp
488
@@ -104,7 +107,11 @@
489
104
  ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_error.h
107
  ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_error.h
490
105
  mir_extension_core.cpp
108
  mir_extension_core.cpp
491
106
  ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_extension_core.h
109
  ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/mir_extension_core.h
492
110
<<<<<<< TREE
493
107
  ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/extensions/drag_and_drop.h
111
  ${CMAKE_SOURCE_DIR}/include/client/mir_toolkit/extensions/drag_and_drop.h
494
112
=======
495
113
  no_tls_future-inl.h
496
114
>>>>>>> MERGE-SOURCE
497
108
)
115
)
498
109
116
499
110
# Ensure protobuf C++ headers have been produced before
117
# Ensure protobuf C++ headers have been produced before
500
@@ -160,6 +167,8 @@
501
160
167
502
161
add_library(mirclient-debug-extension SHARED
168
add_library(mirclient-debug-extension SHARED
503
162
  mir_debug_api.cpp
169
  mir_debug_api.cpp
504
170
  $<TARGET_OBJECTS:mirclientobjects>
505
171
  $<TARGET_OBJECTS:mirsharedinput>
506
163
)
172
)
507
164
173
508
165
target_link_libraries(mirclient-debug-extension
174
target_link_libraries(mirclient-debug-extension
509
166
175
510
=== modified file 'src/client/buffer_factory.cpp'
511
--- src/client/buffer_factory.cpp	2017-03-10 19:47:57 +0000
512
+++ src/client/buffer_factory.cpp	2017-03-28 00:17:49 +0000
513
@@ -22,6 +22,7 @@
514
22
#include <algorithm>
22
#include <algorithm>
515
23
#include <boost/throw_exception.hpp>
23
#include <boost/throw_exception.hpp>
516
24
#include "protobuf_to_native_buffer.h"
24
#include "protobuf_to_native_buffer.h"
517
25
#include <sstream>
518
25
26
519
26
namespace mcl = mir::client;
27
namespace mcl = mir::client;
520
27
namespace geom = mir::geometry;
28
namespace geom = mir::geometry;
521
@@ -92,7 +93,16 @@
522
92
        });
93
        });
523
93
94
524
94
    if (request_it == allocation_requests.end())
95
    if (request_it == allocation_requests.end())
526
95
        BOOST_THROW_EXCEPTION(std::logic_error("unrequested buffer received"));
96
    {
527
97
        std::stringstream message;
528
98
        message << "Unrequested buffer received. Expected a buffer with one of the following sizes:" << std::endl;
529
99
        for (auto const& request : allocation_requests)
530
100
        {
531
101
            message << "\t(" << request->size.width << "×" << request->size.height << ")" << std::endl;
532
102
        }
533
103
        message << "Received buffer has size: (" << buffer.width() << "×" << buffer.height() << ")" << std::endl;
534
104
        BOOST_THROW_EXCEPTION(std::logic_error{message.str()});
535
105
    }
536
96
106
537
97
    std::unique_ptr<mcl::MirBuffer> b;
107
    std::unique_ptr<mcl::MirBuffer> b;
538
98
    if (buffer.has_error())
108
    if (buffer.has_error())
539
99
109
540
=== modified file 'src/client/buffer_stream.cpp'
541
--- src/client/buffer_stream.cpp	2017-03-20 11:24:19 +0000
542
+++ src/client/buffer_stream.cpp	2017-03-28 00:17:49 +0000
543
@@ -142,37 +142,52 @@
544
142
//Should be merged with mcl::BufferVault
142
//Should be merged with mcl::BufferVault
545
143
struct BufferDepository
143
struct BufferDepository
546
144
{
144
{
548
145
    BufferDepository(
145
    static NoTLSFuture<std::unique_ptr<BufferDepository>> create(
549
146
        std::shared_ptr<mcl::ClientBufferFactory> const& factory,
146
        std::shared_ptr<mcl::ClientBufferFactory> const& factory,
550
147
        std::shared_ptr<mcl::AsyncBufferFactory> const& mirbuffer_factory,
147
        std::shared_ptr<mcl::AsyncBufferFactory> const& mirbuffer_factory,
551
148
        std::shared_ptr<mcl::ServerBufferRequests> const& requests,
148
        std::shared_ptr<mcl::ServerBufferRequests> const& requests,
552
149
        std::weak_ptr<mcl::SurfaceMap> const& surface_map,
149
        std::weak_ptr<mcl::SurfaceMap> const& surface_map,
553
150
        geom::Size size, MirPixelFormat format, int usage,
150
        geom::Size size, MirPixelFormat format, int usage,
558
151
        unsigned int initial_nbuffers) :
151
        unsigned int initial_nbuffers)
555
152
        vault(factory, mirbuffer_factory, requests, surface_map, size, format, usage, initial_nbuffers),
556
153
        current(nullptr),
557
154
        size_(size)
559
155
    {
152
    {
561
156
        future = vault.withdraw();
153
        auto vault = std::make_unique<mcl::BufferVault>(
562
154
            factory,
563
155
            mirbuffer_factory,
564
156
            requests,
565
157
            surface_map,
566
158
            size,
567
159
            format,
568
160
            usage,
569
161
            initial_nbuffers);
570
162
571
163
        auto future_buffer = vault->withdraw();
572
164
573
165
        // Because NoTLSFuture<>.then() internally uses a std::function<void()> for the
574
166
        // continuation the lambda passed in has to be CopyConstructible, which means we can't
575
167
        // move-capture a std::unique_ptr<>. Dance around it with release().
576
168
        return future_buffer.then(
577
169
            [raw_vault = vault.release(), size](auto&& resolved_buffer)
578
170
            {
579
171
                std::unique_ptr<mcl::BufferVault> vault{raw_vault};
580
172
                return std::unique_ptr<BufferDepository>(
581
173
                    new BufferDepository{
582
174
                        resolved_buffer.get(),
583
175
                        std::move(vault),
584
176
                        size});
585
177
            });
586
157
    }
178
    }
587
158
179
588
159
    void deposit(mp::Buffer const&, mir::optional_value<geom::Size>, MirPixelFormat)
180
    void deposit(mp::Buffer const&, mir::optional_value<geom::Size>, MirPixelFormat)
589
160
    {
181
    {
590
161
    }
182
    }
591
162
183
592
163
    void advance_current_buffer(std::unique_lock<std::mutex>& lk)
593
164
    {
594
165
        lk.unlock();
595
166
        auto c = future.get();
596
167
        lk.lock();
597
168
        current = c;
598
169
    }
599
170
600
171
    std::shared_ptr<mir::client::ClientBuffer> current_buffer()
184
    std::shared_ptr<mir::client::ClientBuffer> current_buffer()
601
172
    {
185
    {
602
173
        std::unique_lock<std::mutex> lk(mutex);
186
        std::unique_lock<std::mutex> lk(mutex);
603
174
        if (!current)
187
        if (!current)
605
175
            advance_current_buffer(lk);
188
            BOOST_THROW_EXCEPTION(
606
189
                std::logic_error{
607
190
                    "Current buffer requested before waiting for buffer to arrive"});
608
176
        return current->client_buffer();
191
        return current->client_buffer();
609
177
    }
192
    }
610
178
193
611
@@ -180,7 +195,9 @@
612
180
    {
195
    {
613
181
        std::unique_lock<std::mutex> lk(mutex);
196
        std::unique_lock<std::mutex> lk(mutex);
614
182
        if (!current)
197
        if (!current)
616
183
            advance_current_buffer(lk);
198
            BOOST_THROW_EXCEPTION(
617
199
                std::logic_error{
618
200
                    "Current buffer requested before waiting for buffer to arrive"});
619
184
        return current->rpc_id();
201
        return current->rpc_id();
620
185
    }
202
    }
621
186
203
622
@@ -188,16 +205,23 @@
623
188
    {
205
    {
624
189
        std::unique_lock<std::mutex> lk(mutex);
206
        std::unique_lock<std::mutex> lk(mutex);
625
190
        if (!current)
207
        if (!current)
627
191
            advance_current_buffer(lk);
208
            BOOST_THROW_EXCEPTION(
628
209
                std::logic_error{
629
210
                    "Attempted to submit current buffer without waiting for a buffer to become current"});
630
192
        auto c = current;
211
        auto c = current;
631
193
        current = nullptr;
212
        current = nullptr;
632
194
        lk.unlock();
213
        lk.unlock();
633
195
214
639
196
        vault.deposit(c);
215
        vault->deposit(c);
640
197
        auto wh = vault.wire_transfer_outbound(c, done);
216
        auto wh = vault->wire_transfer_outbound(c, done);
641
198
        auto f = vault.withdraw();
217
642
199
        lk.lock();
218
        vault->withdraw().then(
643
200
        future = std::move(f);
219
            [this](auto&& new_buffer)
644
220
            {
645
221
                std::lock_guard<std::mutex> lk{mutex};
646
222
647
223
                current = new_buffer.get();
648
224
            }).detach();
649
201
        return wh;
225
        return wh;
650
202
    }
226
    }
651
203
227
652
@@ -207,7 +231,7 @@
653
207
            std::unique_lock<std::mutex> lk(mutex);
231
            std::unique_lock<std::mutex> lk(mutex);
654
208
            size_ = size;
232
            size_ = size;
655
209
        }
233
        }
657
210
        vault.set_size(size);
234
        vault->set_size(size);
658
211
    }
235
    }
659
212
236
660
213
    geom::Size size() const
237
    geom::Size size() const
661
@@ -218,14 +242,14 @@
662
218
242
663
219
    void lost_connection()
243
    void lost_connection()
664
220
    {
244
    {
666
221
        vault.disconnected();
245
        vault->disconnected();
667
222
    }
246
    }
668
223
247
669
224
    MirWaitHandle* set_scale(float scale, mf::BufferStreamId)
248
    MirWaitHandle* set_scale(float scale, mf::BufferStreamId)
670
225
    {
249
    {
671
226
        scale_wait_handle.expect_result();
250
        scale_wait_handle.expect_result();
672
227
        scale_wait_handle.result_received();
251
        scale_wait_handle.result_received();
674
228
        vault.set_scale(scale);
252
        vault->set_scale(scale);
675
229
        return &scale_wait_handle;
253
        return &scale_wait_handle;
676
230
    }
254
    }
677
231
255
678
@@ -233,15 +257,24 @@
679
233
    {
257
    {
680
234
        std::unique_lock<decltype(mutex)> lk(mutex);
258
        std::unique_lock<decltype(mutex)> lk(mutex);
681
235
        interval = std::max(0, std::min(1, interval));
259
        interval = std::max(0, std::min(1, interval));
690
236
        vault.set_interval(interval);
260
        vault->set_interval(interval);
691
237
    }
261
    }
692
238
262
693
239
    // Future must be before vault, to ensure vault's destruction marks future
263
694
240
    // as ready.
264
private:
695
241
    mir::client::NoTLSFuture<std::shared_ptr<mcl::MirBuffer>> future;
265
    BufferDepository(
696
242
266
        std::shared_ptr<mcl::MirBuffer> initial_buffer,
697
243
    mcl::BufferVault vault;
267
        std::unique_ptr<mcl::BufferVault>&& vault,
698
268
        geom::Size size) :
699
269
        vault{std::move(vault)},
700
270
        current{initial_buffer},
701
271
        size_{size}
702
272
    {
703
273
    }
704
274
705
275
    std::unique_ptr<mcl::BufferVault> vault;
706
244
    std::mutex mutable mutex;
276
    std::mutex mutable mutex;
707
277
    std::mutex current_buffer_mutex;
708
245
    std::shared_ptr<mcl::MirBuffer> current{nullptr};
278
    std::shared_ptr<mcl::MirBuffer> current{nullptr};
709
246
    MirWaitHandle scale_wait_handle;
279
    MirWaitHandle scale_wait_handle;
710
247
    geom::Size size_;
280
    geom::Size size_;
711
@@ -249,12 +282,17 @@
712
249
}
282
}
713
250
}
283
}
714
251
284
715
285
<<<<<<< TREE
716
252
#pragma GCC diagnostic push
286
#pragma GCC diagnostic push
717
253
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
287
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
718
254
mcl::BufferStream::BufferStream(
288
mcl::BufferStream::BufferStream(
719
289
=======
720
290
mcl::NoTLSFuture<std::unique_ptr<mcl::BufferStream>>
721
291
mcl::BufferStream::create(
722
292
>>>>>>> MERGE-SOURCE
723
255
    MirConnection* connection,
293
    MirConnection* connection,
724
256
    MirRenderSurface* render_surface,
294
    MirRenderSurface* render_surface,
726
257
    std::shared_ptr<MirWaitHandle> creation_wait_handle,
295
    std::shared_ptr<MirWaitHandle> const& creation_wait_handle,
727
258
    mclr::DisplayServer& server,
296
    mclr::DisplayServer& server,
728
259
    std::shared_ptr<mcl::ClientPlatform> const& client_platform,
297
    std::shared_ptr<mcl::ClientPlatform> const& client_platform,
729
260
    std::weak_ptr<mcl::SurfaceMap> const& map,
298
    std::weak_ptr<mcl::SurfaceMap> const& map,
730
@@ -264,22 +302,87 @@
731
264
    std::string const& surface_name,
302
    std::string const& surface_name,
732
265
    geom::Size ideal_size,
303
    geom::Size ideal_size,
733
266
    size_t nbuffers)
304
    size_t nbuffers)
734
305
{
735
306
    auto protobuf_bs = mcl::make_protobuf_object(a_protobuf_bs);
736
307
737
308
    if (!protobuf_bs->has_id())
738
309
    {
739
310
        if (!protobuf_bs->has_error())
740
311
            protobuf_bs->set_error("Error processing buffer stream create response, no ID (disconnected?)");
741
312
    }
742
313
743
314
    if (protobuf_bs->has_error())
744
315
    {
745
316
        if (protobuf_bs->has_buffer())
746
317
        {
747
318
            for (int i = 0; i < protobuf_bs->buffer().fd_size(); i++)
748
319
                ::close(protobuf_bs->buffer().fd(i));
749
320
        }
750
321
751
322
        BOOST_THROW_EXCEPTION(std::runtime_error("Can not create buffer stream: " + std::string(protobuf_bs->error())));
752
323
    }
753
324
754
325
755
326
    auto future_depository = BufferDepository::create(
756
327
        client_platform->create_buffer_factory(), factory,
757
328
        std::make_shared<Requests>(server, protobuf_bs->id().value()), map,
758
329
        ideal_size, static_cast<MirPixelFormat>(protobuf_bs->pixel_format()),
759
330
        protobuf_bs->buffer_usage(), nbuffers);
760
331
761
332
    return future_depository.then(
762
333
        [=, raw_protobuf_bs = protobuf_bs.release(), raw_server = &server](auto&& depository)
763
334
        {
764
335
            std::unique_ptr<mp::BufferStream> protobuf_bs{raw_protobuf_bs};
765
336
            // Can't use make_unique because the constructor is private to it.
766
337
            return std::unique_ptr<BufferStream>{
767
338
                new BufferStream{
768
339
                    *raw_server,
769
340
                    connection,
770
341
                    render_surface,
771
342
                    creation_wait_handle,
772
343
                    depository.get(),
773
344
                    client_platform,
774
345
                    map,
775
346
                    std::move(protobuf_bs),
776
347
                    perf_report,
777
348
                    surface_name,
778
349
                    ideal_size}};
779
350
        }
780
351
    );
781
352
}
782
353
783
354
mcl::BufferStream::BufferStream(
784
355
    rpc::DisplayServer& server,
785
356
    MirConnection* connection,
786
357
    MirRenderSurface* render_surface,
787
358
    std::shared_ptr<MirWaitHandle> const& creation_wait_handle,
788
359
    std::unique_ptr<BufferDepository>&& depository,
789
360
    std::shared_ptr<mcl::ClientPlatform> const& client_platform,
790
361
    std::weak_ptr<mcl::SurfaceMap> const& map,
791
362
    std::unique_ptr<mp::BufferStream>&& incoming_protobuf_bs,
792
363
    std::shared_ptr<mcl::PerfReport> const& perf_report,
793
364
    std::string const& surface_name,
794
365
    geom::Size ideal_size)
795
267
    : connection_(connection),
366
    : connection_(connection),
796
268
      client_platform(client_platform),
367
      client_platform(client_platform),
798
269
      protobuf_bs{mcl::make_protobuf_object<mir::protobuf::BufferStream>(a_protobuf_bs)},
368
      protobuf_bs{std::move(incoming_protobuf_bs)},
799
270
      user_swap_interval(parse_env_for_swap_interval()),
369
      user_swap_interval(parse_env_for_swap_interval()),
800
370
<<<<<<< TREE
801
271
      using_client_side_vsync(false),
371
      using_client_side_vsync(false),
802
272
      interval_config{server, frontend::BufferStreamId{a_protobuf_bs.id().value()}},
372
      interval_config{server, frontend::BufferStreamId{a_protobuf_bs.id().value()}},
803
373
=======
804
374
      interval_config{server, frontend::BufferStreamId{this->protobuf_bs->id().value()}},
805
375
>>>>>>> MERGE-SOURCE
806
273
      scale_(1.0f),
376
      scale_(1.0f),
807
274
      perf_report(perf_report),
377
      perf_report(perf_report),
808
275
      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()},
378
      protobuf_void{mcl::make_protobuf_object<mir::protobuf::Void>()},
809
379
      buffer_depository{std::move(depository)},
810
276
      ideal_buffer_size(ideal_size),
380
      ideal_buffer_size(ideal_size),
813
277
      nbuffers(nbuffers),
381
      creation_wait_handle{creation_wait_handle},
812
278
      creation_wait_handle(creation_wait_handle),
814
279
      map(map),
382
      map(map),
815
280
      factory(factory),
816
281
      render_surface_(render_surface)
383
      render_surface_(render_surface)
817
282
{
384
{
818
385
<<<<<<< TREE
819
283
    /*
386
    /*
820
284
     * Since we try to use client-side vsync where possible, a separate
387
     * Since we try to use client-side vsync where possible, a separate
821
285
     * copy of the current swap interval is required to represent that
388
     * copy of the current swap interval is required to represent that
822
@@ -306,9 +409,12 @@
823
306
409
824
307
        BOOST_THROW_EXCEPTION(std::runtime_error("Can not create buffer stream: " + std::string(protobuf_bs->error())));
410
        BOOST_THROW_EXCEPTION(std::runtime_error("Can not create buffer stream: " + std::string(protobuf_bs->error())));
825
308
    }
411
    }
826
412
=======
827
413
>>>>>>> MERGE-SOURCE
828
309
414
829
310
    try
415
    try
830
311
    {
416
    {
831
417
<<<<<<< TREE
832
312
        buffer_depository = std::make_unique<BufferDepository>(
418
        buffer_depository = std::make_unique<BufferDepository>(
833
313
            client_platform->create_buffer_factory(), factory,
419
            client_platform->create_buffer_factory(), factory,
834
314
            std::make_shared<Requests>(server, protobuf_bs->id().value(), client_platform),
420
            std::make_shared<Requests>(server, protobuf_bs->id().value(), client_platform),
835
@@ -316,6 +422,8 @@
836
316
            ideal_buffer_size, static_cast<MirPixelFormat>(protobuf_bs->pixel_format()), 
422
            ideal_buffer_size, static_cast<MirPixelFormat>(protobuf_bs->pixel_format()), 
837
317
            protobuf_bs->buffer_usage(), nbuffers);
423
            protobuf_bs->buffer_usage(), nbuffers);
838
318
424
839
425
=======
840
426
>>>>>>> MERGE-SOURCE
841
319
        egl_native_window_ = client_platform->create_egl_native_window(this);
427
        egl_native_window_ = client_platform->create_egl_native_window(this);
842
320
428
843
321
        // This might seem like something to provide during creation but
429
        // This might seem like something to provide during creation but
844
322
430
845
=== modified file 'src/client/buffer_stream.h'
846
--- src/client/buffer_stream.h	2017-03-20 11:24:19 +0000
847
+++ src/client/buffer_stream.h	2017-03-28 00:17:49 +0000
848
@@ -26,10 +26,15 @@
849
26
#include "mir/geometry/size.h"
26
#include "mir/geometry/size.h"
850
27
#include "mir/optional_value.h"
27
#include "mir/optional_value.h"
851
28
#include "buffer_stream_configuration.h"
28
#include "buffer_stream_configuration.h"
852
29
<<<<<<< TREE
853
29
#include "frame_clock.h"
30
#include "frame_clock.h"
854
31
=======
855
32
#include "no_tls_future-inl.h"
856
33
>>>>>>> MERGE-SOURCE
857
30
34
858
31
#include "mir_toolkit/client_types.h"
35
#include "mir_toolkit/client_types.h"
859
32
36
860
37
861
33
#include <EGL/eglplatform.h>
38
#include <EGL/eglplatform.h>
862
34
39
863
35
#include <unordered_set>
40
#include <unordered_set>
864
@@ -74,15 +79,19 @@
865
74
class BufferStream : public EGLNativeSurface, public MirBufferStream
79
class BufferStream : public EGLNativeSurface, public MirBufferStream
866
75
{
80
{
867
76
public:
81
public:
868
82
<<<<<<< TREE
869
77
    BufferStream(
83
    BufferStream(
870
78
        mir::client::rpc::DisplayServer& server,
84
        mir::client::rpc::DisplayServer& server,
871
79
        std::weak_ptr<SurfaceMap> const& map);
85
        std::weak_ptr<SurfaceMap> const& map);
872
80
#pragma GCC diagnostic push
86
#pragma GCC diagnostic push
873
81
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
87
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
874
82
    BufferStream(
88
    BufferStream(
875
89
=======
876
90
    static NoTLSFuture<std::unique_ptr<BufferStream>> create(
877
91
>>>>>>> MERGE-SOURCE
878
83
        MirConnection* connection,
92
        MirConnection* connection,
879
84
        MirRenderSurface* render_surface,
93
        MirRenderSurface* render_surface,
881
85
        std::shared_ptr<MirWaitHandle> creation_wait_handle,
94
        std::shared_ptr<MirWaitHandle> const& creation_wait_handle,
882
86
        mir::client::rpc::DisplayServer& server,
95
        mir::client::rpc::DisplayServer& server,
883
87
        std::shared_ptr<ClientPlatform> const& native_window_factory,
96
        std::shared_ptr<ClientPlatform> const& native_window_factory,
884
88
        std::weak_ptr<SurfaceMap> const& map,
97
        std::weak_ptr<SurfaceMap> const& map,
885
@@ -139,6 +148,19 @@
886
139
    BufferStream& operator=(BufferStream const&) = delete;
148
    BufferStream& operator=(BufferStream const&) = delete;
887
140
149
888
141
private:
150
private:
889
151
    BufferStream(
890
152
        rpc::DisplayServer& server,
891
153
        MirConnection* connection,
892
154
        MirRenderSurface* render_surface,
893
155
        std::shared_ptr<MirWaitHandle> const& creation_wait_handle,
894
156
        std::unique_ptr<BufferDepository>&& depository,
895
157
        std::shared_ptr<ClientPlatform> const& native_window_factory,
896
158
        std::weak_ptr<SurfaceMap> const& map,
897
159
        std::unique_ptr<mir::protobuf::BufferStream>&& protobuf_bs,
898
160
        std::shared_ptr<PerfReport> const& perf_report,
899
161
        std::string const& surface_name,
900
162
        geometry::Size ideal_size);
901
163
902
142
    void process_buffer(protobuf::Buffer const& buffer);
164
    void process_buffer(protobuf::Buffer const& buffer);
903
143
    void process_buffer(protobuf::Buffer const& buffer, std::unique_lock<std::mutex>&);
165
    void process_buffer(protobuf::Buffer const& buffer, std::unique_lock<std::mutex>&);
904
144
    MirWaitHandle* set_server_swap_interval(int i);
166
    MirWaitHandle* set_server_swap_interval(int i);
905
@@ -165,13 +187,15 @@
906
165
187
907
166
    std::unique_ptr<BufferDepository> buffer_depository;
188
    std::unique_ptr<BufferDepository> buffer_depository;
908
167
    geometry::Size ideal_buffer_size;
189
    geometry::Size ideal_buffer_size;
909
168
    size_t const nbuffers;
910
169
    std::string error_message;
190
    std::string error_message;
912
170
    std::shared_ptr<MirWaitHandle> creation_wait_handle;
191
    std::shared_ptr<MirWaitHandle> const creation_wait_handle;
913
171
    std::weak_ptr<SurfaceMap> const map;
192
    std::weak_ptr<SurfaceMap> const map;
914
193
<<<<<<< TREE
915
172
    std::shared_ptr<AsyncBufferFactory> const factory;
194
    std::shared_ptr<AsyncBufferFactory> const factory;
916
173
#pragma GCC diagnostic push
195
#pragma GCC diagnostic push
917
174
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
196
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
918
197
=======
919
198
>>>>>>> MERGE-SOURCE
920
175
    MirRenderSurface* render_surface_;
199
    MirRenderSurface* render_surface_;
921
176
#pragma GCC diagnostic pop
200
#pragma GCC diagnostic pop
922
177
201
923
178
202
924
=== modified file 'src/client/buffer_stream_configuration.cpp'
925
--- src/client/buffer_stream_configuration.cpp	2017-01-18 02:29:37 +0000
926
+++ src/client/buffer_stream_configuration.cpp	2017-03-28 00:17:49 +0000
927
@@ -29,6 +29,14 @@
928
29
{
29
{
929
30
}
30
}
930
31
31
931
32
mcl::BufferStreamConfiguration::BufferStreamConfiguration(
932
33
    BufferStreamConfiguration&& from)
933
34
    : server{from.server},
934
35
      id{from.id},
935
36
      protobuf_void{std::move(from.protobuf_void)}
936
37
{
937
38
}
938
39
939
32
void mcl::BufferStreamConfiguration::on_swap_interval_set(int interval)
40
void mcl::BufferStreamConfiguration::on_swap_interval_set(int interval)
940
33
{
41
{
941
34
    std::unique_lock<decltype(mutex)> lock(mutex);
42
    std::unique_lock<decltype(mutex)> lock(mutex);
942
35
43
943
=== modified file 'src/client/buffer_stream_configuration.h'
944
--- src/client/buffer_stream_configuration.h	2017-01-18 02:29:37 +0000
945
+++ src/client/buffer_stream_configuration.h	2017-03-28 00:17:49 +0000
946
@@ -33,6 +33,7 @@
947
33
{
33
{
948
34
public:
34
public:
949
35
    BufferStreamConfiguration(rpc::DisplayServer& server, frontend::BufferStreamId id);
35
    BufferStreamConfiguration(rpc::DisplayServer& server, frontend::BufferStreamId id);
950
36
    BufferStreamConfiguration(BufferStreamConfiguration&& from);
951
36
37
952
37
    void on_swap_interval_set(int interval);
38
    void on_swap_interval_set(int interval);
953
38
    int swap_interval() const;
39
    int swap_interval() const;
954
39
40
955
=== modified file 'src/client/buffer_vault.cpp'
956
--- src/client/buffer_vault.cpp	2017-01-30 08:13:20 +0000
957
+++ src/client/buffer_vault.cpp	2017-03-28 00:17:49 +0000
958
@@ -28,6 +28,7 @@
959
28
#include "buffer_factory.h"
28
#include "buffer_factory.h"
960
29
#include "buffer.h"
29
#include "buffer.h"
961
30
#include <algorithm>
30
#include <algorithm>
962
31
#include <experimental/optional>
963
31
#include <boost/throw_exception.hpp>
32
#include <boost/throw_exception.hpp>
964
32
33
965
33
namespace mcl = mir::client;
34
namespace mcl = mir::client;
966
@@ -271,14 +272,30 @@
967
271
        }
272
        }
968
272
    }
273
    }
969
273
274
970
275
    auto cb = deferred_cb;
971
276
    deferred_cb = {};
972
277
    std::experimental::optional<decltype(promises)::value_type> buffer_promise;
973
278
974
274
    if (!promises.empty())
279
    if (!promises.empty())
975
275
    {
280
    {
976
276
        buffers[buffer_id] = Owner::ContentProducer;
281
        buffers[buffer_id] = Owner::ContentProducer;
982
277
        promises.front().set_value(buffer);
282
        // Satisfying a promise might call continuation code on this stack.
983
278
        promises.pop_front();
283
        // We need to
984
279
    }
284
        buffer_promise = std::move(promises.front());
985
280
285
        promises.pop_front();;
986
281
    trigger_callback(std::move(lk));
286
    }
987
287
988
288
    lk.unlock();
989
289
990
290
    if (buffer_promise)
991
291
    {
992
292
        buffer_promise->set_value(buffer);
993
293
    }
994
294
    if (cb)
995
295
    {
996
296
        cb();
997
297
        swap_buffers_wait_handle.result_received();
998
298
    }
999
282
}
299
}
1000
283
300
1001
284
void mcl::BufferVault::disconnected()
301
void mcl::BufferVault::disconnected()
1002
285
302
1003
=== added file 'src/client/client_buffer_stream_factory.h.THIS'
1004
--- src/client/client_buffer_stream_factory.h.THIS	1970-01-01 00:00:00 +0000
1005
+++ src/client/client_buffer_stream_factory.h.THIS	2017-03-28 00:17:49 +0000
1006
@@ -0,0 +1,66 @@
1007
1
/*
1008
2
 * Copyright © 2015 Canonical Ltd.
1009
3
 *
1010
4
 * This program is free software: you can redistribute it and/or modify it
1011
5
 * under the terms of the GNU Lesser General Public License version 3,
1012
6
 * as published by the Free Software Foundation.
1013
7
 *
1014
8
 * This program is distributed in the hope that it will be useful,
1015
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1016
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1017
11
 * GNU Lesser General Public License for more details.
1018
12
 *
1019
13
 * You should have received a copy of the GNU Lesser General Public License
1020
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1021
15
 *
1022
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
1023
17
 */
1024
18
1025
19
#ifndef MIR_CLIENT_CLIENT_BUFFER_STREAM_FACTORY_H_
1026
20
#define MIR_CLIENT_CLIENT_BUFFER_STREAM_FACTORY_H_
1027
21
1028
22
#include "mir_protobuf.pb.h"
1029
23
1030
24
#include "mir_toolkit/client_types.h"
1031
25
1032
26
#include <memory>
1033
27
1034
28
class MirConnection;
1035
29
1036
30
namespace mir
1037
31
{
1038
32
namespace client
1039
33
{
1040
34
class ClientBufferStream;
1041
35
class BufferStream;
1042
36
class ClientBufferStreamFactory
1043
37
{
1044
38
public:
1045
39
    virtual std::shared_ptr<ClientBufferStream> make_consumer_stream(
1046
40
        MirConnection* allocating_connection,
1047
41
        protobuf::DisplayServer& server,
1048
42
        protobuf::BufferStream const& protobuf_bs,
1049
43
        std::string const& surface_name) = 0;
1050
44
    virtual std::shared_ptr<ClientBufferStream> make_producer_stream(
1051
45
       MirConnection* allocating_connection,
1052
46
       protobuf::DisplayServer& server,
1053
47
       protobuf::BufferStream const& protobuf_bs,
1054
48
       std::string const& surface_name) = 0;
1055
49
1056
50
    // For creating buffer stream owned by client.
1057
51
    virtual ClientBufferStream* make_producer_stream(
1058
52
       MirConnection* allocating_connection,
1059
53
       protobuf::DisplayServer& server,
1060
54
       protobuf::BufferStreamParameters const& params,
1061
55
       mir_buffer_stream_callback callback, void* context) = 0;
1062
56
1063
57
protected:
1064
58
    ClientBufferStreamFactory() = default;
1065
59
    virtual ~ClientBufferStreamFactory() = default;
1066
60
    ClientBufferStreamFactory(const ClientBufferStreamFactory&) = delete;
1067
61
    ClientBufferStreamFactory& operator=(const ClientBufferStreamFactory&) = delete;
1068
62
};
1069
63
}
1070
64
}
1071
65
1072
66
#endif // MIR_CLIENT_CLIENT_BUFFER_STREAM_FACTORY_H_
1073
0
67
1074
=== modified file 'src/client/connection_configuration.h'
1075
--- src/client/connection_configuration.h	2017-02-15 14:45:41 +0000
1076
+++ src/client/connection_configuration.h	2017-03-28 00:17:49 +0000
1077
@@ -37,6 +37,11 @@
1078
37
class Logger;
37
class Logger;
1079
38
}
38
}
1080
39
39
1081
40
namespace dispatch
1082
41
{
1083
42
class ActionQueue;
1084
43
}
1085
44
1086
40
namespace client
45
namespace client
1087
41
{
46
{
1088
42
namespace rpc
47
namespace rpc
1089
@@ -51,11 +56,17 @@
1090
51
class EventHandlerRegister;
56
class EventHandlerRegister;
1091
52
class AsyncBufferFactory;
57
class AsyncBufferFactory;
1092
53
58
1093
59
namespace rpc
1094
60
{
1095
61
class MirBasicRpcChannel;
1096
62
}
1097
63
1098
54
class ConnectionConfiguration
64
class ConnectionConfiguration
1099
55
{
65
{
1100
56
public:
66
public:
1101
57
    virtual ~ConnectionConfiguration() = default;
67
    virtual ~ConnectionConfiguration() = default;
1102
58
68
1103
69
    virtual std::shared_ptr<dispatch::ActionQueue> the_delayed_queue() = 0;
1104
59
    virtual std::shared_ptr<ConnectionSurfaceMap> the_surface_map() = 0;
70
    virtual std::shared_ptr<ConnectionSurfaceMap> the_surface_map() = 0;
1105
60
    virtual std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> the_rpc_channel() = 0;
71
    virtual std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> the_rpc_channel() = 0;
1106
61
    virtual std::shared_ptr<mir::logging::Logger> the_logger() = 0;
72
    virtual std::shared_ptr<mir::logging::Logger> the_logger() = 0;
1107
62
73
1108
=== modified file 'src/client/connection_surface_map.cpp'
1109
--- src/client/connection_surface_map.cpp	2017-03-14 04:41:33 +0000
1110
+++ src/client/connection_surface_map.cpp	2017-03-28 00:17:49 +0000
1111
@@ -20,26 +20,78 @@
1112
20
#include "mir_surface.h"
20
#include "mir_surface.h"
1113
21
#include "presentation_chain.h"
21
#include "presentation_chain.h"
1114
22
22
1115
23
#include "mir/dispatch/action_queue.h"
1116
24
1117
23
#include <boost/throw_exception.hpp>
25
#include <boost/throw_exception.hpp>
1118
24
#include <sstream>
26
#include <sstream>
1119
25
27
1120
26
namespace mcl=mir::client;
28
namespace mcl=mir::client;
1121
27
namespace mf=mir::frontend;
29
namespace mf=mir::frontend;
1122
28
30
1123
31
<<<<<<< TREE
1124
29
using mir::client::ConnectionSurfaceMap;
32
using mir::client::ConnectionSurfaceMap;
1125
30
using mir::frontend::SurfaceId;
33
using mir::frontend::SurfaceId;
1126
31
using mir::frontend::BufferStreamId;
34
using mir::frontend::BufferStreamId;
1127
32
35
1128
33
std::shared_ptr<MirWindow> ConnectionSurfaceMap::surface(SurfaceId id) const
36
std::shared_ptr<MirWindow> ConnectionSurfaceMap::surface(SurfaceId id) const
1130
34
{
37
=======
1131
38
mcl::ConnectionSurfaceMap::ConnectionSurfaceMap(
1132
39
    std::shared_ptr<dispatch::ActionQueue> delayed_queue)
1133
40
    : delayed_queue{delayed_queue}
1134
41
{
1135
42
}
1136
43
1137
44
void mcl::ConnectionSurfaceMap::with_surface_do(
1138
45
    mf::SurfaceId surface_id, std::function<void(MirSurface*)> const& exec) const
1139
46
>>>>>>> MERGE-SOURCE
1140
47
{
1141
48
    {
1142
49
        std::lock_guard<decltype(reserved_guard)> lock{reserved_guard};
1143
50
        auto const it = surface_reservations.find(surface_id);
1144
51
        if (it != surface_reservations.end())
1145
52
        {
1146
53
            it->second.push_back(exec);
1147
54
            return;
1148
55
        }
1149
56
    }
1150
57
1151
35
    std::shared_lock<decltype(guard)> lk(guard);
58
    std::shared_lock<decltype(guard)> lk(guard);
1152
36
    auto const found = surfaces.find(id);
59
    auto const found = surfaces.find(id);
1153
37
    return found != surfaces.end() ? found->second : nullptr;
60
    return found != surfaces.end() ? found->second : nullptr;
1154
38
}
61
}
1155
39
62
1156
63
<<<<<<< TREE
1157
40
void mcl::ConnectionSurfaceMap::insert(mf::SurfaceId surface_id, std::shared_ptr<MirWindow> const& surface)
64
void mcl::ConnectionSurfaceMap::insert(mf::SurfaceId surface_id, std::shared_ptr<MirWindow> const& surface)
1158
65
=======
1159
66
void mcl::ConnectionSurfaceMap::reserve(mf::SurfaceId surface_id)
1160
67
{
1161
68
    std::lock_guard<decltype(reserved_guard)> lock{reserved_guard};
1162
69
    surface_reservations[surface_id] = {};
1163
70
}
1164
71
1165
72
1166
73
1167
74
void mcl::ConnectionSurfaceMap::insert(mf::SurfaceId surface_id, std::shared_ptr<MirSurface> const& surface)
1168
75
>>>>>>> MERGE-SOURCE
1169
41
{
76
{
1170
42
    std::lock_guard<decltype(guard)> lk(guard);
77
    std::lock_guard<decltype(guard)> lk(guard);
1171
78
    std::lock_guard<decltype(reserved_guard)> lock{reserved_guard};
1172
79
    for (auto& func : surface_reservations[surface_id])
1173
80
    {
1174
81
        delayed_queue->enqueue(
1175
82
            [this, surface_id, exec = std::move(func)]()
1176
83
            {
1177
84
                std::shared_lock<decltype(guard)> lk(guard);
1178
85
                auto const it = surfaces.find(surface_id);
1179
86
                if (it != surfaces.end())
1180
87
                {
1181
88
                    auto const surface = it->second;
1182
89
                    lk.unlock();
1183
90
                    exec(surface.get());
1184
91
                }
1185
92
            });
1186
93
    }
1187
94
    surface_reservations.erase(surface_id);
1188
43
    surfaces[surface_id] = surface;
95
    surfaces[surface_id] = surface;
1189
44
}
96
}
1190
45
97
1191
46
98
1192
=== modified file 'src/client/connection_surface_map.h'
1193
--- src/client/connection_surface_map.h	2017-03-14 04:41:33 +0000
1194
+++ src/client/connection_surface_map.h	2017-03-28 00:17:49 +0000
1195
@@ -23,19 +23,43 @@
1196
23
23
1197
24
#include <shared_mutex>
24
#include <shared_mutex>
1198
25
#include <unordered_map>
25
#include <unordered_map>
1199
26
#include <vector>
1200
26
27
1201
27
class MirPresentationChain;
28
class MirPresentationChain;
1202
28
class MirRenderSurface;
29
class MirRenderSurface;
1203
29
namespace mir
30
namespace mir
1204
30
{
31
{
1205
32
namespace dispatch
1206
33
{
1207
34
class ActionQueue;
1208
35
}
1209
31
namespace client
36
namespace client
1210
32
{
37
{
1211
33
class MirBuffer;
38
class MirBuffer;
1212
34
class ConnectionSurfaceMap : public SurfaceMap
39
class ConnectionSurfaceMap : public SurfaceMap
1213
35
{
40
{
1214
36
public:
41
public:
1215
42
<<<<<<< TREE
1216
37
    virtual std::shared_ptr<MirWindow> surface(frontend::SurfaceId) const override;
43
    virtual std::shared_ptr<MirWindow> surface(frontend::SurfaceId) const override;
1217
38
    void insert(frontend::SurfaceId surface_id, std::shared_ptr<MirWindow> const& surface);
44
    void insert(frontend::SurfaceId surface_id, std::shared_ptr<MirWindow> const& surface);
1218
45
=======
1219
46
    ConnectionSurfaceMap(std::shared_ptr<dispatch::ActionQueue> delayed_queue);
1220
47
1221
48
    void with_surface_do(frontend::SurfaceId surface_id, std::function<void(MirSurface*)> const& exec) const override;
1222
49
    /**
1223
50
     * Notify the surface map that a surface will be constructed.
1224
51
     *
1225
52
     * After this call, calls to with_surface_do(surface_id, functor) will succeed, but defer execution
1226
53
     * of functor until a subsequent call to insert(surface_id, surf).
1227
54
     *
1228
55
     * Any functor queued will be executed on the delayed queue, not in the stack of
1229
56
     * the insert() call.
1230
57
     *
1231
58
     * \param [in] surface_id   ID of the surface about to be created.
1232
59
     */
1233
60
    void reserve(frontend::SurfaceId surface_id);
1234
61
    void insert(frontend::SurfaceId surface_id, std::shared_ptr<MirSurface> const& surface);
1235
62
>>>>>>> MERGE-SOURCE
1236
39
    void erase(frontend::SurfaceId surface_id);
63
    void erase(frontend::SurfaceId surface_id);
1237
40
64
1238
41
    virtual std::shared_ptr<MirBufferStream> stream(frontend::BufferStreamId) const override;
65
    virtual std::shared_ptr<MirBufferStream> stream(frontend::BufferStreamId) const override;
1239
@@ -57,8 +81,16 @@
1240
57
    std::shared_ptr<MirRenderSurface> render_surface(void* render_surface_key) const;
81
    std::shared_ptr<MirRenderSurface> render_surface(void* render_surface_key) const;
1241
58
#pragma GCC diagnostic pop
82
#pragma GCC diagnostic pop
1242
59
private:
83
private:
1243
84
    std::shared_ptr<dispatch::ActionQueue> const delayed_queue;
1244
85
1245
60
    std::shared_timed_mutex mutable guard;
86
    std::shared_timed_mutex mutable guard;
1246
87
<<<<<<< TREE
1247
61
    std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirWindow>> surfaces;
88
    std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirWindow>> surfaces;
1248
89
=======
1249
90
    std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirSurface>> surfaces;
1250
91
    std::mutex mutable reserved_guard;
1251
92
    std::unordered_map<frontend::SurfaceId, std::vector<std::function<void(MirSurface*)>>> mutable surface_reservations;
1252
93
>>>>>>> MERGE-SOURCE
1253
62
    std::shared_timed_mutex mutable stream_guard;
94
    std::shared_timed_mutex mutable stream_guard;
1254
63
    std::unordered_map<frontend::BufferStreamId, std::shared_ptr<MirBufferStream>> streams;
95
    std::unordered_map<frontend::BufferStreamId, std::shared_ptr<MirBufferStream>> streams;
1255
64
    std::unordered_map<frontend::BufferStreamId, std::shared_ptr<MirPresentationChain>> chains;
96
    std::unordered_map<frontend::BufferStreamId, std::shared_ptr<MirPresentationChain>> chains;
1256
65
97
1257
=== added file 'src/client/default_client_buffer_stream_factory.cpp.THIS'
1258
--- src/client/default_client_buffer_stream_factory.cpp.THIS	1970-01-01 00:00:00 +0000
1259
+++ src/client/default_client_buffer_stream_factory.cpp.THIS	2017-03-28 00:17:49 +0000
1260
@@ -0,0 +1,87 @@
1261
1
/*
1262
2
 * Copyright © 2015 Canonical Ltd.
1263
3
 *
1264
4
 * This program is free software: you can redistribute it and/or modify it
1265
5
 * under the terms of the GNU Lesser General Public License version 3,
1266
6
 * as published by the Free Software Foundation.
1267
7
 *
1268
8
 * This program is distributed in the hope that it will be useful,
1269
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1270
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1271
11
 * GNU Lesser General Public License for more details.
1272
12
 *
1273
13
 * You should have received a copy of the GNU Lesser General Public License
1274
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1275
15
 *
1276
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
1277
17
 */
1278
18
#include "default_client_buffer_stream_factory.h"
1279
19
#include "buffer_stream.h"
1280
20
#include "perf_report.h"
1281
21
#include "logging/perf_report.h"
1282
22
#include "lttng/perf_report.h"
1283
23
1284
24
namespace mcl = mir::client;
1285
25
namespace ml = mir::logging;
1286
26
namespace mp = mir::protobuf;
1287
27
1288
28
namespace
1289
29
{
1290
30
1291
31
std::shared_ptr<mcl::PerfReport>
1292
32
make_perf_report(std::shared_ptr<ml::Logger> const& logger)
1293
33
{
1294
34
    // TODO: It seems strange that this directly uses getenv
1295
35
    const char* report_target = getenv("MIR_CLIENT_PERF_REPORT");
1296
36
    if (report_target && !strncmp(report_target, "log", strlen(report_target)))
1297
37
    {
1298
38
        return std::make_shared<mcl::logging::PerfReport>(logger);
1299
39
    }
1300
40
    else if (report_target && !strncmp(report_target, "lttng", strlen(report_target)))
1301
41
    {
1302
42
        return std::make_shared<mcl::lttng::PerfReport>();
1303
43
    }
1304
44
    else
1305
45
    {
1306
46
        return std::make_shared<mcl::NullPerfReport>();
1307
47
    }
1308
48
}
1309
49
1310
50
}
1311
51
1312
52
mcl::DefaultClientBufferStreamFactory::DefaultClientBufferStreamFactory(
1313
53
    std::shared_ptr<mcl::ClientPlatform> const& client_platform,
1314
54
    std::shared_ptr<ml::Logger> const& logger)
1315
55
    : client_platform(client_platform),
1316
56
      logger(logger)
1317
57
{
1318
58
}
1319
59
1320
60
std::shared_ptr<mcl::ClientBufferStream> mcl::DefaultClientBufferStreamFactory::make_consumer_stream(
1321
61
    MirConnection* allocating_connection,
1322
62
    mp::DisplayServer& server,
1323
63
    mp::BufferStream const& protobuf_bs,
1324
64
    std::string const& surface_name)
1325
65
{
1326
66
    return std::make_shared<mcl::BufferStream>(allocating_connection, server, mcl::BufferStreamMode::Consumer, client_platform, protobuf_bs, make_perf_report(logger), surface_name);
1327
67
}
1328
68
1329
69
std::shared_ptr<mcl::ClientBufferStream> mcl::DefaultClientBufferStreamFactory::make_producer_stream(
1330
70
    MirConnection* allocating_connection,
1331
71
    mp::DisplayServer& server,
1332
72
    mp::BufferStream const& protobuf_bs,
1333
73
    std::string const& surface_name)
1334
74
{
1335
75
    return std::make_shared<mcl::BufferStream>(allocating_connection, server, mcl::BufferStreamMode::Producer, client_platform, protobuf_bs, make_perf_report(logger), surface_name);
1336
76
}
1337
77
1338
78
1339
79
mcl::ClientBufferStream* mcl::DefaultClientBufferStreamFactory::make_producer_stream(
1340
80
    MirConnection* allocating_connection,
1341
81
    mp::DisplayServer& server,
1342
82
    mp::BufferStreamParameters const& params,
1343
83
    mir_buffer_stream_callback callback,
1344
84
    void* context)
1345
85
{
1346
86
    return new mcl::BufferStream(allocating_connection, server, client_platform, params, make_perf_report(logger), callback, context);
1347
87
}
1348
0
88
1349
=== added file 'src/client/default_client_buffer_stream_factory.h.THIS'
1350
--- src/client/default_client_buffer_stream_factory.h.THIS	1970-01-01 00:00:00 +0000
1351
+++ src/client/default_client_buffer_stream_factory.h.THIS	2017-03-28 00:17:49 +0000
1352
@@ -0,0 +1,70 @@
1353
1
/*
1354
2
 * Copyright © 2015 Canonical Ltd.
1355
3
 *
1356
4
 * This program is free software: you can redistribute it and/or modify it
1357
5
 * under the terms of the GNU Lesser General Public License version 3,
1358
6
 * as published by the Free Software Foundation.
1359
7
 *
1360
8
 * This program is distributed in the hope that it will be useful,
1361
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1362
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1363
11
 * GNU Lesser General Public License for more details.
1364
12
 *
1365
13
 * You should have received a copy of the GNU Lesser General Public License
1366
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1367
15
 *
1368
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
1369
17
 */
1370
18
1371
19
#ifndef MIR_CLIENT_DEFAULT_CLIENT_BUFFER_STREAM_FACTORY_H_
1372
20
#define MIR_CLIENT_DEFAULT_CLIENT_BUFFER_STREAM_FACTORY_H_
1373
21
1374
22
#include "client_buffer_stream_factory.h"
1375
23
1376
24
class MirConnection;
1377
25
1378
26
namespace mir
1379
27
{
1380
28
namespace logging
1381
29
{
1382
30
class Logger;
1383
31
}
1384
32
namespace client
1385
33
{
1386
34
class ClientBufferFactory;
1387
35
class ClientPlatform;
1388
36
1389
37
class DefaultClientBufferStreamFactory : public ClientBufferStreamFactory
1390
38
{
1391
39
public:
1392
40
    DefaultClientBufferStreamFactory(
1393
41
        std::shared_ptr<ClientPlatform> const& native_window_factory,
1394
42
        std::shared_ptr<logging::Logger> const& logger);
1395
43
    virtual ~DefaultClientBufferStreamFactory() = default;
1396
44
1397
45
    std::shared_ptr<ClientBufferStream> make_consumer_stream(
1398
46
        MirConnection* allocating_connection,
1399
47
        protobuf::DisplayServer& server,
1400
48
        protobuf::BufferStream const& protobuf_bs,
1401
49
        std::string const& surface_name) override;
1402
50
    std::shared_ptr<ClientBufferStream> make_producer_stream(
1403
51
       MirConnection* allocating_connection,
1404
52
       protobuf::DisplayServer& server,
1405
53
       protobuf::BufferStream const& protobuf_bs,
1406
54
       std::string const& surface_name) override;
1407
55
1408
56
    ClientBufferStream* make_producer_stream(
1409
57
       MirConnection* allocating_connection,
1410
58
       protobuf::DisplayServer& server,
1411
59
       protobuf::BufferStreamParameters const& params,
1412
60
       mir_buffer_stream_callback callback, void* context) override;
1413
61
1414
62
private:
1415
63
    std::shared_ptr<ClientPlatform> const client_platform;
1416
64
    std::shared_ptr<logging::Logger> const logger;
1417
65
1418
66
};
1419
67
}
1420
68
}
1421
69
1422
70
#endif // MIR_CLIENT_DEFAULT_CLIENT_BUFFER_STREAM_FACTORY_H_
1423
0
71
1424
=== modified file 'src/client/default_connection_configuration.cpp'
1425
--- src/client/default_connection_configuration.cpp	2017-02-15 14:45:41 +0000
1426
+++ src/client/default_connection_configuration.cpp	2017-03-28 00:17:49 +0000
1427
@@ -37,8 +37,10 @@
1428
37
#include "probing_client_platform_factory.h"
37
#include "probing_client_platform_factory.h"
1429
38
#include "mir_event_distributor.h"
38
#include "mir_event_distributor.h"
1430
39
#include "buffer_factory.h"
39
#include "buffer_factory.h"
1431
40
#include "mir/dispatch/action_queue.h"
1432
40
41
1433
41
namespace mcl = mir::client;
42
namespace mcl = mir::client;
1434
43
namespace md = mir::dispatch;
1435
42
44
1436
43
namespace
45
namespace
1437
44
{
46
{
1438
@@ -53,12 +55,23 @@
1439
53
{
55
{
1440
54
}
56
}
1441
55
57
1442
58
std::shared_ptr<md::ActionQueue>
1443
59
mcl::DefaultConnectionConfiguration::the_delayed_queue()
1444
60
{
1445
61
    return delayed_queue(
1446
62
        []()
1447
63
        {
1448
64
            return std::make_shared<md::ActionQueue>();
1449
65
        });
1450
66
}
1451
67
1452
56
std::shared_ptr<mcl::ConnectionSurfaceMap>
68
std::shared_ptr<mcl::ConnectionSurfaceMap>
1453
57
mcl::DefaultConnectionConfiguration::the_surface_map()
69
mcl::DefaultConnectionConfiguration::the_surface_map()
1454
58
{
70
{
1456
59
    return surface_map([]
71
    return surface_map(
1457
72
        [this]()
1458
60
        {
73
        {
1460
61
            return std::make_shared<mcl::ConnectionSurfaceMap>();
74
            return std::make_shared<mcl::ConnectionSurfaceMap>(the_delayed_queue());
1461
62
        });
75
        });
1462
63
}
76
}
1463
64
77
1464
65
78
1465
=== modified file 'src/client/default_connection_configuration.h'
1466
--- src/client/default_connection_configuration.h	2017-02-15 14:45:41 +0000
1467
+++ src/client/default_connection_configuration.h	2017-03-28 00:17:49 +0000
1468
@@ -50,6 +50,7 @@
1469
50
public:
50
public:
1470
51
    DefaultConnectionConfiguration(std::string const& socket_file);
51
    DefaultConnectionConfiguration(std::string const& socket_file);
1471
52
52
1472
53
    std::shared_ptr<dispatch::ActionQueue> the_delayed_queue() override;
1473
53
    std::shared_ptr<ConnectionSurfaceMap> the_surface_map() override;
54
    std::shared_ptr<ConnectionSurfaceMap> the_surface_map() override;
1474
54
    std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> the_rpc_channel() override;
55
    std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> the_rpc_channel() override;
1475
55
    std::shared_ptr<mir::logging::Logger> the_logger() override;
56
    std::shared_ptr<mir::logging::Logger> the_logger() override;
1476
@@ -69,6 +70,7 @@
1477
69
    virtual std::shared_ptr<input::receiver::InputReceiverReport> the_input_receiver_report();
70
    virtual std::shared_ptr<input::receiver::InputReceiverReport> the_input_receiver_report();
1478
70
71
1479
71
protected:
72
protected:
1480
73
    CachedPtr<dispatch::ActionQueue> delayed_queue;
1481
72
    CachedPtr<mir::client::rpc::MirBasicRpcChannel> rpc_channel;
74
    CachedPtr<mir::client::rpc::MirBasicRpcChannel> rpc_channel;
1482
73
    CachedPtr<mir::logging::Logger> logger;
75
    CachedPtr<mir::logging::Logger> logger;
1483
74
    CachedPtr<ClientPlatformFactory> client_platform_factory;
76
    CachedPtr<ClientPlatformFactory> client_platform_factory;
1484
75
77
1485
=== modified file 'src/client/error_render_surface.cpp'
1486
--- src/client/error_render_surface.cpp	2017-01-18 02:29:37 +0000
1487
+++ src/client/error_render_surface.cpp	2017-03-28 00:17:49 +0000
1488
@@ -54,10 +54,7 @@
1489
54
    return false;
54
    return false;
1490
55
}
55
}
1491
56
56
1496
57
MirBufferStream* mcl::ErrorRenderSurface::get_buffer_stream(
57
void mcl::ErrorRenderSurface::get_buffer_stream(int, int, MirPixelFormat, MirBufferUsage, mir_buffer_stream_callback, void*)
1493
58
    int /*width*/, int /*height*/,
1494
59
    MirPixelFormat /*format*/,
1495
60
    MirBufferUsage /*buffer_usage*/)
1497
61
{
58
{
1498
62
    BOOST_THROW_EXCEPTION(std::runtime_error(error));
59
    BOOST_THROW_EXCEPTION(std::runtime_error(error));
1499
63
}
60
}
1500
64
61
1501
=== modified file 'src/client/error_render_surface.h'
1502
--- src/client/error_render_surface.h	2017-03-10 19:47:57 +0000
1503
+++ src/client/error_render_surface.h	2017-03-28 00:17:49 +0000
1504
@@ -39,10 +39,13 @@
1505
39
    void set_size(mir::geometry::Size) override;
39
    void set_size(mir::geometry::Size) override;
1506
40
    bool valid() const override;
40
    bool valid() const override;
1507
41
    char const* get_error_message() const override;
41
    char const* get_error_message() const override;
1510
42
    MirBufferStream* get_buffer_stream(
42
    void get_buffer_stream(
1511
43
        int width, int height,
43
        int width,
1512
44
        int height,
1513
44
        MirPixelFormat format,
45
        MirPixelFormat format,
1515
45
        MirBufferUsage buffer_usage) override;
46
        MirBufferUsage buffer_usage,
1516
47
        mir_buffer_stream_callback callback,
1517
48
        void* context) override;
1518
46
    MirPresentationChain* get_presentation_chain() override;
49
    MirPresentationChain* get_presentation_chain() override;
1519
47
private:
50
private:
1520
48
    std::string const error;
51
    std::string const error;
1521
49
52
1522
=== modified file 'src/client/mir_buffer_stream_api.cpp'
1523
--- src/client/mir_buffer_stream_api.cpp	2017-01-24 07:37:03 +0000
1524
+++ src/client/mir_buffer_stream_api.cpp	2017-03-28 00:17:49 +0000
1525
@@ -30,25 +30,14 @@
1526
30
#include "mir/uncaught.h"
30
#include "mir/uncaught.h"
1527
31
#include "mir/require.h"
31
#include "mir/require.h"
1528
32
32
1529
33
#include "synchronous_helper.h"
1530
34
1531
33
#include <stdexcept>
35
#include <stdexcept>
1532
34
#include <boost/throw_exception.hpp>
36
#include <boost/throw_exception.hpp>
1533
35
37
1534
36
namespace mcl = mir::client;
38
namespace mcl = mir::client;
1535
37
namespace mp = mir::protobuf;
39
namespace mp = mir::protobuf;
1536
38
40
1537
39
namespace
1538
40
{
1539
41
// assign_result is compatible with all 2-parameter callbacks
1540
42
void assign_result(void* result, void** context)
1541
43
{
1542
44
    if (context)
1543
45
        *context = result;
1544
46
}
1545
47
1546
48
}
1547
49
1548
50
1549
51
1550
52
MirWaitHandle* mir_connection_create_buffer_stream(MirConnection *connection,
41
MirWaitHandle* mir_connection_create_buffer_stream(MirConnection *connection,
1551
53
    int width, int height,
42
    int width, int height,
1552
54
    MirPixelFormat format,
43
    MirPixelFormat format,
1553
@@ -72,9 +61,20 @@
1554
72
    MirBufferUsage buffer_usage)
61
    MirBufferUsage buffer_usage)
1555
73
try
62
try
1556
74
{
63
{
1557
64
<<<<<<< TREE
1558
75
    MirBufferStream *stream = nullptr;
65
    MirBufferStream *stream = nullptr;
1559
76
    mir_connection_create_buffer_stream(connection, width, height, format, buffer_usage,
66
    mir_connection_create_buffer_stream(connection, width, height, format, buffer_usage,
1560
77
        reinterpret_cast<MirBufferStreamCallback>(assign_result), &stream)->wait_for_all();
67
        reinterpret_cast<MirBufferStreamCallback>(assign_result), &stream)->wait_for_all();
1561
68
=======
1562
69
    MirBufferStream* stream = nullptr;
1563
70
    make_synchronous_call(
1564
71
        connection,
1565
72
        mir_connection_create_buffer_stream,
1566
73
        connection,
1567
74
        width, height, format, buffer_usage,
1568
75
        &assign_result<MirBufferStream>,
1569
76
        &stream);
1570
77
>>>>>>> MERGE-SOURCE
1571
78
    return stream;
78
    return stream;
1572
79
}
79
}
1573
80
catch (std::exception const& ex)
80
catch (std::exception const& ex)
1574
@@ -94,7 +94,12 @@
1575
94
94
1576
95
void mir_buffer_stream_release_sync(MirBufferStream *buffer_stream)
95
void mir_buffer_stream_release_sync(MirBufferStream *buffer_stream)
1577
96
{
96
{
1579
97
    mir_buffer_stream_release(buffer_stream, nullptr, nullptr)->wait_for_all();
97
    make_synchronous_call(
1580
98
        buffer_stream->connection(),
1581
99
        &mir_buffer_stream_release,
1582
100
        buffer_stream,
1583
101
        &assign_result<MirBufferStream>,
1584
102
        static_cast<void*>(nullptr));
1585
98
}
103
}
1586
99
104
1587
100
void mir_buffer_stream_get_current_buffer(MirBufferStream* buffer_stream, MirNativeBuffer** buffer_package_out)
105
void mir_buffer_stream_get_current_buffer(MirBufferStream* buffer_stream, MirNativeBuffer** buffer_package_out)
1588
@@ -132,6 +137,7 @@
1589
132
}
137
}
1590
133
138
1591
134
void mir_buffer_stream_swap_buffers_sync(MirBufferStream* buffer_stream)
139
void mir_buffer_stream_swap_buffers_sync(MirBufferStream* buffer_stream)
1592
140
<<<<<<< TREE
1593
135
try
141
try
1594
136
{
142
{
1595
137
    buffer_stream->swap_buffers_sync();
143
    buffer_stream->swap_buffers_sync();
1596
@@ -139,6 +145,15 @@
1597
139
catch (std::exception const& ex)
145
catch (std::exception const& ex)
1598
140
{
146
{
1599
141
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
147
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
1600
148
=======
1601
149
{
1602
150
    make_synchronous_call(
1603
151
        buffer_stream->connection(),
1604
152
        &mir_buffer_stream_swap_buffers,
1605
153
        buffer_stream,
1606
154
        &assign_result<MirBufferStream>,
1607
155
        static_cast<void*>(nullptr));
1608
156
>>>>>>> MERGE-SOURCE
1609
142
}
157
}
1610
143
158
1611
144
bool mir_buffer_stream_get_graphics_region(
159
bool mir_buffer_stream_get_graphics_region(
1612
145
160
1613
=== modified file 'src/client/mir_connection.cpp'
1614
--- src/client/mir_connection.cpp	2017-03-21 05:51:47 +0000
1615
+++ src/client/mir_connection.cpp	2017-03-28 00:17:49 +0000
1616
@@ -27,8 +27,12 @@
1617
27
#include "mir/client_platform.h"
27
#include "mir/client_platform.h"
1618
28
#include "mir/client_platform_factory.h"
28
#include "mir/client_platform_factory.h"
1619
29
#include "rpc/mir_basic_rpc_channel.h"
29
#include "rpc/mir_basic_rpc_channel.h"
1620
30
#include "rpc/mir_protobuf_rpc_channel.h"
1621
30
#include "mir/dispatch/dispatchable.h"
31
#include "mir/dispatch/dispatchable.h"
1622
32
#include "mir/dispatch/multiplexing_dispatchable.h"
1623
31
#include "mir/dispatch/threaded_dispatcher.h"
33
#include "mir/dispatch/threaded_dispatcher.h"
1624
34
#include "mir/dispatch/multiplexing_dispatchable.h"
1625
35
#include "mir/dispatch/action_queue.h"
1626
32
#include "mir/input/input_devices.h"
36
#include "mir/input/input_devices.h"
1627
33
#include "connection_configuration.h"
37
#include "connection_configuration.h"
1628
34
#include "display_configuration.h"
38
#include "display_configuration.h"
1629
@@ -53,6 +57,7 @@
1630
53
#include "mir/logging/logger.h"
57
#include "mir/logging/logger.h"
1631
54
#include "mir/platform_message.h"
58
#include "mir/platform_message.h"
1632
55
#include "mir_error.h"
59
#include "mir_error.h"
1633
60
#include "mir/require.h"
1634
56
61
1635
57
#include <algorithm>
62
#include <algorithm>
1636
58
#include <cstddef>
63
#include <cstddef>
1637
@@ -63,6 +68,7 @@
1638
63
#include <boost/throw_exception.hpp>
68
#include <boost/throw_exception.hpp>
1639
64
69
1640
65
namespace mcl = mir::client;
70
namespace mcl = mir::client;
1641
71
namespace mclr = mir::client::rpc;
1642
66
namespace md = mir::dispatch;
72
namespace md = mir::dispatch;
1643
67
namespace mircv = mir::input::receiver;
73
namespace mircv = mir::input::receiver;
1644
68
namespace mev = mir::events;
74
namespace mev = mir::events;
1645
@@ -309,8 +315,13 @@
1646
309
{
315
{
1647
310
}
316
}
1648
311
317
1649
318
MirConnection::MirConnection(mir::client::ConnectionConfiguration& conf) :
1650
319
    MirConnection(conf, DispatchType::automatic)
1651
320
{
1652
321
}
1653
322
1654
312
MirConnection::MirConnection(
323
MirConnection::MirConnection(
1656
313
    mir::client::ConnectionConfiguration& conf) :
324
    mir::client::ConnectionConfiguration& conf, DispatchType dispatch) :
1657
314
        deregisterer{this},
325
        deregisterer{this},
1658
315
        surface_map(conf.the_surface_map()),
326
        surface_map(conf.the_surface_map()),
1659
316
        buffer_factory(conf.the_buffer_factory()),
327
        buffer_factory(conf.the_buffer_factory()),
1660
@@ -330,13 +341,26 @@
1661
330
        display_configuration(conf.the_display_configuration()),
341
        display_configuration(conf.the_display_configuration()),
1662
331
        input_devices{conf.the_input_devices()},
342
        input_devices{conf.the_input_devices()},
1663
332
        lifecycle_control(conf.the_lifecycle_control()),
343
        lifecycle_control(conf.the_lifecycle_control()),
1664
344
        event_handler_register(conf.the_event_handler_register()),
1665
345
        dispatcher{std::make_shared<md::MultiplexingDispatchable>()},
1666
346
        eventloop{dispatch == DispatchType::automatic ?
1667
347
                  std::make_unique<md::ThreadedDispatcher>("RPC Dispatch", dispatcher) :
1668
348
                  nullptr
1669
349
        },
1670
333
        ping_handler{conf.the_ping_handler()},
350
        ping_handler{conf.the_ping_handler()},
1671
351
        pong_callback(google::protobuf::NewPermanentCallback(&google::protobuf::DoNothing)),
1672
352
        delayed_queue{conf.the_delayed_queue()},
1673
334
        error_handler{conf.the_error_handler()},
353
        error_handler{conf.the_error_handler()},
1674
335
        event_handler_register(conf.the_event_handler_register()),
1675
336
        pong_callback(google::protobuf::NewPermanentCallback(&google::protobuf::DoNothing)),
1676
337
        eventloop{new md::ThreadedDispatcher{"RPC Thread", std::dynamic_pointer_cast<md::Dispatchable>(channel)}},
1677
338
        nbuffers(get_nbuffers_from_env())
354
        nbuffers(get_nbuffers_from_env())
1678
339
{
355
{
1679
356
    dispatcher->add_watch(channel);
1680
357
    dispatcher->add_watch(delayed_queue);
1681
358
    if (eventloop)
1682
359
    {
1683
360
        // Need a second thread ensure RPC is not blocked if the delayed_queue blocks,
1684
361
        // as it does when waiting for surface creation.
1685
362
        eventloop->add_thread();
1686
363
    }
1687
340
    connect_result->set_error("connect not called");
364
    connect_result->set_error("connect not called");
1688
341
    {
365
    {
1689
342
        std::lock_guard<std::mutex> lock(connection_guard);
366
        std::lock_guard<std::mutex> lock(connection_guard);
1690
@@ -419,38 +443,41 @@
1691
419
    if (request_it == surface_requests.end())
443
    if (request_it == surface_requests.end())
1692
420
        return;
444
        return;
1693
421
445
1697
422
    auto surface_proto = request->response; 
446
    auto surface_proto = request->response;
1695
423
    auto callback = request->cb;
1696
424
    auto context = request->context;
1698
425
    auto const& spec = request->spec;
447
    auto const& spec = request->spec;
1699
426
    std::string name{spec.surface_name.is_set() ?
448
    std::string name{spec.surface_name.is_set() ?
1700
427
                     spec.surface_name.value() : ""};
449
                     spec.surface_name.value() : ""};
1701
450
    surface_map->reserve(mf::SurfaceId{surface_proto->id().value()});
1702
428
451
1704
429
    std::shared_ptr<MirBufferStream> default_stream {nullptr};
452
    mcl::NoTLSFuture<std::unique_ptr<mcl::BufferStream>> default_stream;
1705
430
    if (surface_proto->buffer_stream().has_id())
453
    if (surface_proto->buffer_stream().has_id())
1706
431
    {
454
    {
1707
432
        try
455
        try
1708
433
        {
456
        {
1710
434
            default_stream = std::make_shared<mcl::BufferStream>(
457
            default_stream = mcl::BufferStream::create(
1711
435
                this, nullptr, request->wh, server, platform, surface_map, buffer_factory,
458
                this, nullptr, request->wh, server, platform, surface_map, buffer_factory,
1712
436
                surface_proto->buffer_stream(), make_perf_report(logger), name,
459
                surface_proto->buffer_stream(), make_perf_report(logger), name,
1715
437
                mir::geometry::Size{surface_proto->width(), surface_proto->height()}, nbuffers);
460
                mir::geometry::Size{surface_proto->width(), surface_proto->height()},
1716
438
            surface_map->insert(default_stream->rpc_id(), default_stream);
461
                nbuffers);
1717
439
        }
462
        }
1718
440
        catch (std::exception const& error)
463
        catch (std::exception const& error)
1719
441
        {
464
        {
1720
442
            if (!surface_proto->has_error())
465
            if (!surface_proto->has_error())
1721
443
                surface_proto->set_error(error.what());
466
                surface_proto->set_error(error.what());
1722
444
            // Clean up surface_proto's direct fds; BufferStream has cleaned up any owned by
1723
445
            // surface_proto->buffer_stream()
1724
446
            for (auto i = 0; i < surface_proto->fd_size(); i++)
1725
447
                ::close(surface_proto->fd(i));
1726
448
        }
467
        }
1727
449
    }
468
    }
1728
450
469
1729
470
<<<<<<< TREE
1730
451
    std::shared_ptr<MirWindow> surf {nullptr};
471
    std::shared_ptr<MirWindow> surf {nullptr};
1731
472
=======
1732
473
>>>>>>> MERGE-SOURCE
1733
452
    if (surface_proto->has_error() || !surface_proto->has_id())
474
    if (surface_proto->has_error() || !surface_proto->has_id())
1734
453
    {
475
    {
1735
476
        // Clean up surface_proto's direct fds; BufferStream has cleaned up any owned by
1736
477
        // surface_proto->buffer_stream()
1737
478
        for (auto i = 0; i < surface_proto->fd_size(); i++)
1738
479
            ::close(surface_proto->fd(i));
1739
480
1740
454
        std::string reason;
481
        std::string reason;
1741
455
        if (surface_proto->has_error())
482
        if (surface_proto->has_error())
1742
456
            reason += surface_proto->error();
483
            reason += surface_proto->error();
1743
@@ -459,19 +486,63 @@
1744
459
        if (!surface_proto->has_id()) 
486
        if (!surface_proto->has_id()) 
1745
460
            reason +=  "Server assigned surface no id";
487
            reason +=  "Server assigned surface no id";
1746
461
        auto id = next_error_id(lock);
488
        auto id = next_error_id(lock);
1747
489
<<<<<<< TREE
1748
462
        surf = std::make_shared<MirWindow>(reason, this, id, request->wh);
490
        surf = std::make_shared<MirWindow>(reason, this, id, request->wh);
1749
491
=======
1750
492
        auto surf = std::make_shared<MirSurface>(reason, this, id, request->wh);
1751
493
>>>>>>> MERGE-SOURCE
1752
463
        surface_map->insert(id, surf);
494
        surface_map->insert(id, surf);
1753
495
1754
496
        request->cb(surf.get(), request->context);
1755
497
        request->wh->result_received();
1756
498
    }
1757
499
    else if (default_stream.valid())
1758
500
    {
1759
501
        default_stream.then(
1760
502
            [this, request = *request_it](auto&& resolved_stream) -> void
1761
503
            {
1762
504
                std::shared_ptr<MirSurface> surf;
1763
505
                std::shared_ptr<MirBufferStream> stream;
1764
506
                try
1765
507
                {
1766
508
                    stream = resolved_stream.get();
1767
509
                    surface_map->insert(stream->rpc_id(), stream);
1768
510
                }
1769
511
                catch (std::exception const& error)
1770
512
                {
1771
513
                    request->response->set_error(error.what());
1772
514
                }
1773
515
1774
516
                surf = std::make_shared<MirSurface>(
1775
517
                    this,
1776
518
                    server,
1777
519
                    &debug,
1778
520
                    stream,
1779
521
                    input_platform,
1780
522
                    request->spec,
1781
523
                    *request->response,
1782
524
                    request->wh);
1783
525
                surface_map->insert(mf::SurfaceId{request->response->id().value()}, surf);
1784
526
1785
527
                request->cb(surf.get(), request->context);
1786
528
                request->wh->result_received();
1787
529
            }).detach();
1788
464
    }
530
    }
1789
465
    else
531
    else
1790
466
    {
532
    {
1791
533
<<<<<<< TREE
1792
467
        surf = std::make_shared<MirWindow>(
534
        surf = std::make_shared<MirWindow>(
1793
468
            this, server, &debug, default_stream, spec, *surface_proto, request->wh);
535
            this, server, &debug, default_stream, spec, *surface_proto, request->wh);
1794
536
=======
1795
537
        auto surf = std::make_shared<MirSurface>(
1796
538
            this, server, &debug, nullptr, input_platform, spec, *surface_proto, request->wh);
1797
539
>>>>>>> MERGE-SOURCE
1798
469
        surface_map->insert(mf::SurfaceId{surface_proto->id().value()}, surf);
540
        surface_map->insert(mf::SurfaceId{surface_proto->id().value()}, surf);
1799
541
1800
542
        request->cb(surf.get(), request->context);
1801
543
        request->wh->result_received();
1802
470
    }
544
    }
1803
471
545
1804
472
    callback(surf.get(), context);
1805
473
    request->wh->result_received();
1806
474
1807
475
    surface_requests.erase(request_it);
546
    surface_requests.erase(request_it);
1808
476
}
547
}
1809
477
548
1810
@@ -515,17 +586,17 @@
1811
515
586
1812
516
void MirConnection::released(StreamRelease data)
587
void MirConnection::released(StreamRelease data)
1813
517
{
588
{
1814
589
    {
1815
590
        std::unique_lock<decltype(mutex)> lk(mutex);
1816
591
        if (data.rs)
1817
592
            surface_map->erase(data.rs);
1818
593
        surface_map->erase(mf::BufferStreamId(data.rpc_id));
1819
594
    }
1820
595
1821
518
    if (data.callback)
596
    if (data.callback)
1822
519
        data.callback(data.stream, data.context);
597
        data.callback(data.stream, data.context);
1823
520
    if (data.handle)
598
    if (data.handle)
1824
521
        data.handle->result_received();
599
        data.handle->result_received();
1825
522
1826
523
    {
1827
524
        std::unique_lock<decltype(mutex)> lk(mutex);
1828
525
        if (data.rs)
1829
526
            surface_map->erase(data.rs);
1830
527
        surface_map->erase(mf::BufferStreamId(data.rpc_id));
1831
528
    }
1832
529
}
600
}
1833
530
601
1834
531
void MirConnection::released(SurfaceRelease data)
602
void MirConnection::released(SurfaceRelease data)
1835
@@ -701,6 +772,36 @@
1836
701
    return &disconnect_wait_handle;
772
    return &disconnect_wait_handle;
1837
702
}
773
}
1838
703
774
1839
775
mir::Fd MirConnection::watch_fd() const
1840
776
{
1841
777
    return eventloop ? mir::Fd{} : dispatcher->watch_fd();
1842
778
}
1843
779
1844
780
void MirConnection::dispatch()
1845
781
{
1846
782
    mir::require(!eventloop);
1847
783
1848
784
    dispatcher->dispatch(md::FdEvent::readable);
1849
785
}
1850
786
1851
787
void MirConnection::add_dispatchee(std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchee)
1852
788
{
1853
789
    dispatcher->add_watch(dispatchee);
1854
790
    if (eventloop)
1855
791
    {
1856
792
        eventloop->add_thread();
1857
793
    }
1858
794
}
1859
795
1860
796
void MirConnection::remove_dispatchee(std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchee)
1861
797
{
1862
798
    dispatcher->remove_watch(dispatchee);
1863
799
    if (eventloop)
1864
800
    {
1865
801
        eventloop->remove_thread();
1866
802
    }
1867
803
}
1868
804
1869
704
void MirConnection::done_platform_operation(
805
void MirConnection::done_platform_operation(
1870
705
    MirPlatformOperationCallback callback, void* context)
806
    MirPlatformOperationCallback callback, void* context)
1871
706
{
807
{
1872
@@ -880,16 +981,34 @@
1873
880
981
1874
881
    try
982
    try
1875
882
    {
983
    {
1886
883
        auto stream = std::make_shared<mcl::BufferStream>(
984
        auto future_stream = mcl::BufferStream::create(
1887
884
            this, request->rs, request->wh, server, platform, surface_map, buffer_factory,
985
            this,
1888
885
            *protobuf_bs, make_perf_report(logger), std::string{},
986
            request->rs,
1889
886
            mir::geometry::Size{request->parameters.width(), request->parameters.height()}, nbuffers);
987
            request->wh,
1890
887
        surface_map->insert(mf::BufferStreamId(protobuf_bs->id().value()), stream);
988
            server,
1891
888
989
            platform,
1892
889
        if (request->mbs_callback)
990
            surface_map,
1893
890
            request->mbs_callback(stream.get(), request->context);
991
            buffer_factory,
1894
891
992
            *protobuf_bs,
1895
892
        request->wh->result_received();
993
            make_perf_report(logger),
1896
994
            std::string{},
1897
995
            mir::geometry::Size{request->parameters.width(), request->parameters.height()},
1898
996
            nbuffers);
1899
997
1900
998
        future_stream.then(
1901
999
            [this, request](auto&& resolved_stream) -> void
1902
1000
            {
1903
1001
                std::shared_ptr<mcl::BufferStream> stream{resolved_stream.get()};
1904
1002
                auto& protobuf_bs = request->response;
1905
1003
1906
1004
                surface_map->insert(mf::BufferStreamId(protobuf_bs->id().value()), stream);
1907
1005
1908
1006
                request->mbs_callback(
1909
1007
                    static_cast<MirBufferStream*>(stream.get()),
1910
1008
                    request->context);
1911
1009
1912
1010
                request->wh->result_received();
1913
1011
            }).detach();
1914
893
    }
1012
    }
1915
894
    catch (std::exception const& error)
1013
    catch (std::exception const& error)
1916
895
    {
1014
    {
1917
@@ -939,17 +1058,25 @@
1918
939
    return request->wh.get();
1058
    return request->wh.get();
1919
940
}
1059
}
1920
941
1060
1922
942
std::shared_ptr<mir::client::BufferStream> MirConnection::create_client_buffer_stream_with_id(
1061
mcl::NoTLSFuture<std::unique_ptr<mcl::BufferStream>>
1923
1062
MirConnection::create_client_buffer_stream_with_id(
1924
943
    int width, int height,
1063
    int width, int height,
1925
944
    MirRenderSurface* render_surface,
1064
    MirRenderSurface* render_surface,
1926
945
    mir::protobuf::BufferStream const& a_protobuf_bs)
1065
    mir::protobuf::BufferStream const& a_protobuf_bs)
1927
946
{
1066
{
1934
947
    auto stream = std::make_shared<mcl::BufferStream>(
1067
    return mcl::BufferStream::create(
1935
948
        this, render_surface, nullptr, server, platform, surface_map, buffer_factory,
1068
        this,
1936
949
        a_protobuf_bs, make_perf_report(logger), std::string{},
1069
        render_surface,
1937
950
        mir::geometry::Size{width, height}, nbuffers);
1070
        nullptr,
1938
951
    surface_map->insert(render_surface->stream_id(), stream);
1071
        server,
1939
952
    return stream;
1072
        platform,
1940
1073
        surface_map,
1941
1074
        buffer_factory,
1942
1075
        a_protobuf_bs,
1943
1076
        make_perf_report(logger),
1944
1077
        std::string{},
1945
1078
        mir::geometry::Size{width, height},
1946
1079
        nbuffers);
1947
953
}
1080
}
1948
954
#pragma GCC diagnostic pop
1081
#pragma GCC diagnostic pop
1949
955
1082
1950
@@ -1322,8 +1449,15 @@
1951
1322
    server.release_buffers(&request, ignored.get(), gp::NewCallback(ignore));
1449
    server.release_buffers(&request, ignored.get(), gp::NewCallback(ignore));
1952
1323
}
1450
}
1953
1324
1451
1954
1452
void MirConnection::process_next_request_first()
1955
1453
{
1956
1454
    channel->process_next_request_first();
1957
1455
}
1958
1456
1959
1325
void MirConnection::release_render_surface_with_content(
1457
void MirConnection::release_render_surface_with_content(
1961
1326
    void* render_surface)
1458
    void* render_surface,
1962
1459
    mir_render_surface_callback callback,
1963
1460
    void* ctx)
1964
1327
{
1461
{
1965
1328
    auto rs = surface_map->render_surface(render_surface);
1462
    auto rs = surface_map->render_surface(render_surface);
1966
1329
    if (!rs->valid())
1463
    if (!rs->valid())
1967
@@ -1332,13 +1466,23 @@
1968
1332
        return;
1466
        return;
1969
1333
    }
1467
    }
1970
1334
1468
1978
1335
    StreamRelease stream_release{
1469
<<<<<<< TREE
1979
1336
        nullptr,
1470
    StreamRelease stream_release{
1980
1337
        nullptr,
1471
        nullptr,
1981
1338
        nullptr,
1472
        nullptr,
1982
1339
        nullptr,
1473
        nullptr,
1983
1340
        rs->stream_id().as_value(),
1474
        nullptr,
1984
1341
        render_surface};
1475
        rs->stream_id().as_value(),
1985
1476
        render_surface};
1986
1477
=======
1987
1478
    StreamRelease stream_release{
1988
1479
        reinterpret_cast<MirBufferStream*>(render_surface),
1989
1480
        nullptr,
1990
1481
        reinterpret_cast<mir_buffer_stream_callback>(callback),
1991
1482
        ctx,
1992
1483
        rs->stream_id().as_value(),
1993
1484
        render_surface};
1994
1485
>>>>>>> MERGE-SOURCE
1995
1342
1486
1996
1343
    mp::BufferStreamId buffer_stream_id;
1487
    mp::BufferStreamId buffer_stream_id;
1997
1344
    buffer_stream_id.set_value(rs->stream_id().as_value());
1488
    buffer_stream_id.set_value(rs->stream_id().as_value());
1998
1345
1489
1999
=== modified file 'src/client/mir_connection.h'
2000
--- src/client/mir_connection.h	2017-03-14 04:41:33 +0000
2001
+++ src/client/mir_connection.h	2017-03-28 00:17:49 +0000
2002
@@ -34,6 +34,7 @@
2003
34
#include "mir_surface.h"
34
#include "mir_surface.h"
2004
35
#include "display_configuration.h"
35
#include "display_configuration.h"
2005
36
#include "error_handler.h"
36
#include "error_handler.h"
2006
37
#include "no_tls_future-inl.h"
2007
37
38
2008
38
#include <atomic>
39
#include <atomic>
2009
39
#include <memory>
40
#include <memory>
2010
@@ -42,6 +43,8 @@
2011
42
#include <unordered_set>
43
#include <unordered_set>
2012
43
#include <unordered_map>
44
#include <unordered_map>
2013
44
45
2014
46
#include "mir/fd.h"
2015
47
2016
45
namespace mir
48
namespace mir
2017
46
{
49
{
2018
47
namespace input
50
namespace input
2019
@@ -85,8 +88,17 @@
2020
85
namespace dispatch
88
namespace dispatch
2021
86
{
89
{
2022
87
class ThreadedDispatcher;
90
class ThreadedDispatcher;
2025
88
}
91
class Dispatchable;
2026
89
}
92
class MultiplexingDispatchable;
2027
93
class ActionQueue;
2028
94
}
2029
95
}
2030
96
2031
97
enum class DispatchType
2032
98
{
2033
99
    automatic,
2034
100
    manual
2035
101
};
2036
90
102
2037
91
struct MirConnection : mir::client::ClientContext
103
struct MirConnection : mir::client::ClientContext
2038
92
{
104
{
2039
@@ -94,6 +106,7 @@
2040
94
    MirConnection(std::string const& error_message);
106
    MirConnection(std::string const& error_message);
2041
95
107
2042
96
    MirConnection(mir::client::ConnectionConfiguration& conf);
108
    MirConnection(mir::client::ConnectionConfiguration& conf);
2043
109
    MirConnection(mir::client::ConnectionConfiguration &conf, DispatchType dispatch);
2044
97
    ~MirConnection() noexcept;
110
    ~MirConnection() noexcept;
2045
98
111
2046
99
    MirConnection(MirConnection const &) = delete;
112
    MirConnection(MirConnection const &) = delete;
2047
@@ -119,6 +132,12 @@
2048
119
132
2049
120
    MirWaitHandle* disconnect();
133
    MirWaitHandle* disconnect();
2050
121
134
2051
135
    mir::Fd watch_fd() const;
2052
136
    void dispatch();
2053
137
2054
138
    void add_dispatchee(std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchee);
2055
139
    void remove_dispatchee(std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchee);
2056
140
2057
122
    MirWaitHandle* platform_operation(
141
    MirWaitHandle* platform_operation(
2058
123
        MirPlatformMessage const* request,
142
        MirPlatformMessage const* request,
2059
124
        MirPlatformOperationCallback callback, void* context) override;
143
        MirPlatformOperationCallback callback, void* context) override;
2060
@@ -151,7 +170,7 @@
2061
151
        MirRenderSurface* render_surface,
170
        MirRenderSurface* render_surface,
2062
152
        MirBufferStreamCallback mbs_callback,
171
        MirBufferStreamCallback mbs_callback,
2063
153
        void *context);
172
        void *context);
2065
154
    std::shared_ptr<mir::client::BufferStream> create_client_buffer_stream_with_id(
173
    mir::client::NoTLSFuture<std::unique_ptr<mir::client::BufferStream>> create_client_buffer_stream_with_id(
2066
155
        int width, int height,
174
        int width, int height,
2067
156
        MirRenderSurface* render_surface,
175
        MirRenderSurface* render_surface,
2068
157
        mir::protobuf::BufferStream const& a_protobuf_bs);
176
        mir::protobuf::BufferStream const& a_protobuf_bs);
2069
@@ -221,10 +240,13 @@
2070
221
        void* context) -> MirRenderSurface*;
240
        void* context) -> MirRenderSurface*;
2071
222
#pragma GCC diagnostic pop
241
#pragma GCC diagnostic pop
2072
223
    void release_render_surface_with_content(
242
    void release_render_surface_with_content(
2074
224
        void* render_surface);
243
        void* render_surface,
2075
244
        mir_render_surface_callback callback,
2076
245
        void* ctx);
2077
225
246
2078
226
    void* request_interface(char const* name, int version);
247
    void* request_interface(char const* name, int version);
2079
227
248
2080
249
    void process_next_request_first();
2081
228
private:
250
private:
2082
229
    //google cant have callbacks with more than 2 args
251
    //google cant have callbacks with more than 2 args
2083
230
    struct SurfaceCreationRequest
252
    struct SurfaceCreationRequest
2084
@@ -242,7 +264,7 @@
2085
242
        std::shared_ptr<MirWaitHandle> wh;
264
        std::shared_ptr<MirWaitHandle> wh;
2086
243
    };
265
    };
2087
244
    std::vector<std::shared_ptr<SurfaceCreationRequest>> surface_requests;
266
    std::vector<std::shared_ptr<SurfaceCreationRequest>> surface_requests;
2089
245
    void surface_created(SurfaceCreationRequest*);
267
    void    surface_created(SurfaceCreationRequest*);
2090
246
268
2091
247
    struct StreamCreationRequest
269
    struct StreamCreationRequest
2092
248
    {
270
    {
2093
@@ -350,16 +372,20 @@
2094
350
372
2095
351
    std::shared_ptr<mir::client::LifecycleControl> const lifecycle_control;
373
    std::shared_ptr<mir::client::LifecycleControl> const lifecycle_control;
2096
352
374
2097
375
2098
376
    std::shared_ptr<mir::client::EventHandlerRegister> const event_handler_register;
2099
377
2100
378
    std::shared_ptr<mir::dispatch::MultiplexingDispatchable> const dispatcher;
2101
379
    std::unique_ptr<mir::dispatch::ThreadedDispatcher> const eventloop;
2102
380
2103
353
    std::shared_ptr<mir::client::PingHandler> const ping_handler;
381
    std::shared_ptr<mir::client::PingHandler> const ping_handler;
2104
354
382
2105
383
    std::unique_ptr<google::protobuf::Closure> const pong_callback;
2106
384
2107
385
    std::shared_ptr<mir::dispatch::ActionQueue> const delayed_queue;
2108
386
2109
355
    std::shared_ptr<mir::client::ErrorHandler> error_handler;
387
    std::shared_ptr<mir::client::ErrorHandler> error_handler;
2110
356
388
2111
357
    std::shared_ptr<mir::client::EventHandlerRegister> const event_handler_register;
2112
358
2113
359
    std::unique_ptr<google::protobuf::Closure> const pong_callback;
2114
360
2115
361
    std::unique_ptr<mir::dispatch::ThreadedDispatcher> const eventloop;
2116
362
    
2117
363
389
2118
364
    struct SurfaceRelease;
390
    struct SurfaceRelease;
2119
365
    struct StreamRelease;
391
    struct StreamRelease;
2120
366
392
2121
=== modified file 'src/client/mir_connection_api.cpp'
2122
--- src/client/mir_connection_api.cpp	2017-02-15 07:38:33 +0000
2123
+++ src/client/mir_connection_api.cpp	2017-03-28 00:17:49 +0000
2124
@@ -29,9 +29,11 @@
2125
29
#include "display_configuration.h"
29
#include "display_configuration.h"
2126
30
#include "error_connections.h"
30
#include "error_connections.h"
2127
31
#include "mir/uncaught.h"
31
#include "mir/uncaught.h"
2128
32
#include "synchronous_helper.h"
2129
32
33
2130
33
#include <cstddef>
34
#include <cstddef>
2131
34
#include <cstring>
35
#include <cstring>
2132
36
#include <poll.h>
2133
35
37
2134
36
namespace mcl = mir::client;
38
namespace mcl = mir::client;
2135
37
namespace mp = mir::protobuf;
39
namespace mp = mir::protobuf;
2136
@@ -39,12 +41,105 @@
2137
39
41
2138
40
namespace
42
namespace
2139
41
{
43
{
2140
44
<<<<<<< TREE
2141
42
// assign_result is compatible with all 2-parameter callbacks
45
// assign_result is compatible with all 2-parameter callbacks
2142
43
void assign_result(void* result, void** context)
46
void assign_result(void* result, void** context)
2143
44
{
47
{
2144
45
    if (context)
48
    if (context)
2145
46
        *context = result;
49
        *context = result;
2146
47
}
50
}
2147
51
=======
2148
52
class DefaultMirConnectionAPI : public mcl::MirConnectionAPI
2149
53
{
2150
54
public:
2151
55
    MirWaitHandle* connect(
2152
56
        mcl::ConfigurationFactory configuration,
2153
57
        char const* socket_file,
2154
58
        char const* name,
2155
59
        mir_connected_callback callback,
2156
60
        void* context) override
2157
61
    {
2158
62
        try
2159
63
        {
2160
64
            std::string sock;
2161
65
            if (socket_file)
2162
66
                sock = socket_file;
2163
67
            else
2164
68
            {
2165
69
                auto socket_env = getenv("MIR_SOCKET");
2166
70
                if (socket_env && socket_env[0])
2167
71
                    sock = socket_env;
2168
72
                else
2169
73
                    sock = mir::default_server_socket;
2170
74
            }
2171
75
2172
76
            auto const conf = configuration(sock);
2173
77
2174
78
            auto connection = std::make_unique<MirConnection>(*conf);
2175
79
            auto const result = connection->connect(name, callback, context);
2176
80
            connection.release();
2177
81
            return result;
2178
82
        }
2179
83
        catch (std::exception const& x)
2180
84
        {
2181
85
            MirConnection* error_connection = new MirConnection(x.what());
2182
86
            mcl::ErrorConnections::instance().insert(error_connection);
2183
87
            callback(error_connection, context);
2184
88
            return nullptr;
2185
89
        }
2186
90
    }
2187
91
2188
92
    void release(MirConnection* connection) override
2189
93
    {
2190
94
        if (!mcl::ErrorConnections::instance().contains(connection))
2191
95
        {
2192
96
            try
2193
97
            {
2194
98
                auto wait_handle = connection->disconnect();
2195
99
                if (connection->watch_fd() != mir::Fd::invalid)
2196
100
                {
2197
101
                    pollfd fd;
2198
102
                    fd.fd = connection->watch_fd();
2199
103
                    fd.events = POLLIN;
2200
104
                    while(wait_handle->is_pending() && (poll(&fd, 1, -1) > 0))
2201
105
                    {
2202
106
                        connection->dispatch();
2203
107
                    }
2204
108
                }
2205
109
                else
2206
110
                {
2207
111
                    wait_handle->wait_for_all();
2208
112
                }
2209
113
            }
2210
114
            catch (std::exception const& ex)
2211
115
            {
2212
116
                // We're implementing a C API so no exceptions are to be
2213
117
                // propagated. And that's OK because if disconnect() fails,
2214
118
                // we don't care why. We're finished with the connection anyway.
2215
119
2216
120
                MIR_LOG_UNCAUGHT_EXCEPTION(ex);
2217
121
            }
2218
122
        }
2219
123
        else
2220
124
        {
2221
125
            mcl::ErrorConnections::instance().remove(connection);
2222
126
        }
2223
127
2224
128
        delete connection;
2225
129
    }
2226
130
2227
131
    mcl::ConfigurationFactory configuration_factory() override
2228
132
    {
2229
133
        return [](std::string const& socket) {
2230
134
            return std::unique_ptr<mcl::ConnectionConfiguration>{
2231
135
                new mcl::DefaultConnectionConfiguration{socket}
2232
136
            };
2233
137
        };
2234
138
    }
2235
139
};
2236
140
2237
141
DefaultMirConnectionAPI default_api;
2238
142
>>>>>>> MERGE-SOURCE
2239
48
}
143
}
2240
49
144
2241
50
MirWaitHandle* mir_connect(
145
MirWaitHandle* mir_connect(
2242
@@ -94,6 +189,7 @@
2243
94
    char const* app_name)
189
    char const* app_name)
2244
95
{
190
{
2245
96
    MirConnection* conn = nullptr;
191
    MirConnection* conn = nullptr;
2246
192
<<<<<<< TREE
2247
97
    auto wh = mir_connect(server, app_name,
193
    auto wh = mir_connect(server, app_name,
2248
98
                          reinterpret_cast<MirConnectedCallback>
194
                          reinterpret_cast<MirConnectedCallback>
2249
99
                          (assign_result),
195
                          (assign_result),
2250
@@ -104,9 +200,62 @@
2251
104
        wh->wait_for_all();
200
        wh->wait_for_all();
2252
105
    }
201
    }
2253
106
202
2254
203
=======
2255
204
    mir_wait_for(mir_connect(server, app_name,
2256
205
                             assign_result,
2257
206
                             &conn));
2258
207
>>>>>>> MERGE-SOURCE
2259
107
    return conn;
208
    return conn;
2260
108
}
209
}
2261
109
210
2262
211
MirConnection* mir_connect_with_manual_dispatch(
2263
212
        char const* server,
2264
213
        char const* app_name,
2265
214
        mir_connected_callback callback,
2266
215
        void* context)
2267
216
{
2268
217
    try
2269
218
    {
2270
219
        std::string sock;
2271
220
        if (server)
2272
221
            sock = server;
2273
222
        else
2274
223
        {
2275
224
            auto socket_env = getenv("MIR_SOCKET");
2276
225
            if (socket_env)
2277
226
                sock = socket_env;
2278
227
            else
2279
228
                sock = mir::default_server_socket;
2280
229
        }
2281
230
2282
231
        mcl::DefaultConnectionConfiguration conf{sock};
2283
232
2284
233
        std::unique_ptr<MirConnection> connection{new MirConnection(conf, DispatchType::manual)};
2285
234
        connection->connect(app_name, callback, context);
2286
235
        return connection.release();
2287
236
    }
2288
237
    catch (std::exception const& x)
2289
238
    {
2290
239
        MirConnection* error_connection = new MirConnection(x.what());
2291
240
        mcl::ErrorConnections::instance().insert(error_connection);
2292
241
        callback(error_connection, context);
2293
242
        return error_connection;
2294
243
    }
2295
244
}
2296
245
2297
246
MirConnection* mir_connect_with_manual_dispatch_sync(
2298
247
    char const* server,
2299
248
    char const* app_name)
2300
249
{
2301
250
    MirConnection* result = nullptr;
2302
251
2303
252
    auto connection = mir_connect_with_manual_dispatch(server, app_name, &assign_result, &result);
2304
253
2305
254
    dispatch_connection_until(connection, [&result]() { return result != nullptr; });
2306
255
2307
256
    return connection;
2308
257
}
2309
258
2310
110
bool mir_connection_is_valid(MirConnection* connection)
259
bool mir_connection_is_valid(MirConnection* connection)
2311
111
{
260
{
2312
112
    return MirConnection::is_valid(connection);
261
    return MirConnection::is_valid(connection);
2313
@@ -139,6 +288,16 @@
2314
139
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
288
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
2315
140
}
289
}
2316
141
290
2317
291
int mir_connection_get_event_fd(MirConnection* connection)
2318
292
{
2319
293
    return connection->watch_fd();
2320
294
}
2321
295
2322
296
void mir_connection_dispatch(MirConnection* connection)
2323
297
{
2324
298
    connection->dispatch();
2325
299
}
2326
300
2327
142
void mir_connection_get_platform(
301
void mir_connection_get_platform(
2328
143
    MirConnection* connection,
302
    MirConnection* connection,
2329
144
    MirPlatformPackage* platform_package)
303
    MirPlatformPackage* platform_package)
2330
145
304
2331
=== modified file 'src/client/mir_prompt_session_api.cpp'
2332
--- src/client/mir_prompt_session_api.cpp	2017-03-10 19:47:57 +0000
2333
+++ src/client/mir_prompt_session_api.cpp	2017-03-28 00:17:49 +0000
2334
@@ -25,6 +25,8 @@
2335
25
#include "mir/require.h"
25
#include "mir/require.h"
2336
26
#include "mir/uncaught.h"
26
#include "mir/uncaught.h"
2337
27
27
2338
28
#include "synchronous_helper.h"
2339
29
2340
28
#include <stdexcept>
30
#include <stdexcept>
2341
29
#include <boost/throw_exception.hpp>
31
#include <boost/throw_exception.hpp>
2342
30
32
2343
@@ -46,6 +48,17 @@
2344
46
            prompt_session->register_prompt_session_state_change_callback(state_change_callback, context);
48
            prompt_session->register_prompt_session_state_change_callback(state_change_callback, context);
2345
47
        prompt_session->start(application_pid, null_callback, nullptr)->wait_for_all();
49
        prompt_session->start(application_pid, null_callback, nullptr)->wait_for_all();
2346
48
50
2347
51
<<<<<<< TREE
2348
52
=======
2349
53
        make_synchronous_call(
2350
54
            connection,
2351
55
            std::mem_fn(&MirPromptSession::start),
2352
56
            prompt_session,
2353
57
            application_pid,
2354
58
            &assign_result<MirPromptSession>,
2355
59
            static_cast<void*>(nullptr));
2356
60
2357
61
>>>>>>> MERGE-SOURCE
2358
49
        return prompt_session;
62
        return prompt_session;
2359
50
    }
63
    }
2360
51
    catch (std::exception const& ex)
64
    catch (std::exception const& ex)
2361
52
65
2362
=== modified file 'src/client/mir_render_surface_api.cpp'
2363
--- src/client/mir_render_surface_api.cpp	2017-03-14 04:41:33 +0000
2364
+++ src/client/mir_render_surface_api.cpp	2017-03-28 00:17:49 +0000
2365
@@ -163,10 +163,13 @@
2366
163
}
163
}
2367
164
164
2368
165
void mir_render_surface_release(
165
void mir_render_surface_release(
2370
166
    MirRenderSurface* render_surface)
166
    MirRenderSurface* render_surface,
2371
167
    mir_render_surface_callback callback,
2372
168
    void* ctx)
2373
167
try
169
try
2374
168
{
170
{
2375
169
    mir::require(render_surface);
171
    mir::require(render_surface);
2376
172
<<<<<<< TREE
2377
170
    auto connection = connection_map.connection(render_surface);
173
    auto connection = connection_map.connection(render_surface);
2378
171
    connection_map.erase(render_surface);
174
    connection_map.erase(render_surface);
2379
172
    connection->release_render_surface_with_content(render_surface);
175
    connection->release_render_surface_with_content(render_surface);
2380
@@ -180,17 +183,114 @@
2381
180
    MirRenderSurface* render_surface,
183
    MirRenderSurface* render_surface,
2382
181
    int width, int height,
184
    int width, int height,
2383
182
    MirPixelFormat format)
185
    MirPixelFormat format)
2386
183
try
186
=======
2387
184
{
187
    auto connection = connection_map.connection(static_cast<void*>(render_surface));
2388
188
    connection_map.erase(static_cast<void*>(render_surface));
2389
189
    connection->release_render_surface_with_content(render_surface, callback, ctx);
2390
190
}
2391
191
catch (std::exception const& ex)
2392
192
{
2393
193
    callback(render_surface, ctx);
2394
194
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
2395
195
}
2396
196
2397
197
void mir_render_surface_get_buffer_stream(
2398
198
    MirRenderSurface* render_surface,
2399
199
    int width,
2400
200
    int height,
2401
201
    MirPixelFormat format,
2402
202
    MirBufferUsage usage,
2403
203
    mir_buffer_stream_callback callback,
2404
204
    void* context)
2405
205
try
2406
206
{
2407
207
    mir::require(render_surface);
2408
208
    auto connection = connection_map.connection(static_cast<void*>(render_surface));
2409
209
    auto rs = connection->connection_surface_map()->render_surface(render_surface);
2410
210
    rs->get_buffer_stream(width, height, format, usage, callback, context);
2411
211
}
2412
212
catch (std::exception const& ex)
2413
213
{
2414
214
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
2415
215
}
2416
216
2417
217
MirBufferStream* mir_render_surface_get_buffer_stream_sync(
2418
218
    MirRenderSurface* render_surface,
2419
219
    int width,
2420
220
    int height,
2421
221
    MirPixelFormat format,
2422
222
    MirBufferUsage usage)
2423
223
>>>>>>> MERGE-SOURCE
2424
224
try
2425
225
{
2426
226
<<<<<<< TREE
2427
185
    mir::require(render_surface);
227
    mir::require(render_surface);
2428
186
    auto connection = connection_map.connection(render_surface);
228
    auto connection = connection_map.connection(render_surface);
2429
187
    auto rs = connection->connection_surface_map()->render_surface(render_surface);
229
    auto rs = connection->connection_surface_map()->render_surface(render_surface);
2430
188
    return rs->get_buffer_stream(width, height, format, mir_buffer_usage_software);
230
    return rs->get_buffer_stream(width, height, format, mir_buffer_usage_software);
2431
231
=======
2432
232
    struct BufferStreamResult
2433
233
    {
2434
234
        std::mutex lock;
2435
235
        std::condition_variable notify;
2436
236
        bool done{false};
2437
237
        MirBufferStream* result;
2438
238
    } ready;
2439
239
2440
240
    mir_render_surface_get_buffer_stream(
2441
241
        render_surface,
2442
242
        width, height,
2443
243
        format,
2444
244
        usage,
2445
245
        [](MirBufferStream* stream, void* context)
2446
246
        {
2447
247
            auto result = reinterpret_cast<BufferStreamResult*>(context);
2448
248
2449
249
            {
2450
250
                std::lock_guard<std::mutex> lock{result->lock};
2451
251
                result->result = stream;
2452
252
                result->done = true;
2453
253
            }
2454
254
            result->notify.notify_all();
2455
255
        },
2456
256
        &ready);
2457
257
2458
258
    std::unique_lock<std::mutex> lock{ready.lock};
2459
259
    ready.notify.wait(lock, [&ready]() { return ready.done; });
2460
260
2461
261
    return ready.result;
2462
262
>>>>>>> MERGE-SOURCE
2463
189
}
263
}
2464
190
catch (std::exception const& ex)
264
catch (std::exception const& ex)
2465
191
{
265
{
2466
192
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
266
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
2468
193
    return nullptr;
267
    std::terminate();
2469
268
}
2470
269
2471
270
void mir_render_surface_release_sync(MirRenderSurface* render_surface)
2472
271
{
2473
272
    struct Waiter
2474
273
    {
2475
274
        std::condition_variable notifier;
2476
275
        std::mutex lock;
2477
276
        bool done{false};
2478
277
    } waiter;
2479
278
2480
279
    mir_render_surface_release(
2481
280
        render_surface,
2482
281
        [](MirRenderSurface*, void* ctx)
2483
282
        {
2484
283
            auto waiter = reinterpret_cast<Waiter*>(ctx);
2485
284
            {
2486
285
                std::lock_guard<std::mutex> lock{waiter->lock};
2487
286
                waiter->done = true;
2488
287
            }
2489
288
            waiter->notifier.notify_all();
2490
289
        },
2491
290
        &waiter);
2492
291
2493
292
    std::unique_lock<std::mutex> lock(waiter.lock);
2494
293
    waiter.notifier.wait(lock, [&waiter]() { return waiter.done; });
2495
194
}
294
}
2496
195
295
2497
196
MirPresentationChain* mir_render_surface_get_presentation_chain(
296
MirPresentationChain* mir_render_surface_get_presentation_chain(
2498
197
297
2499
=== modified file 'src/client/mir_screencast.cpp'
2500
--- src/client/mir_screencast.cpp	2017-03-10 19:47:57 +0000
2501
+++ src/client/mir_screencast.cpp	2017-03-28 00:17:49 +0000
2502
@@ -104,8 +104,9 @@
2503
104
{
104
{
2504
105
}
105
}
2505
106
106
2508
107
MirScreencast::MirScreencast(std::string const& error)
107
MirScreencast::MirScreencast(MirConnection* connection, std::string const& error)
2509
108
    : protobuf_screencast{mcl::make_protobuf_object<mir::protobuf::Screencast>()}
108
    : connection{connection},
2510
109
      protobuf_screencast{mcl::make_protobuf_object<mir::protobuf::Screencast>()}
2511
109
{
110
{
2512
110
    protobuf_screencast->set_error(error);
111
    protobuf_screencast->set_error(error);
2513
111
}
112
}
2514
@@ -178,7 +179,12 @@
2515
178
}
179
}
2516
179
180
2517
180
void MirScreencast::screencast_created(
181
void MirScreencast::screencast_created(
2518
182
<<<<<<< TREE
2519
181
    MirScreencastCallback callback, void* context)
183
    MirScreencastCallback callback, void* context)
2520
184
=======
2521
185
    mir_screencast_callback callback,
2522
186
    void* context)
2523
187
>>>>>>> MERGE-SOURCE
2524
182
{
188
{
2525
183
    if (!protobuf_screencast->has_error() && connection)
189
    if (!protobuf_screencast->has_error() && connection)
2526
184
    {
190
    {
2527
@@ -219,3 +225,8 @@
2528
219
    std::lock_guard<decltype(mutex)> lock(mutex);
225
    std::lock_guard<decltype(mutex)> lock(mutex);
2529
220
    return buffer_stream.get();
226
    return buffer_stream.get();
2530
221
}
227
}
2531
228
2532
229
MirConnection* MirScreencast::get_connection()
2533
230
{
2534
231
    return connection;
2535
232
}
2536
222
233
2537
=== modified file 'src/client/mir_screencast.h'
2538
--- src/client/mir_screencast.h	2017-01-24 07:37:03 +0000
2539
+++ src/client/mir_screencast.h	2017-03-28 00:17:49 +0000
2540
@@ -68,7 +68,7 @@
2541
68
struct MirScreencast
68
struct MirScreencast
2542
69
{
69
{
2543
70
public:
70
public:
2545
71
    MirScreencast(std::string const& error);
71
    MirScreencast(MirConnection* connection, std::string const& error);
2546
72
    MirScreencast(
72
    MirScreencast(
2547
73
        MirScreencastSpec const& spec,
73
        MirScreencastSpec const& spec,
2548
74
        mir::client::rpc::DisplayServer& server,
74
        mir::client::rpc::DisplayServer& server,
2549
@@ -85,6 +85,7 @@
2550
85
85
2551
86
    MirBufferStream* get_buffer_stream();
86
    MirBufferStream* get_buffer_stream();
2552
87
87
2553
88
    MirConnection* get_connection();
2554
88
private:
89
private:
2555
89
    void screencast_created(
90
    void screencast_created(
2556
90
        MirScreencastCallback callback, void* context);
91
        MirScreencastCallback callback, void* context);
2557
91
92
2558
=== modified file 'src/client/mir_screencast_api.cpp'
2559
--- src/client/mir_screencast_api.cpp	2017-01-18 02:29:37 +0000
2560
+++ src/client/mir_screencast_api.cpp	2017-03-28 00:17:49 +0000
2561
@@ -25,6 +25,8 @@
2562
25
#include "mir/require.h"
25
#include "mir/require.h"
2563
26
#include "mir/uncaught.h"
26
#include "mir/uncaught.h"
2564
27
27
2565
28
#include "synchronous_helper.h"
2566
29
2567
28
#include <stdexcept>
30
#include <stdexcept>
2568
29
#include <boost/throw_exception.hpp>
31
#include <boost/throw_exception.hpp>
2569
30
32
2570
@@ -35,7 +37,18 @@
2571
35
{
37
{
2572
36
    auto& server = spec->connection->display_server();
38
    auto& server = spec->connection->display_server();
2573
37
    auto screencast = std::make_unique<MirScreencast>(*spec, server, null_callback, nullptr);
39
    auto screencast = std::make_unique<MirScreencast>(*spec, server, null_callback, nullptr);
2575
38
    screencast->creation_wait_handle()->wait_for_all();
40
2576
41
    if (spec->connection->watch_fd() != mir::Fd::invalid)
2577
42
    {
2578
43
        dispatch_connection_until(spec->connection, [&screencast]()
2579
44
        {
2580
45
            return !screencast->creation_wait_handle()->is_pending();
2581
46
        });
2582
47
    }
2583
48
    else
2584
49
    {
2585
50
        screencast->creation_wait_handle()->wait_for_all();
2586
51
    }
2587
39
52
2588
40
    auto raw_screencast = screencast.get();
53
    auto raw_screencast = screencast.get();
2589
41
    screencast.release();
54
    screencast.release();
2590
@@ -92,7 +105,7 @@
2591
92
catch (std::exception const& ex)
105
catch (std::exception const& ex)
2592
93
{
106
{
2593
94
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
107
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
2595
95
    return new MirScreencast(ex.what());
108
    return new MirScreencast(spec->connection, ex.what());
2596
96
}
109
}
2597
97
110
2598
98
bool mir_screencast_is_valid(MirScreencast *screencast)
111
bool mir_screencast_is_valid(MirScreencast *screencast)
2599
@@ -117,7 +130,11 @@
2600
117
130
2601
118
void mir_screencast_release_sync(MirScreencast* screencast)
131
void mir_screencast_release_sync(MirScreencast* screencast)
2602
119
{
132
{
2604
120
    screencast->release(null_callback, nullptr)->wait_for_all();
133
    make_synchronous_call(screencast->get_connection(),
2605
134
                          std::mem_fn(&MirScreencast::release),
2606
135
                          screencast,
2607
136
                          &assign_result<MirScreencast>,
2608
137
                          static_cast<void*>(nullptr));
2609
121
    delete screencast;
138
    delete screencast;
2610
122
}
139
}
2611
123
140
2612
124
141
2613
=== modified file 'src/client/mir_surface.cpp'
2614
--- src/client/mir_surface.cpp	2017-03-23 17:23:58 +0000
2615
+++ src/client/mir_surface.cpp	2017-03-28 00:17:49 +0000
2616
@@ -194,6 +194,15 @@
2617
194
            spec.event_handler.value().context);
194
            spec.event_handler.value().context);
2618
195
    }
195
    }
2619
196
196
2620
197
<<<<<<< TREE
2621
198
=======
2622
199
    if (surface_proto.fd_size() > 0 && handle_event_callback)
2623
200
    {
2624
201
        input_dispatcher = input_platform->create_input_receiver(surface_proto.fd(0), keymapper, handle_event_callback);
2625
202
        connection()->add_dispatchee(input_dispatcher);
2626
203
    }
2627
204
2628
205
>>>>>>> MERGE-SOURCE
2629
197
    std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
206
    std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
2630
198
    valid_surfaces.insert(this);
207
    valid_surfaces.insert(this);
2631
199
208
2632
@@ -220,7 +229,10 @@
2633
220
229
2634
221
    std::lock_guard<decltype(mutex)> lock(mutex);
230
    std::lock_guard<decltype(mutex)> lock(mutex);
2635
222
231
2637
223
    input_thread.reset();
232
    if (input_dispatcher)
2638
233
    {
2639
234
        connection()->remove_dispatchee(input_dispatcher);
2640
235
    }
2641
224
236
2642
225
    for (auto i = 0, end = surface->fd_size(); i != end; ++i)
237
    for (auto i = 0, end = surface->fd_size(); i != end; ++i)
2643
226
        close(surface->fd(i));
238
        close(surface->fd(i));
2644
@@ -466,7 +478,12 @@
2645
466
{
478
{
2646
467
    std::lock_guard<decltype(mutex)> lock(mutex);
479
    std::lock_guard<decltype(mutex)> lock(mutex);
2647
468
480
2649
469
    input_thread.reset();
481
    if (input_dispatcher)
2650
482
    {
2651
483
        connection()->remove_dispatchee(input_dispatcher);
2652
484
        input_dispatcher.reset();
2653
485
    }
2654
486
2655
470
    handle_event_callback = [](auto){};
487
    handle_event_callback = [](auto){};
2656
471
488
2657
472
    if (callback)
489
    if (callback)
2658
@@ -474,6 +491,17 @@
2659
474
        handle_event_callback = std::bind(callback, this,
491
        handle_event_callback = std::bind(callback, this,
2660
475
                                          std::placeholders::_1,
492
                                          std::placeholders::_1,
2661
476
                                          context);
493
                                          context);
2662
494
<<<<<<< TREE
2663
495
=======
2664
496
2665
497
        if (surface->fd_size() > 0 && handle_event_callback)
2666
498
        {
2667
499
            input_dispatcher = input_platform->create_input_receiver(surface->fd(0),
2668
500
                                                                     keymapper,
2669
501
                                                                     handle_event_callback);
2670
502
            connection()->add_dispatchee(input_dispatcher);
2671
503
        }
2672
504
>>>>>>> MERGE-SOURCE
2673
477
    }
505
    }
2674
478
}
506
}
2675
479
507
2676
480
508
2677
=== modified file 'src/client/mir_surface.h'
2678
--- src/client/mir_surface.h	2017-03-23 17:23:58 +0000
2679
+++ src/client/mir_surface.h	2017-03-28 00:17:49 +0000
2680
@@ -44,7 +44,7 @@
2681
44
{
44
{
2682
45
namespace dispatch
45
namespace dispatch
2683
46
{
46
{
2685
47
class ThreadedDispatcher;
47
class Dispatchable;
2686
48
}
48
}
2687
49
namespace input
49
namespace input
2688
50
{
50
{
2689
@@ -263,9 +263,13 @@
2690
263
    std::shared_ptr<mir::client::FrameClock> const frame_clock;
263
    std::shared_ptr<mir::client::FrameClock> const frame_clock;
2691
264
264
2692
265
    std::function<void(MirEvent const*)> handle_event_callback;
265
    std::function<void(MirEvent const*)> handle_event_callback;
2693
266
<<<<<<< TREE
2694
266
    std::function<void(MirWindowEvent const*)> handle_drag_and_drop_start_callback = [](auto){};
267
    std::function<void(MirWindowEvent const*)> handle_drag_and_drop_start_callback = [](auto){};
2695
267
268
2696
268
    std::shared_ptr<mir::dispatch::ThreadedDispatcher> input_thread;
269
    std::shared_ptr<mir::dispatch::ThreadedDispatcher> input_thread;
2697
270
=======
2698
271
    std::shared_ptr<mir::dispatch::Dispatchable> input_dispatcher;
2699
272
>>>>>>> MERGE-SOURCE
2700
269
273
2701
270
    //a bit batty, but the creation handle has to exist for as long as the MirSurface does,
274
    //a bit batty, but the creation handle has to exist for as long as the MirSurface does,
2702
271
    //as we don't really manage the lifetime of MirWaitHandle sensibly.
275
    //as we don't really manage the lifetime of MirWaitHandle sensibly.
2703
@@ -274,7 +278,6 @@
2704
274
    MirPixelFormat format;
278
    MirPixelFormat format;
2705
275
    MirBufferUsage usage;
279
    MirBufferUsage usage;
2706
276
    uint32_t output_id;
280
    uint32_t output_id;
2707
277
2708
278
};
281
};
2709
279
282
2710
280
#pragma GCC diagnostic pop
283
#pragma GCC diagnostic pop
2711
281
284
2712
=== modified file 'src/client/mir_surface_api.cpp'
2713
--- src/client/mir_surface_api.cpp	2017-03-14 04:41:33 +0000
2714
+++ src/client/mir_surface_api.cpp	2017-03-28 00:17:49 +0000
2715
@@ -30,6 +30,7 @@
2716
30
#include "error_connections.h"
30
#include "error_connections.h"
2717
31
#include "connection_surface_map.h"
31
#include "connection_surface_map.h"
2718
32
#include "mir/uncaught.h"
32
#include "mir/uncaught.h"
2719
33
#include "synchronous_helper.h"
2720
33
34
2721
34
#include <boost/exception/diagnostic_information.hpp>
35
#include <boost/exception/diagnostic_information.hpp>
2722
35
#include <functional>
36
#include <functional>
2723
@@ -37,6 +38,7 @@
2724
37
38
2725
38
namespace mcl = mir::client;
39
namespace mcl = mir::client;
2726
39
40
2727
41
<<<<<<< TREE
2728
40
namespace
42
namespace
2729
41
{
43
{
2730
42
MirWaitHandle* mir_configure_cursor_helper(MirWindow* window, MirCursorConfiguration const* cursor)
44
MirWaitHandle* mir_configure_cursor_helper(MirWindow* window, MirCursorConfiguration const* cursor)
2731
@@ -895,6 +897,8 @@
2732
895
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
897
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
2733
896
}
898
}
2734
897
899
2735
900
=======
2736
901
>>>>>>> MERGE-SOURCE
2737
898
MirSurfaceSpec* mir_connection_create_spec_for_normal_surface(MirConnection* connection,
902
MirSurfaceSpec* mir_connection_create_spec_for_normal_surface(MirConnection* connection,
2738
899
                                                              int width, int height,
903
                                                              int width, int height,
2739
900
                                                              MirPixelFormat format)
904
                                                              MirPixelFormat format)
2740
@@ -969,7 +973,20 @@
2741
969
973
2742
970
MirSurface* mir_surface_create_sync(MirSurfaceSpec* requested_specification)
974
MirSurface* mir_surface_create_sync(MirSurfaceSpec* requested_specification)
2743
971
{
975
{
2744
976
<<<<<<< TREE
2745
972
    return mir_create_window_sync(requested_specification);
977
    return mir_create_window_sync(requested_specification);
2746
978
=======
2747
979
    MirSurface* surface = nullptr;
2748
980
2749
981
    make_synchronous_call(
2750
982
        requested_specification->connection,
2751
983
        &mir_surface_create,
2752
984
        requested_specification,
2753
985
        &assign_result<MirSurface>,
2754
986
        &surface);
2755
987
2756
988
    return surface;
2757
989
>>>>>>> MERGE-SOURCE
2758
973
}
990
}
2759
974
991
2760
975
MirWaitHandle* mir_surface_create(MirSurfaceSpec* requested_specification,
992
MirWaitHandle* mir_surface_create(MirSurfaceSpec* requested_specification,
2761
@@ -1172,7 +1189,15 @@
2762
1172
1189
2763
1173
void mir_surface_release_sync(MirSurface* surface)
1190
void mir_surface_release_sync(MirSurface* surface)
2764
1174
{
1191
{
2765
1192
<<<<<<< TREE
2766
1175
    mir_window_release_sync(surface);
1193
    mir_window_release_sync(surface);
2767
1194
=======
2768
1195
    make_synchronous_call(surface->connection(),
2769
1196
                          mir_surface_release,
2770
1197
                          surface,
2771
1198
                          &assign_result<MirSurface>,
2772
1199
                          static_cast<void*>(nullptr));
2773
1200
>>>>>>> MERGE-SOURCE
2774
1176
}
1201
}
2775
1177
1202
2776
1178
MirSurfaceType mir_surface_get_type(MirSurface* surf)
1203
MirSurfaceType mir_surface_get_type(MirSurface* surf)
2777
1179
1204
2778
=== modified file 'src/client/mir_wait_api.cpp'
2779
--- src/client/mir_wait_api.cpp	2014-03-31 14:36:08 +0000
2780
+++ src/client/mir_wait_api.cpp	2017-03-28 00:17:49 +0000
2781
@@ -30,3 +30,12 @@
2782
30
    if (wait_handle)
30
    if (wait_handle)
2783
31
        wait_handle->wait_for_one();
31
        wait_handle->wait_for_one();
2784
32
}
32
}
2785
33
2786
34
bool mir_wait_handle_ready(MirWaitHandle* wait_handle)
2787
35
{
2788
36
    if (wait_handle)
2789
37
    {
2790
38
        return !wait_handle->is_pending();
2791
39
    }
2792
40
    return true;
2793
41
}
2794
33
42
2795
=== modified file 'src/client/no_tls_future-inl.h'
2796
--- src/client/no_tls_future-inl.h	2017-01-18 02:29:37 +0000
2797
+++ src/client/no_tls_future-inl.h	2017-03-28 00:17:49 +0000
2798
@@ -395,6 +395,7 @@
2799
395
    NoTLSPromiseBase& operator=(NoTLSPromiseBase&& other)
395
    NoTLSPromiseBase& operator=(NoTLSPromiseBase&& other)
2800
396
    {
396
    {
2801
397
        state = std::move(other.state);
397
        state = std::move(other.state);
2802
398
        return *this;
2803
398
    }
399
    }
2804
399
400
2805
400
    NoTLSPromiseBase(NoTLSPromiseBase const&) = delete;
401
    NoTLSPromiseBase(NoTLSPromiseBase const&) = delete;
2806
401
402
2807
=== modified file 'src/client/render_surface.cpp'
2808
--- src/client/render_surface.cpp	2017-03-14 02:26:28 +0000
2809
+++ src/client/render_surface.cpp	2017-03-28 00:17:49 +0000
2810
@@ -25,6 +25,7 @@
2811
25
#include "mir/client_platform.h"
25
#include "mir/client_platform.h"
2812
26
26
2813
27
#include <boost/throw_exception.hpp>
27
#include <boost/throw_exception.hpp>
2814
28
#include <mir/require.h>
2815
28
29
2816
29
namespace mcl = mir::client;
30
namespace mcl = mir::client;
2817
30
namespace geom = mir::geometry;
31
namespace geom = mir::geometry;
2818
@@ -55,27 +56,46 @@
2819
55
    return mf::BufferStreamId(protobuf_bs->id().value());
56
    return mf::BufferStreamId(protobuf_bs->id().value());
2820
56
}
57
}
2821
57
58
2824
58
MirBufferStream* mcl::RenderSurface::get_buffer_stream(
59
void mcl::RenderSurface::get_buffer_stream(
2825
59
    int width, int height,
60
    int width,
2826
61
    int height,
2827
60
    MirPixelFormat format,
62
    MirPixelFormat format,
2829
61
    MirBufferUsage buffer_usage)
63
    MirBufferUsage buffer_usage,
2830
64
    mir_buffer_stream_callback callback,
2831
65
    void* context)
2832
62
{
66
{
2833
63
    if (chain_from_id || stream_from_id)
67
    if (chain_from_id || stream_from_id)
2834
68
    {
2835
69
        callback(nullptr, context);
2836
64
        BOOST_THROW_EXCEPTION(std::logic_error("Content already handed out"));
70
        BOOST_THROW_EXCEPTION(std::logic_error("Content already handed out"));
2837
71
    }
2838
65
72
2839
66
    protobuf_bs->set_pixel_format(format);
73
    protobuf_bs->set_pixel_format(format);
2840
67
    protobuf_bs->set_buffer_usage(buffer_usage);
74
    protobuf_bs->set_buffer_usage(buffer_usage);
2852
68
    stream_from_id = connection_->create_client_buffer_stream_with_id(width,
75
2853
69
                                                                      height,
76
    connection_->create_client_buffer_stream_with_id(
2854
70
                                                                      this,
77
        width,
2855
71
                                                                      *protobuf_bs);
78
        height,
2856
72
    if (buffer_usage == mir_buffer_usage_hardware)
79
        this,
2857
73
    {
80
        *protobuf_bs).then(
2858
74
        platform->use_egl_native_window(
81
        [
2859
75
            wrapped_native_window, dynamic_cast<EGLNativeSurface*>(stream_from_id.get()));
82
            this,
2860
76
    }
83
            buffer_usage,
2861
77
84
            callback,
2862
78
    return stream_from_id.get();
85
            context
2863
86
        ](auto&& resolved_future)
2864
87
        {
2865
88
            auto bs = resolved_future.get();
2866
89
2867
90
            if (buffer_usage == mir_buffer_usage_hardware)
2868
91
            {
2869
92
                platform->use_egl_native_window(
2870
93
                    wrapped_native_window, dynamic_cast<EGLNativeSurface*>(bs.get()));
2871
94
            }
2872
95
2873
96
            stream_from_id = std::move(bs);
2874
97
            callback(static_cast<MirBufferStream*>(stream_from_id.get()), context);
2875
98
        }).detach();
2876
79
}
99
}
2877
80
100
2878
81
MirPresentationChain* mcl::RenderSurface::get_presentation_chain()
101
MirPresentationChain* mcl::RenderSurface::get_presentation_chain()
2879
82
102
2880
=== modified file 'src/client/render_surface.h'
2881
--- src/client/render_surface.h	2017-03-10 19:47:57 +0000
2882
+++ src/client/render_surface.h	2017-03-28 00:17:49 +0000
2883
@@ -56,10 +56,13 @@
2884
56
    mir::frontend::BufferStreamId stream_id() const override;
56
    mir::frontend::BufferStreamId stream_id() const override;
2885
57
    char const* get_error_message() const override;
57
    char const* get_error_message() const override;
2886
58
    bool valid() const override;
58
    bool valid() const override;
2889
59
    MirBufferStream* get_buffer_stream(
59
    void get_buffer_stream(
2890
60
        int width, int height,
60
        int width,
2891
61
        int height,
2892
61
        MirPixelFormat format,
62
        MirPixelFormat format,
2894
62
        MirBufferUsage buffer_usage) override;
63
        MirBufferUsage buffer_usage,
2895
64
        mir_buffer_stream_callback callback,
2896
65
        void* context) override;
2897
63
    MirPresentationChain* get_presentation_chain() override;
66
    MirPresentationChain* get_presentation_chain() override;
2898
64
67
2899
65
private:
68
private:
2900
66
69
2901
=== modified file 'src/client/rpc/make_rpc_channel.h'
2902
--- src/client/rpc/make_rpc_channel.h	2017-01-18 02:29:37 +0000
2903
+++ src/client/rpc/make_rpc_channel.h	2017-03-28 00:17:49 +0000
2904
@@ -41,6 +41,7 @@
2905
41
{
41
{
2906
42
class MirBasicRpcChannel;
42
class MirBasicRpcChannel;
2907
43
class RpcReport;
43
class RpcReport;
2908
44
class MirBasicRpcChannel;
2909
44
45
2910
45
std::shared_ptr<mir::client::rpc::MirBasicRpcChannel>
46
std::shared_ptr<mir::client::rpc::MirBasicRpcChannel>
2911
46
make_rpc_channel(
47
make_rpc_channel(
2912
47
48
2913
=== modified file 'src/client/rpc/mir_basic_rpc_channel.h'
2914
--- src/client/rpc/mir_basic_rpc_channel.h	2017-01-30 05:18:36 +0000
2915
+++ src/client/rpc/mir_basic_rpc_channel.h	2017-03-28 00:17:49 +0000
2916
@@ -19,6 +19,8 @@
2917
19
#ifndef MIR_CLIENT_RPC_MIR_BASIC_RPC_CHANNEL_H_
19
#ifndef MIR_CLIENT_RPC_MIR_BASIC_RPC_CHANNEL_H_
2918
20
#define MIR_CLIENT_RPC_MIR_BASIC_RPC_CHANNEL_H_
20
#define MIR_CLIENT_RPC_MIR_BASIC_RPC_CHANNEL_H_
2919
21
21
2920
22
#include "mir/dispatch/dispatchable.h"
2921
23
2922
22
#include <memory>
24
#include <memory>
2923
23
#include <map>
25
#include <map>
2924
24
#include <mutex>
26
#include <mutex>
2925
@@ -105,6 +107,7 @@
2926
105
}
107
}
2927
106
108
2928
107
class MirBasicRpcChannel
109
class MirBasicRpcChannel
2929
110
    : public mir::dispatch::Dispatchable
2930
108
{
111
{
2931
109
public:
112
public:
2932
110
    virtual ~MirBasicRpcChannel();
113
    virtual ~MirBasicRpcChannel();
2933
@@ -115,11 +118,16 @@
2934
115
        google::protobuf::MessageLite* response,
118
        google::protobuf::MessageLite* response,
2935
116
        google::protobuf::Closure* complete) = 0;
119
        google::protobuf::Closure* complete) = 0;
2936
117
120
2937
121
<<<<<<< TREE
2938
118
    virtual void discard_future_calls() = 0;
122
    virtual void discard_future_calls() = 0;
2939
119
    virtual void wait_for_outstanding_calls() = 0;
123
    virtual void wait_for_outstanding_calls() = 0;
2940
120
124
2941
125
=======
2942
126
    virtual void process_next_request_first() = 0;
2943
127
>>>>>>> MERGE-SOURCE
2944
121
protected:
128
protected:
2945
122
    MirBasicRpcChannel();
129
    MirBasicRpcChannel();
2946
130
2947
123
    mir::protobuf::wire::Invocation invocation_for(
131
    mir::protobuf::wire::Invocation invocation_for(
2948
124
        std::string const& method_name,
132
        std::string const& method_name,
2949
125
        google::protobuf::MessageLite const* request,
133
        google::protobuf::MessageLite const* request,
2950
126
134
2951
=== modified file 'src/client/rpc/mir_protobuf_rpc_channel.cpp'
2952
--- src/client/rpc/mir_protobuf_rpc_channel.cpp	2017-03-17 17:20:09 +0000
2953
+++ src/client/rpc/mir_protobuf_rpc_channel.cpp	2017-03-28 00:17:49 +0000
2954
@@ -374,7 +374,7 @@
2955
374
            {
374
            {
2956
375
                for(auto i = 0; i < seq.buffer_request().buffer().fd_size(); i++)
375
                for(auto i = 0; i < seq.buffer_request().buffer().fd_size(); i++)
2957
376
                    close(seq.buffer_request().buffer().fd(i));
376
                    close(seq.buffer_request().buffer().fd(i));
2959
377
                throw e;
377
                throw;
2960
378
            }
378
            }
2961
379
        }
379
        }
2962
380
        else
380
        else
2963
@@ -395,13 +395,22 @@
2964
395
            // But that's a job for later...
395
            // But that's a job for later...
2965
396
            try
396
            try
2966
397
            {
397
            {
2967
398
<<<<<<< TREE
2968
398
                auto e = MirEvent::deserialize(event.raw());
399
                auto e = MirEvent::deserialize(event.raw());
2969
400
=======
2970
401
                std::shared_ptr<MirEvent> e = mev::deserialize_event(event.raw());
2971
402
>>>>>>> MERGE-SOURCE
2972
399
                if (e)
403
                if (e)
2973
400
                {
404
                {
2974
401
                    rpc_report->event_parsing_succeeded(*e);
405
                    rpc_report->event_parsing_succeeded(*e);
2975
402
406
2976
407
<<<<<<< TREE
2977
403
                    int window_id = 0;
408
                    int window_id = 0;
2978
404
                    bool is_window_event = true;
409
                    bool is_window_event = true;
2979
410
=======
2980
411
                    auto const send_e = [e](MirSurface* surface)
2981
412
                        { surface->handle_event(*e); };
2982
413
>>>>>>> MERGE-SOURCE
2983
405
414
2984
406
                    switch (e->type())
415
                    switch (e->type())
2985
407
                    {
416
                    {
2986
408
417
2987
=== modified file 'src/client/rpc/mir_protobuf_rpc_channel.h'
2988
--- src/client/rpc/mir_protobuf_rpc_channel.h	2017-01-30 05:18:36 +0000
2989
+++ src/client/rpc/mir_protobuf_rpc_channel.h	2017-03-28 00:17:49 +0000
2990
@@ -53,8 +53,7 @@
2991
53
53
2992
54
class MirProtobufRpcChannel :
54
class MirProtobufRpcChannel :
2993
55
        public MirBasicRpcChannel,
55
        public MirBasicRpcChannel,
2996
56
        public StreamTransport::Observer,
56
        public StreamTransport::Observer
2995
57
        public dispatch::Dispatchable
2997
58
{
57
{
2998
59
public:
58
public:
2999
60
    MirProtobufRpcChannel(std::unique_ptr<StreamTransport> transport,
59
    MirProtobufRpcChannel(std::unique_ptr<StreamTransport> transport,
3000
@@ -91,7 +90,7 @@
3001
91
     *
90
     *
3002
92
     * No messages are discarded, only delayed.
91
     * No messages are discarded, only delayed.
3003
93
     */
92
     */
3005
94
    void process_next_request_first();
93
    void process_next_request_first() override;
3006
95
94
3007
96
    void call_method(
95
    void call_method(
3008
97
        std::string const& method_name,
96
        std::string const& method_name,
3009
@@ -112,6 +111,7 @@
3010
112
    detail::SendBuffer header_bytes;
111
    detail::SendBuffer header_bytes;
3011
113
    detail::SendBuffer body_bytes;
112
    detail::SendBuffer body_bytes;
3012
114
113
3013
114
3014
115
    void receive_file_descriptors(google::protobuf::MessageLite* response);
115
    void receive_file_descriptors(google::protobuf::MessageLite* response);
3015
116
    template<class MessageType>
116
    template<class MessageType>
3016
117
    void receive_any_file_descriptors_for(MessageType* response);
117
    void receive_any_file_descriptors_for(MessageType* response);
3017
118
118
3018
=== modified file 'src/client/symbols.map'
3019
--- src/client/symbols.map	2017-03-21 05:51:47 +0000
3020
+++ src/client/symbols.map	2017-03-28 00:17:49 +0000
3021
@@ -346,17 +346,23 @@
3022
346
    mir_connection_create_render_surface;
346
    mir_connection_create_render_surface;
3023
347
    mir_connection_create_render_surface_sync;
347
    mir_connection_create_render_surface_sync;
3024
348
    mir_render_surface_get_buffer_stream;
348
    mir_render_surface_get_buffer_stream;
3025
349
    mir_render_surface_get_buffer_stream_sync;
3026
349
    mir_render_surface_get_presentation_chain;
350
    mir_render_surface_get_presentation_chain;
3027
350
    mir_render_surface_is_valid;
351
    mir_render_surface_is_valid;
3028
351
    mir_render_surface_get_error_message;
352
    mir_render_surface_get_error_message;
3029
352
    mir_render_surface_get_size;
353
    mir_render_surface_get_size;
3030
353
    mir_render_surface_set_size;
354
    mir_render_surface_set_size;
3031
354
    mir_render_surface_release;
355
    mir_render_surface_release;
3032
356
<<<<<<< TREE
3033
355
    mir_connection_present_mode_supported;
357
    mir_connection_present_mode_supported;
3034
356
    mir_presentation_chain_set_mode;
358
    mir_presentation_chain_set_mode;
3035
357
    mir_window_spec_add_render_surface;
359
    mir_window_spec_add_render_surface;
3036
358
    mir_window_spec_set_cursor_render_surface;
360
    mir_window_spec_set_cursor_render_surface;
3037
359
    mir_cursor_configuration_from_render_surface;
361
    mir_cursor_configuration_from_render_surface;
3038
362
=======
3039
363
    mir_render_surface_release_sync;
3040
364
    mir_surface_spec_add_render_surface;
3041
365
>>>>>>> MERGE-SOURCE
3042
360
366
3043
361
    #private functions needed temporarily by nested passthrough
367
    #private functions needed temporarily by nested passthrough
3044
362
    #should not be published along with the rest of the NBS symbols
368
    #should not be published along with the rest of the NBS symbols
3045
@@ -395,6 +401,11 @@
3046
395
    mir_input_device_state_event_time;
401
    mir_input_device_state_event_time;
3047
396
    mir_input_device_state_event_device_pointer_buttons;
402
    mir_input_device_state_event_device_pointer_buttons;
3048
397
    mir_surface_spec_set_pointer_confinement;
403
    mir_surface_spec_set_pointer_confinement;
3049
404
    mir_connect_with_manual_dispatch;
3050
405
    mir_connect_with_manual_dispatch_sync;
3051
406
    mir_connection_get_event_fd;
3052
407
    mir_connection_dispatch;
3053
408
    mir_wait_handle_ready;
3054
398
} MIR_CLIENT_0.22;
409
} MIR_CLIENT_0.22;
3055
399
410
3056
400
MIR_CLIENT_0.25 {  # New functions in Mir 0.25
411
MIR_CLIENT_0.25 {  # New functions in Mir 0.25
3057
@@ -552,6 +563,7 @@
3058
552
    mir_window_request_persistent_id;
563
    mir_window_request_persistent_id;
3059
553
    mir_window_request_persistent_id_sync;
564
    mir_window_request_persistent_id_sync;
3060
554
} MIR_CLIENT_0.25;
565
} MIR_CLIENT_0.25;
3061
566
<<<<<<< TREE
3062
555
567
3063
556
MIR_CLIENT_0.26.1 { # New functions in Mir 0.26.1
568
MIR_CLIENT_0.26.1 { # New functions in Mir 0.26.1
3064
557
  global:
569
  global:
3065
@@ -616,3 +628,12 @@
3066
616
    mir_touchscreen_config_set_mapping_mode;
628
    mir_touchscreen_config_set_mapping_mode;
3067
617
    mir_touchscreen_config_set_output_id;
629
    mir_touchscreen_config_set_output_id;
3068
618
} MIR_CLIENT_0.26.1;
630
} MIR_CLIENT_0.26.1;
3069
631
=======
3070
632
3071
633
MIR_CLIENT_DETAIL_0.26 {
3072
634
  global:
3073
635
    extern "C++" {
3074
636
      mir::client::DefaultConnectionConfiguration::the_delayed_queue*;
3075
637
    };
3076
638
} MIR_CLIENT_DETAIL_0.25;
3077
639
>>>>>>> MERGE-SOURCE
3078
619
640
3079
=== added file 'src/client/synchronous_helper.cpp'
3080
--- src/client/synchronous_helper.cpp	1970-01-01 00:00:00 +0000
3081
+++ src/client/synchronous_helper.cpp	2017-03-28 00:17:49 +0000
3082
@@ -0,0 +1,33 @@
3083
1
/*
3084
2
 * Copyright © 2015 Canonical Ltd.
3085
3
 *
3086
4
 * This program is free software: you can redistribute it and/or modify it
3087
5
 * under the terms of the GNU Lesser General Public License version 3,
3088
6
 * as published by the Free Software Foundation.
3089
7
 *
3090
8
 * This program is distributed in the hope that it will be useful,
3091
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3092
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3093
11
 * GNU Lesser General Public License for more details.
3094
12
 *
3095
13
 * You should have received a copy of the GNU Lesser General Public License
3096
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3097
15
 *
3098
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
3099
17
 */
3100
18
3101
19
#include "synchronous_helper.h"
3102
20
3103
21
#include <poll.h>
3104
22
3105
23
void dispatch_connection_until(MirConnection* connection, std::function<bool()> predicate)
3106
24
{
3107
25
    pollfd fd;
3108
26
    fd.fd = connection->watch_fd();
3109
27
    fd.events = POLLIN;
3110
28
    while(!predicate() && (poll(&fd, 1, -1) > 0))
3111
29
    {
3112
30
        connection->dispatch();
3113
31
    }
3114
32
}
3115
33
3116
0
34
3117
=== added file 'src/client/synchronous_helper.h'
3118
--- src/client/synchronous_helper.h	1970-01-01 00:00:00 +0000
3119
+++ src/client/synchronous_helper.h	2017-03-28 00:17:49 +0000
3120
@@ -0,0 +1,160 @@
3121
1
/*
3122
2
 * Copyright © 2015 Canonical Ltd.
3123
3
 *
3124
4
 * This program is free software: you can redistribute it and/or modify it
3125
5
 * under the terms of the GNU Lesser General Public License version 3,
3126
6
 * as published by the Free Software Foundation.
3127
7
 *
3128
8
 * This program is distributed in the hope that it will be useful,
3129
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3130
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3131
11
 * GNU Lesser General Public License for more details.
3132
12
 *
3133
13
 * You should have received a copy of the GNU Lesser General Public License
3134
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3135
15
 *
3136
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
3137
17
 */
3138
18
3139
19
#ifndef MIR_CLIENT_SYNCHRONOUS_H_
3140
20
#define MIR_CLIENT_SYNCHRONOUS_H_
3141
21
3142
22
#include "mir_connection.h"
3143
23
#include "mir_wait_handle.h"
3144
24
3145
25
#include <functional>
3146
26
#include <type_traits>
3147
27
3148
28
template<typename Result>
3149
29
void assign_result(Result* result, void* ctx)
3150
30
{
3151
31
    auto assignee = reinterpret_cast<Result**>(ctx);
3152
32
    if (assignee)
3153
33
    {
3154
34
        *assignee = result;
3155
35
    }
3156
36
}
3157
37
3158
38
template<typename Callback>
3159
39
struct SynchronousContext
3160
40
{
3161
41
    Callback real_callback;
3162
42
    bool complete;
3163
43
    void* userdata;
3164
44
};
3165
45
3166
46
template<typename Callable, class Tuple, std::size_t...I>
3167
47
void apply_substituting_last_arg(
3168
48
    Callable&& function,
3169
49
    Tuple&& args,
3170
50
    std::index_sequence<I...>,
3171
51
    void* context)
3172
52
{
3173
53
    return std::forward<Callable>(function)(
3174
54
        std::get<I>(std::forward<Tuple>(args))...,
3175
55
        context);
3176
56
}
3177
57
3178
58
3179
59
template<typename... Args>
3180
60
void synchronous_wrapper(Args... args)
3181
61
{
3182
62
    std::tuple<Args...> arguments{args...};
3183
63
    constexpr std::size_t arg_count = sizeof...(Args);
3184
64
3185
65
    auto wrapped_context = reinterpret_cast<SynchronousContext<void(*)(Args...)>*>(std::get<arg_count - 1>(arguments));
3186
66
    if (wrapped_context->real_callback)
3187
67
    {
3188
68
        apply_substituting_last_arg(
3189
69
               wrapped_context->real_callback,
3190
70
               std::forward_as_tuple(args...),
3191
71
               std::make_index_sequence<arg_count - 1>(),
3192
72
               wrapped_context->userdata);
3193
73
    }
3194
74
    wrapped_context->complete = true;
3195
75
}
3196
76
3197
77
3198
78
template<typename Callable, typename Tuple, std::size_t...I>
3199
79
constexpr decltype(auto) call_impl(Callable&& function, Tuple&& args, std::index_sequence<I...>)
3200
80
{
3201
81
    return std::forward<Callable>(function)(std::get<I>(std::forward<Tuple>((args)))...);
3202
82
}
3203
83
3204
84
template<typename Callable, typename Tuple>
3205
85
constexpr decltype(auto) apply(Callable&& function, Tuple&& args)
3206
86
{
3207
87
    return call_impl(
3208
88
        std::forward<Callable>(function),
3209
89
        std::forward<Tuple>(args),
3210
90
        std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>{}>{});
3211
91
}
3212
92
3213
93
void dispatch_connection_until(MirConnection* connection, std::function<bool()> predicate);
3214
94
3215
95
3216
96
/**
3217
97
 * \brief Make a synchronous RPC call
3218
98
 *
3219
99
 * This wrapper takes care of manually dispatching the MirConnection if it is in
3220
100
 * manual dispatch mode, or waiting for the operation to complete if in automatic
3221
101
 * dispatch mode.
3222
102
 *
3223
103
 * Given a function mir_foo_do_thing(MirFoo* target, int arg, foo_callback callback, void* context)
3224
104
 * the correct way to call this function is
3225
105
 * make_synchronous_call(connection,
3226
106
 *                       &mir_foo_do_thing,
3227
107
 *                       target,
3228
108
 *                       arg,
3229
109
 *                       callback,
3230
110
 *                       static_cast<void*>(context));
3231
111
 *
3232
112
 * The last two parameters must be the callback function and the void* to pass to that callback.
3233
113
 * The last argument must have a pointer type; NULL or nullptr must be explicitly cast to
3234
114
 * void*.
3235
115
 */
3236
116
template<typename Callable, typename... Args>
3237
117
void make_synchronous_call(MirConnection* connection,
3238
118
                           Callable&& function,
3239
119
                           Args&&... args)
3240
120
{
3241
121
    static_assert(
3242
122
        std::is_same<typename std::result_of<Callable(Args...)>::type, MirWaitHandle*>::value,
3243
123
        "Second parameter must be a function that returns a MirWaitHandle*");
3244
124
3245
125
    if (connection->watch_fd() != mir::Fd::invalid)
3246
126
    {
3247
127
        std::tuple<Args...> arguments{args...};
3248
128
        constexpr int arg_count = sizeof...(Args);
3249
129
        auto callback = std::get<arg_count - 2>(arguments);
3250
130
        auto context = std::get<arg_count - 1>(arguments);
3251
131
3252
132
        static_assert(
3253
133
            std::is_pointer<typename std::tuple_element<arg_count - 1, std::tuple<Args...>>::type>::value,
3254
134
            "The final argument must be a pointer type");
3255
135
        static_assert(
3256
136
            std::is_pointer<typename std::tuple_element<arg_count - 2, std::tuple<Args...>>::type>::value,
3257
137
            "The second last argument must be a function pointer");
3258
138
3259
139
        SynchronousContext<decltype(callback)> wrapper_context {
3260
140
            callback,
3261
141
            false,
3262
142
            context
3263
143
        };
3264
144
3265
145
        std::get<arg_count - 2>(arguments) = &synchronous_wrapper;
3266
146
        std::get<arg_count - 1>(arguments) =
3267
147
            reinterpret_cast<typename std::tuple_element<arg_count - 1, std::tuple<Args...>>::type>(&wrapper_context);
3268
148
3269
149
        connection->process_next_request_first();
3270
150
        apply(std::forward<Callable>(function), arguments);
3271
151
3272
152
        dispatch_connection_until(connection, [&wrapper_context](){ return wrapper_context.complete; });
3273
153
    }
3274
154
    else
3275
155
    {
3276
156
        mir_wait_for(std::forward<Callable>(function)(std::forward<Args>(args)...));
3277
157
    }
3278
158
}
3279
159
3280
160
#endif // MIR_CLIENT_SYNCHRONOUS_H_
3281
0
161
3282
=== added file 'src/common/dispatch/threaded_dispatcher.cpp.moved'
3283
--- src/common/dispatch/threaded_dispatcher.cpp.moved	1970-01-01 00:00:00 +0000
3284
+++ src/common/dispatch/threaded_dispatcher.cpp.moved	2017-03-28 00:17:49 +0000
3285
@@ -0,0 +1,294 @@
3286
1
/*
3287
2
 * Copyright © 2015 Canonical Ltd.
3288
3
 *
3289
4
 * This program is free software: you can redistribute it and/or modify it
3290
5
 * under the terms of the GNU Lesser General Public License version 3,
3291
6
 * as published by the Free Software Foundation.
3292
7
 *
3293
8
 * This program is distributed in the hope that it will be useful,
3294
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3295
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3296
11
 * GNU Lesser General Public License for more details.
3297
12
 *
3298
13
 * You should have received a copy of the GNU Lesser General Public License
3299
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3300
15
 *
3301
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
3302
17
 */
3303
18
3304
19
#include "mir/dispatch/threaded_dispatcher.h"
3305
20
#include "mir/dispatch/dispatchable.h"
3306
21
#include "mir/thread_name.h"
3307
22
3308
23
#include "mir/raii.h"
3309
24
#include "mir/logging/logger.h"
3310
25
3311
26
#include <fcntl.h>
3312
27
#include <poll.h>
3313
28
#include <unistd.h>
3314
29
#include <system_error>
3315
30
#include <signal.h>
3316
31
#include <boost/exception/all.hpp>
3317
32
#include <algorithm>
3318
33
#include <unordered_map>
3319
34
#include <sys/eventfd.h>
3320
35
3321
36
namespace md = mir::dispatch;
3322
37
3323
38
class md::ThreadedDispatcher::ThreadShutdownRequestHandler : public md::Dispatchable
3324
39
{
3325
40
public:
3326
41
    ThreadShutdownRequestHandler()
3327
42
        : event_semaphore{eventfd(0, EFD_CLOEXEC | EFD_SEMAPHORE)},
3328
43
          shutting_down{false}
3329
44
    {
3330
45
        if (event_semaphore == mir::Fd::invalid)
3331
46
        {
3332
47
            BOOST_THROW_EXCEPTION((std::system_error{errno,
3333
48
                                                     std::system_category(),
3334
49
                                                     "Failed to create shutdown eventfd"}));
3335
50
        }
3336
51
    }
3337
52
3338
53
    mir::Fd watch_fd() const override
3339
54
    {
3340
55
        return event_semaphore;
3341
56
    }
3342
57
3343
58
    bool dispatch(md::FdEvents events) override
3344
59
    {
3345
60
        if (events & md::FdEvent::error)
3346
61
        {
3347
62
            return false;
3348
63
        }
3349
64
3350
65
        eventfd_t dummy;
3351
66
        if (eventfd_read(event_semaphore, &dummy) < 0)
3352
67
        {
3353
68
            BOOST_THROW_EXCEPTION((std::system_error{errno,
3354
69
                                                     std::system_category(),
3355
70
                                                     "Failed to clear shutdown notification"}));
3356
71
        }
3357
72
        std::lock_guard<decltype(running_flag_guard)> lock{running_flag_guard};
3358
73
        *running_flags.at(std::this_thread::get_id()) = false;
3359
74
3360
75
        return true;
3361
76
    }
3362
77
3363
78
    md::FdEvents relevant_events() const override
3364
79
    {
3365
80
        return md::FdEvent::readable;
3366
81
    }
3367
82
3368
83
    std::thread::id terminate_one_thread()
3369
84
    {
3370
85
        // First we tell a thread to die, any thread...
3371
86
        if (eventfd_write(event_semaphore, 1) < 0)
3372
87
        {
3373
88
            BOOST_THROW_EXCEPTION((std::system_error{errno,
3374
89
                                                     std::system_category(),
3375
90
                                                     "Failed to trigger thread shutdown"}));
3376
91
        }
3377
92
3378
93
        // ...now we wait for a thread to die and tell us its ID...
3379
94
        // We wait for a surprisingly long time because our threads are potentially blocked
3380
95
        // in client code that we don't control.
3381
96
        //
3382
97
        // If the client is entirely unresponsive for a whole minute, it deserves to die.
3383
98
        std::unique_lock<decltype(terminating_thread_mutex)> lock{terminating_thread_mutex};
3384
99
        if (!thread_terminating.wait_for (lock,
3385
100
                                          std::chrono::seconds{60},
3386
101
                                          [this]() { return !terminating_threads.empty(); }))
3387
102
        {
3388
103
            BOOST_THROW_EXCEPTION((std::runtime_error{"Thread failed to shutdown"}));
3389
104
        }
3390
105
3391
106
        auto killed_thread_id = terminating_threads.back();
3392
107
        terminating_threads.pop_back();
3393
108
        return killed_thread_id;
3394
109
    }
3395
110
3396
111
    void terminate_all_threads_async()
3397
112
    {
3398
113
        eventfd_t thread_count;
3399
114
        {
3400
115
            std::lock_guard<std::mutex> lock(running_flag_guard);
3401
116
            thread_count = running_flags.size();
3402
117
            shutting_down = true;
3403
118
        }
3404
119
        if (eventfd_write(event_semaphore, thread_count) < 0)
3405
120
        {
3406
121
            BOOST_THROW_EXCEPTION((std::system_error{errno,
3407
122
                                                     std::system_category(),
3408
123
                                                     "Failed to trigger thread shutdown"}));
3409
124
        }
3410
125
    }
3411
126
3412
127
    void register_thread(bool& run_flag)
3413
128
    {
3414
129
        std::lock_guard<decltype(running_flag_guard)> lock{running_flag_guard};
3415
130
3416
131
        running_flags[std::this_thread::get_id()] = &run_flag;
3417
132
        if (shutting_down)
3418
133
        {
3419
134
            if (eventfd_write(event_semaphore, 1) < 0)
3420
135
            {
3421
136
                BOOST_THROW_EXCEPTION((std::system_error{errno,
3422
137
                                                         std::system_category(),
3423
138
                                                         "Failed to trigger thread shutdown"}));
3424
139
            }
3425
140
        }
3426
141
    }
3427
142
3428
143
    void unregister_thread()
3429
144
    {
3430
145
        {
3431
146
            std::lock_guard<decltype(terminating_thread_mutex)> lock{terminating_thread_mutex};
3432
147
            terminating_threads.push_back(std::this_thread::get_id());
3433
148
        }
3434
149
        thread_terminating.notify_one();
3435
150
        {
3436
151
            std::lock_guard<decltype(running_flag_guard)> lock{running_flag_guard};
3437
152
3438
153
            if (running_flags.erase(std::this_thread::get_id()) != 1)
3439
154
            {
3440
155
                BOOST_THROW_EXCEPTION((std::logic_error{"Attempted to unregister a not-registered thread"}));
3441
156
            }
3442
157
        }
3443
158
    }
3444
159
3445
160
private:
3446
161
    mir::Fd event_semaphore;
3447
162
3448
163
    std::mutex terminating_thread_mutex;
3449
164
    std::condition_variable thread_terminating;
3450
165
    std::vector<std::thread::id> terminating_threads;
3451
166
3452
167
    std::mutex running_flag_guard;
3453
168
    std::unordered_map<std::thread::id, bool*> running_flags;
3454
169
    bool shutting_down;
3455
170
};
3456
171
3457
172
md::ThreadedDispatcher::ThreadedDispatcher(std::string const& name, std::shared_ptr<Dispatchable> const& dispatchee)
3458
173
    : ThreadedDispatcher(name, dispatchee, [](){ throw; })
3459
174
{
3460
175
}
3461
176
3462
177
md::ThreadedDispatcher::ThreadedDispatcher(std::string const& name,
3463
178
                                           std::shared_ptr<md::Dispatchable> const& dispatchee,
3464
179
                                           std::function<void()> const& exception_handler)
3465
180
    : name_base{name},
3466
181
      thread_exiter{std::make_shared<ThreadShutdownRequestHandler>()},
3467
182
      dispatcher{std::make_shared<MultiplexingDispatchable>()},
3468
183
      exception_handler{exception_handler}
3469
184
{
3470
185
3471
186
    // We rely on exactly one thread at a time getting a shutdown message
3472
187
    dispatcher->add_watch(thread_exiter, md::DispatchReentrancy::sequential);
3473
188
3474
189
    // But our target dispatchable is welcome to be dispatched on as many threads
3475
190
    // as desired.
3476
191
    dispatcher->add_watch(dispatchee, md::DispatchReentrancy::reentrant);
3477
192
3478
193
    threadpool.emplace_back(&dispatch_loop, name_base, thread_exiter, dispatcher, exception_handler);
3479
194
}
3480
195
3481
196
md::ThreadedDispatcher::~ThreadedDispatcher() noexcept
3482
197
{
3483
198
    std::lock_guard<decltype(thread_pool_mutex)> lock{thread_pool_mutex};
3484
199
3485
200
    thread_exiter->terminate_all_threads_async();
3486
201
3487
202
    for (auto& thread : threadpool)
3488
203
    {
3489
204
        if (thread.get_id() == std::this_thread::get_id())
3490
205
        {
3491
206
            // We're being destroyed from within the dispatch callback
3492
207
            // Attempting to join the eventloop will result in a trivial deadlock.
3493
208
            //
3494
209
            // The std::thread destructor will call std::terminate() for us, let's
3495
210
            // leave a useful message.
3496
211
            mir::logging::log(mir::logging::Severity::critical,
3497
212
                              "Destroying ThreadedDispatcher from within a dispatch callback. This is a programming error.",
3498
213
                              "Dispatch");
3499
214
        }
3500
215
        else
3501
216
        {
3502
217
            thread.join();
3503
218
        }
3504
219
    }
3505
220
}
3506
221
3507
222
void md::ThreadedDispatcher::add_thread()
3508
223
{
3509
224
    std::lock_guard<decltype(thread_pool_mutex)> lock{thread_pool_mutex};
3510
225
    threadpool.emplace_back(&dispatch_loop, name_base, thread_exiter, dispatcher, exception_handler);
3511
226
}
3512
227
3513
228
void md::ThreadedDispatcher::remove_thread()
3514
229
{
3515
230
    auto terminated_thread_id = thread_exiter->terminate_one_thread();
3516
231
3517
232
    // Find that thread in our vector, join() it, then remove it.
3518
233
    std::lock_guard<decltype(thread_pool_mutex)> threadpool_lock{thread_pool_mutex};
3519
234
3520
235
    auto dying_thread = std::find_if(threadpool.begin(),
3521
236
                                     threadpool.end(),
3522
237
                                     [this, &terminated_thread_id](std::thread const& candidate)
3523
238
    {
3524
239
            return candidate.get_id() == terminated_thread_id;
3525
240
    });
3526
241
    dying_thread->join();
3527
242
    threadpool.erase(dying_thread);
3528
243
}
3529
244
3530
245
void md::ThreadedDispatcher::dispatch_loop(std::string const& name,
3531
246
                                           std::shared_ptr<ThreadShutdownRequestHandler> thread_register,
3532
247
                                           std::shared_ptr<Dispatchable> dispatcher,
3533
248
                                           std::function<void()> const& exception_handler)
3534
249
{
3535
250
    sigset_t all_signals;
3536
251
    sigfillset(&all_signals);
3537
252
3538
253
    if (auto error = pthread_sigmask(SIG_BLOCK, &all_signals, NULL))
3539
254
        BOOST_THROW_EXCEPTION((std::system_error{error,
3540
255
                                                 std::system_category(),
3541
256
                                                 "Failed to block signals on IO thread"}));
3542
257
3543
258
    mir::set_thread_name(name);
3544
259
3545
260
    // This does not have to be std::atomic<bool> because thread_register is guaranteed to
3546
261
    // only ever be dispatch()ed from one thread at a time.
3547
262
    bool running{true};
3548
263
3549
264
    auto thread_registrar = mir::raii::paired_calls(
3550
265
    [&running, thread_register]()
3551
266
    {
3552
267
        thread_register->register_thread(running);
3553
268
    },
3554
269
    [thread_register]()
3555
270
    {
3556
271
        thread_register->unregister_thread();
3557
272
    });
3558
273
3559
274
    try
3560
275
    {
3561
276
        struct pollfd waiter;
3562
277
        waiter.fd = dispatcher->watch_fd();
3563
278
        waiter.events = POLL_IN;
3564
279
        while (running)
3565
280
        {
3566
281
            if (poll(&waiter, 1, -1) < 0)
3567
282
            {
3568
283
                BOOST_THROW_EXCEPTION((std::system_error{errno,
3569
284
                                                         std::system_category(),
3570
285
                                                         "Failed to wait for event"}));
3571
286
            }
3572
287
            dispatcher->dispatch(md::FdEvent::readable);
3573
288
        }
3574
289
    }
3575
290
    catch(...)
3576
291
    {
3577
292
        exception_handler();
3578
293
    }
3579
294
}
3580
0
295
3581
=== modified file 'src/include/client/mir/mir_render_surface.h'
3582
--- src/include/client/mir/mir_render_surface.h	2017-03-10 19:47:57 +0000
3583
+++ src/include/client/mir/mir_render_surface.h	2017-03-28 00:17:49 +0000
3584
@@ -32,10 +32,13 @@
3585
32
    virtual mir::geometry::Size size() const = 0;
32
    virtual mir::geometry::Size size() const = 0;
3586
33
    virtual void set_size(mir::geometry::Size) = 0;
33
    virtual void set_size(mir::geometry::Size) = 0;
3587
34
    virtual bool valid() const = 0;
34
    virtual bool valid() const = 0;
3590
35
    virtual MirBufferStream* get_buffer_stream(
35
    virtual void get_buffer_stream(
3591
36
        int width, int height,
36
        int width,
3592
37
        int height,
3593
37
        MirPixelFormat format,
38
        MirPixelFormat format,
3595
38
        MirBufferUsage buffer_usage) = 0;
39
        MirBufferUsage buffer_usage,
3596
40
        mir_buffer_stream_callback callback,
3597
41
        void* context) = 0;
3598
39
    virtual MirPresentationChain* get_presentation_chain() = 0;
42
    virtual MirPresentationChain* get_presentation_chain() = 0;
3599
40
    virtual char const* get_error_message() const = 0;
43
    virtual char const* get_error_message() const = 0;
3600
41
    virtual ~MirRenderSurface() = default;
44
    virtual ~MirRenderSurface() = default;
3601
42
45
3602
=== modified file 'src/server/scene/mediating_display_changer.cpp'
3603
--- src/server/scene/mediating_display_changer.cpp	2017-03-13 08:12:52 +0000
3604
+++ src/server/scene/mediating_display_changer.cpp	2017-03-28 00:17:49 +0000
3605
@@ -336,7 +336,7 @@
3606
336
         */
336
         */
3607
337
        previously_set_alarm = std::move(preview_configuration_timeout);
337
        previously_set_alarm = std::move(preview_configuration_timeout);
3608
338
        preview_configuration_timeout = nullptr;
338
        preview_configuration_timeout = nullptr;
3610
339
        currently_previewing_session = std::weak_ptr<frontend::Session>{};
339
        currently_previewing_session = std::weak_ptr<frontend::Session>{}   ;
3611
340
    }
340
    }
3612
341
341
3613
342
    if (previously_set_alarm->cancel())
342
    if (previously_set_alarm->cancel())
3614
343
343
3615
=== modified file 'tests/acceptance-tests/CMakeLists.txt'
3616
--- tests/acceptance-tests/CMakeLists.txt	2017-03-15 09:30:18 +0000
3617
+++ tests/acceptance-tests/CMakeLists.txt	2017-03-28 00:17:49 +0000
3618
@@ -1,5 +1,13 @@
3619
1
include(CMakeDependentOption)
1
include(CMakeDependentOption)
3620
2
2
3621
3
<<<<<<< TREE
3622
4
=======
3623
5
include_directories(
3624
6
  ${CMAKE_SOURCE_DIR}
3625
7
  ${UMOCKDEV_INCLUDE_DIRS}
3626
8
)
3627
9
3628
10
>>>>>>> MERGE-SOURCE
3629
3
set(
11
set(
3630
4
  SOURCES
12
  SOURCES
3631
5
13
3632
6
14
3633
=== modified file 'tests/acceptance-tests/test_client_library.cpp'
3634
--- tests/acceptance-tests/test_client_library.cpp	2017-03-10 19:47:57 +0000
3635
+++ tests/acceptance-tests/test_client_library.cpp	2017-03-28 00:17:49 +0000
3636
@@ -20,9 +20,19 @@
3637
20
20
3638
21
#include "mir_test_framework/headless_in_process_server.h"
21
#include "mir_test_framework/headless_in_process_server.h"
3639
22
#include "mir_test_framework/stub_platform_helpers.h"
22
#include "mir_test_framework/stub_platform_helpers.h"
3640
23
<<<<<<< TREE
3641
24
=======
3642
25
#include "mir_test_framework/using_stub_client_platform.h"
3643
26
#include "mir_test_framework/fake_input_device.h"
3644
27
#include "mir_test_framework/stub_server_platform_factory.h"
3645
28
>>>>>>> MERGE-SOURCE
3646
23
#include "mir_test_framework/any_surface.h"
29
#include "mir_test_framework/any_surface.h"
3647
30
#include "mir/test/fd_utils.h"
3648
31
#include "mir/test/signal.h"
3649
24
#include "mir/test/validity_matchers.h"
32
#include "mir/test/validity_matchers.h"
3650
33
#include "mir/test/signal.h"
3651
25
#include "src/include/common/mir/protobuf/protocol_version.h"
34
#include "src/include/common/mir/protobuf/protocol_version.h"
3652
35
#include "mir/test/signal.h"
3653
26
36
3654
27
#include "mir_protobuf.pb.h"
37
#include "mir_protobuf.pb.h"
3655
28
38
3656
@@ -38,10 +48,16 @@
3657
38
#include <fcntl.h>
48
#include <fcntl.h>
3658
39
49
3659
40
#include <errno.h>
50
#include <errno.h>
3660
51
#include <mir/input/input_device_info.h>
3661
52
#include <mir/input/device_capability.h>
3662
41
53
3663
42
namespace mf = mir::frontend;
54
namespace mf = mir::frontend;
3664
43
namespace mc = mir::compositor;
55
namespace mc = mir::compositor;
3665
44
namespace mtf = mir_test_framework;
56
namespace mtf = mir_test_framework;
3666
57
namespace mt = mir::test;
3667
58
namespace mi = mir::input;
3668
59
namespace mis = mir::input::synthesis;
3669
60
3670
45
namespace
61
namespace
3671
46
{
62
{
3672
47
#pragma GCC diagnostic push
63
#pragma GCC diagnostic push
3673
@@ -1120,8 +1136,371 @@
3674
1120
    mir_connection_release(connection);
1136
    mir_connection_release(connection);
3675
1121
}
1137
}
3676
1122
1138
3677
1139
<<<<<<< TREE
3678
1123
#pragma GCC diagnostic push
1140
#pragma GCC diagnostic push
3679
1124
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1141
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
3680
1142
=======
3681
1143
namespace
3682
1144
{
3683
1145
struct ThreadTrackingCallbacks
3684
1146
{
3685
1147
    ThreadTrackingCallbacks()
3686
1148
        : client_thread{pthread_self()}
3687
1149
    {
3688
1150
    }
3689
1151
3690
1152
    static void connection_ready(MirConnection* /*connection*/, void* ctx)
3691
1153
    {
3692
1154
        auto data = reinterpret_cast<ThreadTrackingCallbacks*>(ctx);
3693
1155
        EXPECT_EQ(pthread_self(), data->client_thread);
3694
1156
        data->connection_ready_called.raise();
3695
1157
    }
3696
1158
3697
1159
    static void event_delegate(MirSurface* /*surf*/, MirEvent const* event, void* ctx)
3698
1160
    {
3699
1161
        auto data = reinterpret_cast<ThreadTrackingCallbacks*>(ctx);
3700
1162
3701
1163
        EXPECT_THAT(pthread_self(), Eq(data->client_thread));
3702
1164
        data->event_received.raise();
3703
1165
        if (mir_event_get_type(event) == mir_event_type_input)
3704
1166
        {
3705
1167
            data->input_event_received.raise();
3706
1168
        }
3707
1169
    }
3708
1170
3709
1171
    static void surface_created(MirSurface* surf, void* ctx)
3710
1172
    {
3711
1173
        auto data = reinterpret_cast<ThreadTrackingCallbacks*>(ctx);
3712
1174
        EXPECT_THAT(pthread_self(), Eq(data->client_thread));
3713
1175
        data->surf = surf;
3714
1176
3715
1177
        mir_surface_set_event_handler(data->surf, &ThreadTrackingCallbacks::event_delegate, data);
3716
1178
    }
3717
1179
3718
1180
    static void swap_buffers_complete(MirBufferStream* /*stream*/, void* ctx)
3719
1181
    {
3720
1182
        auto data = reinterpret_cast<ThreadTrackingCallbacks*>(ctx);
3721
1183
        EXPECT_EQ(pthread_self(), data->client_thread);
3722
1184
        data->buffers_swapped.raise();
3723
1185
    }
3724
1186
3725
1187
    pthread_t const client_thread;
3726
1188
    MirSurface* surf{nullptr};
3727
1189
    mt::Signal buffers_swapped;
3728
1190
    mt::Signal connection_ready_called;
3729
1191
    mt::Signal event_received;
3730
1192
    mt::Signal input_event_received;
3731
1193
};
3732
1194
3733
1195
void pump_eventloop_until(MirConnection* connection, std::function<bool()> predicate, std::chrono::steady_clock::time_point timeout)
3734
1196
{
3735
1197
    using namespace std::literals::chrono_literals;
3736
1198
3737
1199
    auto fd = mir::Fd{mir::IntOwnedFd{mir_connection_get_event_fd(connection)}};
3738
1200
3739
1201
    while (!predicate() && (std::chrono::steady_clock::now() < timeout))
3740
1202
    {
3741
1203
        if (mt::fd_becomes_readable(fd, 10ms))
3742
1204
        {
3743
1205
            mir_connection_dispatch(connection);
3744
1206
        }
3745
1207
    }
3746
1208
    if (!predicate())
3747
1209
    {
3748
1210
        BOOST_THROW_EXCEPTION((std::runtime_error{"Timeout waiting for state change"}));
3749
1211
    }
3750
1212
}
3751
1213
}
3752
1214
3753
1215
TEST_F(ClientLibrary, manual_dispatch_handles_callbacks_in_parent_thread)
3754
1216
{
3755
1217
    using namespace std::literals::chrono_literals;
3756
1218
3757
1219
    auto const test_timeout = std::chrono::steady_clock::now() + 10min;
3758
1220
3759
1221
    ThreadTrackingCallbacks data;
3760
1222
3761
1223
    auto connection = mir_connect_with_manual_dispatch(new_connection().c_str(), __PRETTY_FUNCTION__, &ThreadTrackingCallbacks::connection_ready, &data);
3762
1224
3763
1225
    ASSERT_THAT(connection, Ne(nullptr));
3764
1226
3765
1227
    pump_eventloop_until(
3766
1228
        connection,
3767
1229
        [&data]()
3768
1230
        {
3769
1231
            return data.connection_ready_called.raised();
3770
1232
        },
3771
1233
        test_timeout);
3772
1234
3773
1235
    ASSERT_THAT(connection, IsValid());
3774
1236
3775
1237
    auto surface_spec = mir_connection_create_spec_for_normal_surface(connection,
3776
1238
                                                                      233, 355,
3777
1239
                                                                      mir_pixel_format_argb_8888);
3778
1240
    auto surf_wh = mir_surface_create(surface_spec,
3779
1241
                                      &ThreadTrackingCallbacks::surface_created,
3780
1242
                                      &data);
3781
1243
    mir_surface_spec_release(surface_spec);
3782
1244
3783
1245
    pump_eventloop_until(
3784
1246
        connection,
3785
1247
        [surf_wh]()
3786
1248
        {
3787
1249
            return mir_wait_handle_ready(surf_wh);
3788
1250
        },
3789
1251
        test_timeout);
3790
1252
3791
1253
    EXPECT_THAT(data.surf, IsValid());
3792
1254
3793
1255
    auto buffer_stream = mir_surface_get_buffer_stream(data.surf);
3794
1256
    auto swap_wh = mir_buffer_stream_swap_buffers(buffer_stream, ThreadTrackingCallbacks::swap_buffers_complete, &data);
3795
1257
3796
1258
    pump_eventloop_until(
3797
1259
        connection,
3798
1260
        [swap_wh]()
3799
1261
        {
3800
1262
            return mir_wait_handle_ready(swap_wh);
3801
1263
        },
3802
1264
        test_timeout);
3803
1265
    EXPECT_TRUE(data.buffers_swapped.raised());
3804
1266
3805
1267
    mir_surface_release_sync(data.surf);
3806
1268
    mir_connection_release(connection);
3807
1269
}
3808
1270
3809
1271
TEST_F(ClientLibrary, manual_dispatch_handles_events_in_parent_thread)
3810
1272
{
3811
1273
    using namespace testing;
3812
1274
    using namespace std::literals::chrono_literals;
3813
1275
3814
1276
    auto const test_timeout = std::chrono::steady_clock::now() + 10min;
3815
1277
3816
1278
    auto fake_keyboard = mtf::add_fake_input_device(
3817
1279
        mi::InputDeviceInfo{"keyboard", "keyboard-unique-id", mi::DeviceCapability::keyboard});
3818
1280
3819
1281
    ThreadTrackingCallbacks data;
3820
1282
3821
1283
    connection = mir_connect_with_manual_dispatch(new_connection().c_str(), __PRETTY_FUNCTION__, &ThreadTrackingCallbacks::connection_ready, &data);
3822
1284
3823
1285
    ASSERT_THAT(connection, Ne(nullptr));
3824
1286
3825
1287
    pump_eventloop_until(
3826
1288
        connection,
3827
1289
        [&data]()
3828
1290
        {
3829
1291
            return data.connection_ready_called.raised();
3830
1292
        },
3831
1293
        test_timeout);
3832
1294
3833
1295
    ASSERT_THAT(connection, IsValid());
3834
1296
3835
1297
    auto surface_spec = mir_connection_create_spec_for_normal_surface(connection,
3836
1298
                                                                      233, 355,
3837
1299
                                                                      mir_pixel_format_argb_8888);
3838
1300
    auto surf_wh = mir_surface_create(surface_spec,
3839
1301
                                      &ThreadTrackingCallbacks::surface_created,
3840
1302
                                      &data);
3841
1303
    mir_surface_spec_release(surface_spec);
3842
1304
3843
1305
3844
1306
    pump_eventloop_until(
3845
1307
        connection,
3846
1308
        [surf_wh]()
3847
1309
        {
3848
1310
            return mir_wait_handle_ready(surf_wh);
3849
1311
        },
3850
1312
        test_timeout);
3851
1313
3852
1314
    EXPECT_THAT(data.surf, IsValid());
3853
1315
3854
1316
    // We need to swap buffers so that the surface is fully realised and
3855
1317
    // will be a valid focus target.
3856
1318
    //
3857
1319
    // The shell will not focus a surface with no content.
3858
1320
    auto buffer_stream = mir_surface_get_buffer_stream(data.surf);
3859
1321
    mir_buffer_stream_swap_buffers_sync(buffer_stream);
3860
1322
3861
1323
    pump_eventloop_until(
3862
1324
        connection,
3863
1325
        [&data]()
3864
1326
        {
3865
1327
            return mir_surface_get_focus(data.surf) == mir_surface_focused;
3866
1328
        },
3867
1329
        test_timeout);
3868
1330
3869
1331
    ASSERT_THAT(mir_surface_get_focus(data.surf), Eq(mir_surface_focused));
3870
1332
3871
1333
    fake_keyboard->emit_event(mis::a_key_down_event());
3872
1334
3873
1335
    pump_eventloop_until(
3874
1336
        connection,
3875
1337
        [&data]()
3876
1338
        {
3877
1339
            return data.input_event_received.raised();
3878
1340
        },
3879
1341
        test_timeout);
3880
1342
3881
1343
    mir_surface_release_sync(data.surf);
3882
1344
    mir_connection_release(connection);
3883
1345
}
3884
1346
3885
1347
namespace
3886
1348
{
3887
1349
struct SignalData
3888
1350
{
3889
1351
    mir::test::Signal focus_received;
3890
1352
    mir::test::Signal now_blocking;
3891
1353
    mir::test::Signal event_received;
3892
1354
    mir::test::Signal buffer_stream_destroyed;
3893
1355
};
3894
1356
3895
1357
void notifying_event_handler(MirSurface*, MirEvent const* ev, void* ctx)
3896
1358
{
3897
1359
    auto signals = *reinterpret_cast<std::shared_ptr<SignalData>*>(ctx);
3898
1360
    // We trigger an input event once we've noticed the surface callback is blocking
3899
1361
    // so we need to only raise the flag on an input event; otherwise we may spuriously
3900
1362
    // fail if we receive a surface event (like the focus event) before we hit
3901
1363
    // the wait in blocking_surface_callback()
3902
1364
    if (mir_event_get_type(ev) == mir_event_type_input)
3903
1365
    {
3904
1366
        signals->event_received.raise();
3905
1367
    }
3906
1368
    if (mir_event_get_type(ev) == mir_event_type_surface)
3907
1369
    {
3908
1370
        auto surface_event = mir_event_get_surface_event(ev);
3909
1371
        if (mir_surface_event_get_attribute(surface_event) == mir_surface_attrib_focus &&
3910
1372
            mir_surface_event_get_attribute_value(surface_event) == mir_surface_focused)
3911
1373
        {
3912
1374
            signals->focus_received.raise();
3913
1375
        }
3914
1376
    }
3915
1377
}
3916
1378
3917
1379
void notify_buffer_stream_destroyed(MirBufferStream*, void* ctx)
3918
1380
{
3919
1381
    auto& signal = *reinterpret_cast<mt::Signal*>(ctx);
3920
1382
    signal.raise();
3921
1383
}
3922
1384
3923
1385
void blocking_buffer_stream_callback(MirBufferStream* stream, void* ctx)
3924
1386
{
3925
1387
    auto signals = *reinterpret_cast<std::shared_ptr<SignalData>*>(ctx);
3926
1388
    signals->now_blocking.raise();
3927
1389
    EXPECT_TRUE(signals->event_received.wait_for(std::chrono::seconds{5}));
3928
1390
    mir_buffer_stream_release(stream, &notify_buffer_stream_destroyed, &signals->buffer_stream_destroyed);
3929
1391
}
3930
1392
}
3931
1393
3932
1394
TEST_F(ClientLibrary, rpc_blocking_doesnt_block_event_delivery_with_auto_dispatch)
3933
1395
{
3934
1396
    using namespace testing;
3935
1397
3936
1398
    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
3937
1399
3938
1400
    auto fake_keyboard = mtf::add_fake_input_device(
3939
1401
        mi::InputDeviceInfo{"keyboard", "keyboard-unique-id", mi::DeviceCapability::keyboard});
3940
1402
3941
1403
3942
1404
    ASSERT_THAT(connection, IsValid());
3943
1405
    auto signals = std::make_shared<SignalData>();
3944
1406
3945
1407
    auto surface_spec = mir_connection_create_spec_for_normal_surface(connection,
3946
1408
                                                                      233, 355,
3947
1409
                                                                      mir_pixel_format_argb_8888);
3948
1410
    mir_surface_spec_set_event_handler(surface_spec, &notifying_event_handler, &signals);
3949
1411
3950
1412
    auto surf = mir_surface_create_sync(surface_spec);
3951
1413
    mir_surface_spec_release(surface_spec);
3952
1414
3953
1415
    ASSERT_THAT(surf, IsValid());
3954
1416
3955
1417
    auto buffer_stream = mir_surface_get_buffer_stream(surf);
3956
1418
3957
1419
    // Ensure that the surface is focused.
3958
1420
    mir_buffer_stream_swap_buffers_sync(buffer_stream);
3959
1421
    ASSERT_TRUE(signals->focus_received.wait_for(std::chrono::seconds{5}));
3960
1422
3961
1423
    auto wh = mir_connection_create_buffer_stream(
3962
1424
        connection,
3963
1425
        800, 600,
3964
1426
        mir_pixel_format_abgr_8888,
3965
1427
        mir_buffer_usage_software,
3966
1428
        &blocking_buffer_stream_callback, &signals);
3967
1429
3968
1430
    EXPECT_TRUE(signals->now_blocking.wait_for(std::chrono::seconds{5}));
3969
1431
    EXPECT_FALSE(signals->event_received.raised());
3970
1432
3971
1433
    fake_keyboard->emit_event(mis::a_key_down_event());
3972
1434
3973
1435
    EXPECT_TRUE(signals->event_received.wait_for(std::chrono::seconds{5}));
3974
1436
    EXPECT_TRUE(signals->buffer_stream_destroyed.wait_for(std::chrono::seconds{5}));
3975
1437
3976
1438
    mir_wait_for(wh);
3977
1439
    mir_surface_release_sync(surf);
3978
1440
    mir_connection_release(connection);
3979
1441
}
3980
1442
3981
1443
namespace
3982
1444
{
3983
1445
void async_release_completed(MirSurface*, void* ctx)
3984
1446
{
3985
1447
    auto called = reinterpret_cast<bool*>(ctx);
3986
1448
    *called = true;
3987
1449
}
3988
1450
3989
1451
void async_creation_completed(MirSurface* surf, void* ctx)
3990
1452
{
3991
1453
    mir_surface_release(surf, &async_release_completed, ctx);
3992
1454
}
3993
1455
}
3994
1456
3995
1457
TEST_F(ClientLibrary, sync_call_completes_before_previous_undispatched_call)
3996
1458
{
3997
1459
    using namespace std::literals::chrono_literals;
3998
1460
    using namespace testing;
3999
1461
4000
1462
    auto timeout = std::chrono::steady_clock::now() + 60s;
4001
1463
4002
1464
    ThreadTrackingCallbacks data;
4003
1465
4004
1466
    auto connection = mir_connect_with_manual_dispatch(new_connection().c_str(), __PRETTY_FUNCTION__, &ThreadTrackingCallbacks::connection_ready, &data);
4005
1467
    ASSERT_THAT(connection, Ne(nullptr));
4006
1468
4007
1469
    pump_eventloop_until(connection, [connection]() { return mir_connection_is_valid(connection); }, timeout);
4008
1470
4009
1471
    bool async_call_completed{false};
4010
1472
4011
1473
    auto surface_spec = mir_connection_create_spec_for_normal_surface(connection,
4012
1474
                                                                      233, 355,
4013
1475
                                                                      mir_pixel_format_argb_8888);
4014
1476
    mir_surface_create(surface_spec, &async_creation_completed, &async_call_completed);
4015
1477
4016
1478
    EXPECT_FALSE(async_call_completed);
4017
1479
    auto surf = mir_surface_create_sync(surface_spec);
4018
1480
    mir_surface_spec_release(surface_spec);
4019
1481
4020
1482
    EXPECT_THAT(surf, IsValid());
4021
1483
    EXPECT_FALSE(async_call_completed);
4022
1484
4023
1485
    mir_surface_release_sync(surf);
4024
1486
    EXPECT_FALSE(async_call_completed);
4025
1487
4026
1488
    pump_eventloop_until(connection, [&async_call_completed]() { return async_call_completed;}, timeout);
4027
1489
4028
1490
}
4029
1491
4030
1492
TEST_F(ClientLibrary, can_connect_synchronously_with_manual_dispatch)
4031
1493
{
4032
1494
    using namespace testing;
4033
1495
4034
1496
    auto connection = mir_connect_with_manual_dispatch_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
4035
1497
4036
1498
    EXPECT_THAT(connection, IsValid());
4037
1499
4038
1500
    mir_connection_release(connection);
4039
1501
}
4040
1502
4041
1503
>>>>>>> MERGE-SOURCE
4042
1125
TEST_F(ClientLibrary, can_get_persistent_surface_id)
1504
TEST_F(ClientLibrary, can_get_persistent_surface_id)
4043
1126
{
1505
{
4044
1127
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
1506
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
4045
@@ -1225,6 +1604,7 @@
4046
1225
    mir_buffer_stream_release_sync(stream);
1604
    mir_buffer_stream_release_sync(stream);
4047
1226
    mir_connection_release(connection);
1605
    mir_connection_release(connection);
4048
1227
}
1606
}
4049
1607
<<<<<<< TREE
4050
1228
1608
4051
1229
TEST_F(ClientLibrary, client_api_version)
1609
TEST_F(ClientLibrary, client_api_version)
4052
1230
{
1610
{
4053
@@ -1232,3 +1612,117 @@
4054
1232
                                    MIR_CLIENT_API_VERSION_MINOR,
1612
                                    MIR_CLIENT_API_VERSION_MINOR,
4055
1233
                                    MIR_CLIENT_API_VERSION_PATCH) == mir_get_client_api_version());
1613
                                    MIR_CLIENT_API_VERSION_PATCH) == mir_get_client_api_version());
4056
1234
}
1614
}
4057
1615
=======
4058
1616
4059
1617
TEST_F(ClientLibrary, synchronously_creating_buffer_stream_results_in_valid_buffer_stream)
4060
1618
{
4061
1619
    using namespace testing;
4062
1620
4063
1621
    auto connection = mir_connect_with_manual_dispatch_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
4064
1622
4065
1623
    ASSERT_THAT(connection, IsValid());
4066
1624
4067
1625
    int const width{640}, height{480};
4068
1626
    auto stream = mir_connection_create_buffer_stream_sync(
4069
1627
        connection,
4070
1628
        width, height,
4071
1629
        mir_pixel_format_abgr_8888,
4072
1630
        mir_buffer_usage_software);
4073
1631
4074
1632
    EXPECT_THAT(stream, IsValid());
4075
1633
4076
1634
    MirGraphicsRegion region;
4077
1635
    mir_buffer_stream_get_graphics_region(stream, &region);
4078
1636
4079
1637
    EXPECT_THAT(region.vaddr, NotNull());
4080
1638
    EXPECT_THAT(region.width, Eq(width));
4081
1639
    EXPECT_THAT(region.height, Eq(height));
4082
1640
    EXPECT_THAT(region.stride, Ge(width));
4083
1641
    EXPECT_THAT(region.pixel_format, Eq(mir_pixel_format_abgr_8888));
4084
1642
4085
1643
    mir_buffer_stream_release_sync(stream);
4086
1644
    mir_connection_release(connection);
4087
1645
}
4088
1646
4089
1647
TEST_F(ClientLibrary, default_surface_stream_is_valid_in_created_callback)
4090
1648
{
4091
1649
    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
4092
1650
    ASSERT_TRUE(mir_connection_is_valid(connection));
4093
1651
4094
1652
    auto surface_spec = mir_connection_create_spec_for_normal_surface(
4095
1653
        connection,
4096
1654
        800, 600,
4097
1655
        mir_pixel_format_argb_8888);
4098
1656
4099
1657
    mt::Signal done;
4100
1658
4101
1659
    mir_surface_create(
4102
1660
        surface_spec,
4103
1661
        [](MirSurface* surf, void* ctx)
4104
1662
        {
4105
1663
            auto stream = mir_surface_get_buffer_stream(surf);
4106
1664
            EXPECT_THAT(stream, NotNull());
4107
1665
            EXPECT_TRUE(mir_buffer_stream_is_valid(stream));
4108
1666
4109
1667
            MirNativeBuffer* package;
4110
1668
            mir_buffer_stream_get_current_buffer(stream, &package);
4111
1669
4112
1670
            EXPECT_THAT(package, NotNull());
4113
1671
4114
1672
            mir_surface_release(
4115
1673
                surf,
4116
1674
                [](MirSurface*, void* ctx)
4117
1675
                {
4118
1676
                    auto done = reinterpret_cast<mt::Signal*>(ctx);
4119
1677
4120
1678
                    done->raise();
4121
1679
                },
4122
1680
                ctx);
4123
1681
        },
4124
1682
        &done);
4125
1683
    mir_surface_spec_release(surface_spec);
4126
1684
4127
1685
    // ASSERT_TRUE rather than EXPECT_TRUE so that the test dies on client deadlock.
4128
1686
    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
4129
1687
4130
1688
    mir_connection_release(connection);
4131
1689
}
4132
1690
4133
1691
TEST_F(ClientLibrary, buffer_stream_is_valid_in_created_callback)
4134
1692
{
4135
1693
    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
4136
1694
    ASSERT_TRUE(mir_connection_is_valid(connection));
4137
1695
4138
1696
    mt::Signal done;
4139
1697
4140
1698
    mir_connection_create_buffer_stream(
4141
1699
        connection,
4142
1700
        800, 600,
4143
1701
        mir_pixel_format_argb_8888,
4144
1702
        mir_buffer_usage_software,
4145
1703
        [](MirBufferStream* stream, void* ctx)
4146
1704
        {
4147
1705
            EXPECT_THAT(stream, IsValid());
4148
1706
4149
1707
            MirNativeBuffer* package;
4150
1708
            mir_buffer_stream_get_current_buffer(stream, &package);
4151
1709
4152
1710
            EXPECT_THAT(package, NotNull());
4153
1711
4154
1712
            mir_buffer_stream_release(
4155
1713
                stream,
4156
1714
                [](MirBufferStream*, void* ctx)
4157
1715
                {
4158
1716
                    auto done = reinterpret_cast<mt::Signal*>(ctx);
4159
1717
4160
1718
                    done->raise();
4161
1719
                },
4162
1720
                ctx);
4163
1721
        },
4164
1722
        &done);
4165
1723
4166
1724
    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
4167
1725
4168
1726
    mir_connection_release(connection);
4169
1727
}
4170
1728
>>>>>>> MERGE-SOURCE
4171
1235
1729
4172
=== modified file 'tests/acceptance-tests/test_client_surfaces.cpp'
4173
--- tests/acceptance-tests/test_client_surfaces.cpp	2017-03-14 04:41:33 +0000
4174
+++ tests/acceptance-tests/test_client_surfaces.cpp	2017-03-28 00:17:49 +0000
4175
@@ -28,6 +28,7 @@
4176
28
#include "mir_test_framework/any_surface.h"
28
#include "mir_test_framework/any_surface.h"
4177
29
#include "mir/test/validity_matchers.h"
29
#include "mir/test/validity_matchers.h"
4178
30
#include "mir/test/fake_shared.h"
30
#include "mir/test/fake_shared.h"
4179
31
#include "mir/test/signal.h"
4180
31
32
4181
32
#include <gmock/gmock.h>
33
#include <gmock/gmock.h>
4182
33
#include <gtest/gtest.h>
34
#include <gtest/gtest.h>
4183
@@ -391,4 +392,43 @@
4184
391
392
4185
392
    mir_connection_release(im_connection);
393
    mir_connection_release(im_connection);
4186
393
}
394
}
4187
395
<<<<<<< TREE
4188
394
#pragma GCC diagnostic pop
396
#pragma GCC diagnostic pop
4189
397
=======
4190
398
4191
399
TEST_F(ClientSurfaces, default_buffer_stream_is_fully_constructed_in_surface_created_callback)
4192
400
{
4193
401
    using namespace testing;
4194
402
    using namespace std::chrono_literals;
4195
403
4196
404
    auto surface_spec = mir_connection_create_spec_for_normal_surface(
4197
405
        connection,
4198
406
        800, 600,
4199
407
        mir_pixel_format_argb_8888);
4200
408
4201
409
    mt::Signal surface_released;
4202
410
    mir_surface_create(
4203
411
        surface_spec,
4204
412
        [](MirSurface* surf, void* ctx)
4205
413
        {
4206
414
            EXPECT_THAT(surf, IsValid());
4207
415
            auto buffer_stream = mir_surface_get_buffer_stream(surf);
4208
416
            MirGraphicsRegion region;
4209
417
            mir_buffer_stream_get_graphics_region(buffer_stream, &region);
4210
418
            EXPECT_THAT(region.vaddr, NotNull());
4211
419
4212
420
            mir_surface_release(
4213
421
                surf,
4214
422
                [](MirSurface*, void* ctx)
4215
423
                {
4216
424
                    auto& done = *reinterpret_cast<mt::Signal*>(ctx);
4217
425
                    done.raise();
4218
426
                },
4219
427
                ctx);
4220
428
        },
4221
429
        &surface_released);
4222
430
    mir_surface_spec_release(surface_spec);
4223
431
4224
432
    EXPECT_TRUE(surface_released.wait_for(10s));
4225
433
}
4226
434
>>>>>>> MERGE-SOURCE
4227
395
435
4228
=== modified file 'tests/acceptance-tests/test_render_surface.cpp'
4229
--- tests/acceptance-tests/test_render_surface.cpp	2017-03-10 19:47:57 +0000
4230
+++ tests/acceptance-tests/test_render_surface.cpp	2017-03-28 00:17:49 +0000
4231
@@ -23,11 +23,14 @@
4232
23
#include "mir/geometry/size.h"
23
#include "mir/geometry/size.h"
4233
24
#include "mir_test_framework/headless_in_process_server.h"
24
#include "mir_test_framework/headless_in_process_server.h"
4234
25
#include "mir/test/validity_matchers.h"
25
#include "mir/test/validity_matchers.h"
4235
26
#include "mir/test/signal.h"
4236
26
27
4237
27
#include <gtest/gtest.h>
28
#include <gtest/gtest.h>
4238
28
#include <gmock/gmock.h>
29
#include <gmock/gmock.h>
4239
30
#include "mir/test/signal.h"
4240
29
31
4241
30
namespace mtf = mir_test_framework;
32
namespace mtf = mir_test_framework;
4242
33
namespace mt = mir::test;
4243
31
namespace geom = mir::geometry;
34
namespace geom = mir::geometry;
4244
32
35
4245
33
namespace
36
namespace
4246
@@ -54,7 +57,7 @@
4247
54
    EXPECT_TRUE(mir_render_surface_is_valid(rs));
57
    EXPECT_TRUE(mir_render_surface_is_valid(rs));
4248
55
    EXPECT_THAT(mir_render_surface_get_error_message(rs), StrEq(""));
58
    EXPECT_THAT(mir_render_surface_get_error_message(rs), StrEq(""));
4249
56
59
4251
57
    mir_render_surface_release(rs);
60
    mir_render_surface_release_sync(rs);
4252
58
    mir_connection_release(connection);
61
    mir_connection_release(connection);
4253
59
}
62
}
4254
60
63
4255
@@ -73,9 +76,13 @@
4256
73
        return {width, height};
76
        return {width, height};
4257
74
    };
77
    };
4258
75
    auto physical_size = determine_physical_size(rs);
78
    auto physical_size = determine_physical_size(rs);
4260
76
    auto bs = mir_render_surface_get_buffer_stream(
79
4261
80
    mt::Signal done;
4262
81
4263
82
    mir_render_surface_get_buffer_stream(
4264
77
        rs,
83
        rs,
4265
78
        physical_size.width.as_int(), physical_size.height.as_int(),
84
        physical_size.width.as_int(), physical_size.height.as_int(),
4266
85
<<<<<<< TREE
4267
79
        mir_pixel_format_abgr_8888);
86
        mir_pixel_format_abgr_8888);
4268
80
87
4269
81
    ASSERT_THAT(bs, NotNull());
88
    ASSERT_THAT(bs, NotNull());
4270
@@ -83,6 +90,22 @@
4271
83
    EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
90
    EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
4272
84
91
4273
85
    mir_render_surface_release(rs);
92
    mir_render_surface_release(rs);
4274
93
=======
4275
94
        mir_pixel_format_abgr_8888,
4276
95
        mir_buffer_usage_hardware,
4277
96
        [](MirBufferStream* bs, void* ctx)
4278
97
        {
4279
98
            ASSERT_THAT(bs, NotNull());
4280
99
            EXPECT_THAT(bs, IsValid());
4281
100
4282
101
            reinterpret_cast<mt::Signal*>(ctx)->raise();
4283
102
        },
4284
103
        &done);
4285
104
4286
105
    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
4287
106
4288
107
    mir_render_surface_release_sync(rs);
4289
108
>>>>>>> MERGE-SOURCE
4290
86
    mir_connection_release(connection);
109
    mir_connection_release(connection);
4291
87
}
110
}
4292
88
111
4293
@@ -94,23 +117,21 @@
4294
94
    auto rs = mir_connection_create_render_surface_sync(
117
    auto rs = mir_connection_create_render_surface_sync(
4295
95
        connection, logical_size.width.as_int(), logical_size.height.as_int());
118
        connection, logical_size.width.as_int(), logical_size.height.as_int());
4296
96
119
4298
97
    auto bs = mir_render_surface_get_buffer_stream(
120
    auto bs = mir_render_surface_get_buffer_stream_sync(
4299
98
        rs,
121
        rs,
4300
99
        physical_size.width.as_int(), physical_size.height.as_int(),
122
        physical_size.width.as_int(), physical_size.height.as_int(),
4301
100
        mir_pixel_format_abgr_8888);
123
        mir_pixel_format_abgr_8888);
4302
101
124
4306
102
    ASSERT_THAT(bs, NotNull());
125
    EXPECT_THAT(bs, IsValid());
4304
103
    EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
4305
104
    EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
4307
105
126
4309
106
    auto bs2 = mir_render_surface_get_buffer_stream(
127
    auto bs2 = mir_render_surface_get_buffer_stream_sync(
4310
107
        rs,
128
        rs,
4311
108
        physical_size.width.as_int(), physical_size.height.as_int(),
129
        physical_size.width.as_int(), physical_size.height.as_int(),
4312
109
        mir_pixel_format_abgr_8888);
130
        mir_pixel_format_abgr_8888);
4313
110
131
4314
111
    EXPECT_THAT(bs2, Eq(nullptr));
132
    EXPECT_THAT(bs2, Eq(nullptr));
4315
112
133
4317
113
    mir_render_surface_release(rs);
134
    mir_render_surface_release_sync(rs);
4318
114
    mir_connection_release(connection);
135
    mir_connection_release(connection);
4319
115
}
136
}
4320
116
137
4321
@@ -121,9 +142,13 @@
4322
121
142
4323
122
    auto rs = mir_connection_create_render_surface_sync(
143
    auto rs = mir_connection_create_render_surface_sync(
4324
123
        connection, logical_size.width.as_int(), logical_size.height.as_int());
144
        connection, logical_size.width.as_int(), logical_size.height.as_int());
4326
124
    auto bs = mir_render_surface_get_buffer_stream(
145
4327
146
    mt::Signal done;
4328
147
4329
148
    mir_render_surface_get_buffer_stream(
4330
125
        rs,
149
        rs,
4331
126
        physical_size.width.as_int(), physical_size.height.as_int(),
150
        physical_size.width.as_int(), physical_size.height.as_int(),
4332
151
<<<<<<< TREE
4333
127
        mir_pixel_format_abgr_8888);
152
        mir_pixel_format_abgr_8888);
4334
128
153
4335
129
    ASSERT_THAT(bs, NotNull());
154
    ASSERT_THAT(bs, NotNull());
4336
@@ -131,6 +156,22 @@
4337
131
    EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
156
    EXPECT_THAT(mir_buffer_stream_get_error_message(bs), StrEq(""));
4338
132
157
4339
133
    mir_render_surface_release(rs);
158
    mir_render_surface_release(rs);
4340
159
=======
4341
160
        mir_pixel_format_abgr_8888,
4342
161
        mir_buffer_usage_hardware,
4343
162
        [](MirBufferStream* bs, void* ctx)
4344
163
        {
4345
164
            ASSERT_THAT(bs, NotNull());
4346
165
            EXPECT_THAT(bs, IsValid());
4347
166
4348
167
            reinterpret_cast<mt::Signal*>(ctx)->raise();
4349
168
        },
4350
169
        &done);
4351
170
4352
171
    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
4353
172
4354
173
    mir_render_surface_release_sync(rs);
4355
174
>>>>>>> MERGE-SOURCE
4356
134
    mir_connection_release(connection);
175
    mir_connection_release(connection);
4357
135
}
176
}
4358
136
177
4359
@@ -152,8 +193,13 @@
4360
152
    EXPECT_THAT(window, IsValid());
193
    EXPECT_THAT(window, IsValid());
4361
153
    EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
194
    EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
4362
154
195
4363
196
<<<<<<< TREE
4364
155
    mir_render_surface_release(rs);
197
    mir_render_surface_release(rs);
4365
156
    mir_window_release_sync(window);
198
    mir_window_release_sync(window);
4366
199
=======
4367
200
    mir_render_surface_release_sync(rs);
4368
201
    mir_surface_release_sync(surface);
4369
202
>>>>>>> MERGE-SOURCE
4370
157
    mir_connection_release(connection);
203
    mir_connection_release(connection);
4371
158
}
204
}
4372
159
205
4373
@@ -166,19 +212,55 @@
4374
166
212
4375
167
    auto rs = mir_connection_create_render_surface_sync(
213
    auto rs = mir_connection_create_render_surface_sync(
4376
168
        connection, logical_size.width.as_int(), logical_size.height.as_int());
214
        connection, logical_size.width.as_int(), logical_size.height.as_int());
4377
215
<<<<<<< TREE
4378
169
    auto spec = mir_create_normal_window_spec(connection, width, height);
216
    auto spec = mir_create_normal_window_spec(connection, width, height);
4379
170
    mir_window_spec_set_pixel_format(spec, format);
217
    mir_window_spec_set_pixel_format(spec, format);
4380
171
    mir_window_spec_add_render_surface(spec, rs, width, height, 0, 0);
218
    mir_window_spec_add_render_surface(spec, rs, width, height, 0, 0);
4381
172
    auto window = mir_create_window_sync(spec);
219
    auto window = mir_create_window_sync(spec);
4382
173
    mir_window_spec_release(spec);
220
    mir_window_spec_release(spec);
4383
174
    auto bs = mir_render_surface_get_buffer_stream(rs, 640, 480, format);
221
    auto bs = mir_render_surface_get_buffer_stream(rs, 640, 480, format);
4385
175
222
=======
4386
223
    auto spec = mir_connection_create_spec_for_normal_surface(connection,
4387
224
                                                              width, height,
4388
225
                                                              format);
4389
226
    mir_surface_spec_add_render_surface(spec, rs, width, height, 0, 0);
4390
227
    auto surface = mir_surface_create_sync(spec);
4391
228
    mir_surface_spec_release(spec);
4392
229
    mt::Signal done;
4393
230
4394
231
    mir_render_surface_get_buffer_stream(
4395
232
        rs,
4396
233
        640, 480,
4397
234
        format,
4398
235
        usage,
4399
236
        [](MirBufferStream* bs, void* ctx)
4400
237
        {
4401
238
            ASSERT_THAT(bs, NotNull());
4402
239
            EXPECT_THAT(bs, IsValid());
4403
240
4404
241
            reinterpret_cast<mt::Signal*>(ctx)->raise();
4405
242
        },
4406
243
        &done);
4407
244
4408
245
>>>>>>> MERGE-SOURCE
4409
246
4410
247
<<<<<<< TREE
4411
176
    EXPECT_THAT(window, IsValid());
248
    EXPECT_THAT(window, IsValid());
4412
177
    EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
249
    EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
4413
178
    EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
250
    EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
4414
179
251
4415
180
    mir_render_surface_release(rs);
252
    mir_render_surface_release(rs);
4416
181
    mir_window_release_sync(window);
253
    mir_window_release_sync(window);
4417
254
=======
4418
255
    EXPECT_THAT(surface, IsValid());
4419
256
4420
257
    EXPECT_THAT(mir_surface_get_buffer_stream(surface), Eq(nullptr));
4421
258
4422
259
    ASSERT_TRUE(done.wait_for(std::chrono::seconds{20}));
4423
260
4424
261
    mir_render_surface_release_sync(rs);
4425
262
    mir_surface_release_sync(surface);
4426
263
>>>>>>> MERGE-SOURCE
4427
182
    mir_connection_release(connection);
264
    mir_connection_release(connection);
4428
183
}
265
}
4429
184
266
4430
@@ -194,7 +276,7 @@
4431
194
    ASSERT_THAT(pc, NotNull());
276
    ASSERT_THAT(pc, NotNull());
4432
195
    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
277
    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
4433
196
278
4435
197
    mir_render_surface_release(rs);
279
    mir_render_surface_release_sync(rs);
4436
198
    mir_connection_release(connection);
280
    mir_connection_release(connection);
4437
199
}
281
}
4438
200
282
4439
@@ -214,7 +296,7 @@
4440
214
296
4441
215
    EXPECT_THAT(pc2, Eq(nullptr));
297
    EXPECT_THAT(pc2, Eq(nullptr));
4442
216
298
4444
217
    mir_render_surface_release(rs);
299
    mir_render_surface_release_sync(rs);
4445
218
    mir_connection_release(connection);
300
    mir_connection_release(connection);
4446
219
}
301
}
4447
220
302
4448
@@ -238,8 +320,13 @@
4449
238
    EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
320
    EXPECT_THAT(mir_window_get_buffer_stream(window), Eq(nullptr));
4450
239
    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
321
    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
4451
240
322
4452
323
<<<<<<< TREE
4453
241
    mir_render_surface_release(rs);
324
    mir_render_surface_release(rs);
4454
242
    mir_window_release_sync(window);
325
    mir_window_release_sync(window);
4455
326
=======
4456
327
    mir_render_surface_release_sync(rs);
4457
328
    mir_surface_release_sync(surface);
4458
329
>>>>>>> MERGE-SOURCE
4459
243
    mir_connection_release(connection);
330
    mir_connection_release(connection);
4460
244
}
331
}
4461
245
332
4462
@@ -254,7 +341,7 @@
4463
254
    ASSERT_THAT(pc, NotNull());
341
    ASSERT_THAT(pc, NotNull());
4464
255
    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
342
    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
4465
256
343
4467
257
    mir_render_surface_release(rs);
344
    mir_render_surface_release_sync(rs);
4468
258
    mir_connection_release(connection);
345
    mir_connection_release(connection);
4469
259
}
346
}
4470
260
347
4471
@@ -270,14 +357,14 @@
4472
270
    ASSERT_THAT(pc, NotNull());
357
    ASSERT_THAT(pc, NotNull());
4473
271
    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
358
    EXPECT_TRUE(mir_presentation_chain_is_valid(pc));
4474
272
359
4476
273
    auto bs = mir_render_surface_get_buffer_stream(
360
    auto bs = mir_render_surface_get_buffer_stream_sync(
4477
274
        rs,
361
        rs,
4478
275
        physical_size.width.as_int(), physical_size.height.as_int(),
362
        physical_size.width.as_int(), physical_size.height.as_int(),
4479
276
        mir_pixel_format_abgr_8888);
363
        mir_pixel_format_abgr_8888);
4480
277
364
4481
278
    EXPECT_THAT(bs, Eq(nullptr));
365
    EXPECT_THAT(bs, Eq(nullptr));
4482
279
366
4484
280
    mir_render_surface_release(rs);
367
    mir_render_surface_release_sync(rs);
4485
281
    mir_connection_release(connection);
368
    mir_connection_release(connection);
4486
282
}
369
}
4487
283
370
4488
@@ -288,20 +375,148 @@
4489
288
375
4490
289
    auto rs = mir_connection_create_render_surface_sync(
376
    auto rs = mir_connection_create_render_surface_sync(
4491
290
        connection, logical_size.width.as_int(), logical_size.height.as_int());
377
        connection, logical_size.width.as_int(), logical_size.height.as_int());
4493
291
    auto bs = mir_render_surface_get_buffer_stream(
378
    auto bs = mir_render_surface_get_buffer_stream_sync(
4494
292
        rs,
379
        rs,
4495
293
        physical_size.width.as_int(), physical_size.height.as_int(),
380
        physical_size.width.as_int(), physical_size.height.as_int(),
4496
294
        mir_pixel_format_abgr_8888);
381
        mir_pixel_format_abgr_8888);
4497
295
382
4500
296
    ASSERT_THAT(bs, NotNull());
383
    EXPECT_THAT(bs, IsValid());
4499
297
    EXPECT_TRUE(mir_buffer_stream_is_valid(bs));
4501
298
384
4502
299
    auto pc = mir_render_surface_get_presentation_chain(rs);
385
    auto pc = mir_render_surface_get_presentation_chain(rs);
4503
300
386
4504
301
    EXPECT_THAT(pc, Eq(nullptr));
387
    EXPECT_THAT(pc, Eq(nullptr));
4505
302
388
4508
303
    mir_render_surface_release(rs);
389
    mir_render_surface_release_sync(rs);
4509
304
    mir_connection_release(connection);
390
    mir_connection_release(connection);
4510
391
}
4511
392
4512
393
TEST_F(RenderSurfaceTest, asynchronous_render_surface_destruction_works_with_realised_buffer_stream)
4513
394
{
4514
395
    auto physical_size = logical_size;
4515
396
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
4516
397
4517
398
    auto rs = mir_connection_create_render_surface_sync(
4518
399
        connection, logical_size.width.as_int(), logical_size.height.as_int());
4519
400
    mir_render_surface_get_buffer_stream_sync(
4520
401
        rs,
4521
402
        physical_size.width.as_int(), physical_size.height.as_int(),
4522
403
        mir_pixel_format_abgr_8888,
4523
404
        mir_buffer_usage_hardware);
4524
405
4525
406
    struct Context
4526
407
    {
4527
408
        MirRenderSurface* rs;
4528
409
        mt::Signal done;
4529
410
    } context;
4530
411
4531
412
    context.rs = rs;
4532
413
4533
414
    mir_render_surface_release(
4534
415
        rs,
4535
416
        [](MirRenderSurface* rs, void* ctx)
4536
417
        {
4537
418
            auto& context = *reinterpret_cast<Context*>(ctx);
4538
419
            EXPECT_THAT(rs, Eq(context.rs));
4539
420
            /*
4540
421
             * Should really test that the render surface isn't valid here, but that fails.
4541
422
             *
4542
423
            EXPECT_THAT(rs, Not(IsValid()));
4543
424
             */
4544
425
            context.done.raise();
4545
426
        },
4546
427
        &context);
4547
428
4548
429
    ASSERT_TRUE(context.done.wait_for(std::chrono::seconds{20}));
4549
430
4550
431
    mir_connection_release(connection);
4551
432
}
4552
433
4553
434
TEST_F(RenderSurfaceTest, asynchronous_render_surface_destruction_works_with_realised_presentation_chain)
4554
435
{
4555
436
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
4556
437
4557
438
    auto rs = mir_connection_create_render_surface_sync(
4558
439
        connection, logical_size.width.as_int(), logical_size.height.as_int());
4559
440
    mir_render_surface_get_presentation_chain(rs);
4560
441
4561
442
    struct Context
4562
443
    {
4563
444
        MirRenderSurface* rs;
4564
445
        mt::Signal done;
4565
446
    } context;
4566
447
4567
448
    context.rs = rs;
4568
449
4569
450
    mir_render_surface_release(
4570
451
        rs,
4571
452
        [](MirRenderSurface* rs, void* ctx)
4572
453
        {
4573
454
            auto& context = *reinterpret_cast<Context*>(ctx);
4574
455
            EXPECT_THAT(rs, Eq(context.rs));
4575
456
            /*
4576
457
             * Should really test that the render surface isn't valid here, but that fails.
4577
458
             *
4578
459
            EXPECT_THAT(rs, Not(IsValid()));
4579
460
             */
4580
461
            context.done.raise();
4581
462
        },
4582
463
        &context);
4583
464
4584
465
    ASSERT_TRUE(context.done.wait_for(std::chrono::seconds{20}));
4585
466
4586
467
    mir_connection_release(connection);
4587
468
}
4588
469
4589
470
TEST_F(RenderSurfaceTest, asynchronous_render_surface_destruction_works_with_no_backing_object)
4590
471
{
4591
472
    auto connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
4592
473
4593
474
    auto rs = mir_connection_create_render_surface_sync(
4594
475
        connection, logical_size.width.as_int(), logical_size.height.as_int());
4595
476
4596
477
    struct Context
4597
478
    {
4598
479
        MirRenderSurface* rs;
4599
480
        mt::Signal done;
4600
481
    } context;
4601
482
4602
483
    context.rs = rs;
4603
484
4604
485
    mir_render_surface_release(
4605
486
        rs,
4606
487
        [](MirRenderSurface* rs, void* ctx)
4607
488
        {
4608
489
            auto& context = *reinterpret_cast<Context*>(ctx);
4609
490
            EXPECT_THAT(rs, Eq(context.rs));
4610
491
            /*
4611
492
             * Should really test that the render surface isn't valid here, but that fails.
4612
493
             *
4613
494
            EXPECT_THAT(rs, Not(IsValid()));
4614
495
             */
4615
496
            context.done.raise();
4616
497
        },
4617
498
        &context);
4618
499
4619
500
    ASSERT_TRUE(context.done.wait_for(std::chrono::seconds{20}));
4620
501
4621
502
    mir_connection_release(connection);
4622
503
}
4623
504
4624
505
TEST_F(RenderSurfaceTest, asynchronous_destruction_calls_callback_on_failure)
4625
506
{
4626
507
    auto not_a_valid_client_side_rs = reinterpret_cast<MirRenderSurface*>(0x0ff01bb1);
4627
508
4628
509
    mt::Signal callback_called;
4629
510
4630
511
    mir_render_surface_release(
4631
512
        not_a_valid_client_side_rs,
4632
513
        [](MirRenderSurface*, void* ctx)
4633
514
        {
4634
515
            reinterpret_cast<mt::Signal*>(ctx)->raise();
4635
516
        },
4636
517
        &callback_called);
4637
518
4638
519
    EXPECT_TRUE(callback_called.wait_for(std::chrono::seconds{20}));
4639
305
}
520
}
4640
306
521
4641
307
TEST_F(RenderSurfaceTest, stores_user_set_size_for_driver_to_access)
522
TEST_F(RenderSurfaceTest, stores_user_set_size_for_driver_to_access)
4642
308
523
4643
=== modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
4644
--- tests/acceptance-tests/test_server_shutdown.cpp	2017-03-09 12:52:48 +0000
4645
+++ tests/acceptance-tests/test_server_shutdown.cpp	2017-03-28 00:17:49 +0000
4646
@@ -25,7 +25,7 @@
4647
25
#include "mir_test_framework/executable_path.h"
25
#include "mir_test_framework/executable_path.h"
4648
26
#include "mir/test/doubles/null_logger.h"
26
#include "mir/test/doubles/null_logger.h"
4649
27
27
4651
28
#include <gtest/gtest.h>
28
#include </usr/include/gtest/gtest.h>
4652
29
29
4653
30
namespace mt = mir::test;
30
namespace mt = mir::test;
4654
31
namespace mtf = mir_test_framework;
31
namespace mtf = mir_test_framework;
4655
32
32
4656
=== added file 'tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h.THIS'
4657
--- tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h.THIS	1970-01-01 00:00:00 +0000
4658
+++ tests/include/mir/test/doubles/mock_client_buffer_stream_factory.h.THIS	2017-03-28 00:17:49 +0000
4659
@@ -0,0 +1,59 @@
4660
1
/*
4661
2
 * Copyright © 2015 Canonical Ltd.
4662
3
 *
4663
4
 * This program is free software: you can redistribute it and/or modify it
4664
5
 * under the terms of the GNU General Public License version 3,
4665
6
 * as published by the Free Software Foundation.
4666
7
 *
4667
8
 * This program is distributed in the hope that it will be useful,
4668
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4669
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4670
11
 * GNU General Public License for more details.
4671
12
 *
4672
13
 * You should have received a copy of the GNU General Public License
4673
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4674
15
 *
4675
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
4676
17
 */
4677
18
4678
19
#ifndef MIR_TEST_DOUBLES_MOCK_CLIENT_BUFFER_STREAM_FACTORY_H_
4679
20
#define MIR_TEST_DOUBLES_MOCK_CLIENT_BUFFER_STREAM_FACTORY_H_
4680
21
4681
22
#include "src/client/client_buffer_stream_factory.h"
4682
23
#include "src/client/buffer_stream.h"
4683
24
4684
25
#include <gtest/gtest.h>
4685
26
#include <gmock/gmock.h>
4686
27
4687
28
namespace mir
4688
29
{
4689
30
namespace test
4690
31
{
4691
32
namespace doubles
4692
33
{
4693
34
4694
35
struct MockClientBufferStreamFactory : public client::ClientBufferStreamFactory
4695
36
{
4696
37
    MOCK_METHOD4(make_consumer_stream, std::shared_ptr<client::ClientBufferStream>(
4697
38
        MirConnection*,
4698
39
        protobuf::DisplayServer&,
4699
40
        protobuf::BufferStream const&,
4700
41
        std::string const&));
4701
42
    MOCK_METHOD4(make_producer_stream, std::shared_ptr<client::ClientBufferStream>(
4702
43
        MirConnection*,
4703
44
        protobuf::DisplayServer&,
4704
45
        protobuf::BufferStream const&,
4705
46
        std::string const&));
4706
47
    MOCK_METHOD5(make_producer_stream, client::ClientBufferStream*(
4707
48
        MirConnection*,
4708
49
        protobuf::DisplayServer&,
4709
50
        protobuf::BufferStreamParameters const&,
4710
51
        mir_buffer_stream_callback callback,
4711
52
        void* context));
4712
53
};
4713
54
4714
55
}
4715
56
}
4716
57
}
4717
58
4718
59
#endif // MIR_TEST_DOUBLES_MOCK_CLIENT_BUFFER_STREAM_FACTORY_H_
4719
0
60
4720
=== modified file 'tests/include/mir/test/doubles/mock_mir_buffer_stream.h'
4721
--- tests/include/mir/test/doubles/mock_mir_buffer_stream.h	2017-03-10 19:47:57 +0000
4722
+++ tests/include/mir/test/doubles/mock_mir_buffer_stream.h	2017-03-28 00:17:49 +0000
4723
@@ -50,6 +50,7 @@
4724
50
    MOCK_METHOD0(get_create_wait_handle, MirWaitHandle*(void));
50
    MOCK_METHOD0(get_create_wait_handle, MirWaitHandle*(void));
4725
51
    MOCK_CONST_METHOD0(rpc_id, frontend::BufferStreamId(void));
51
    MOCK_CONST_METHOD0(rpc_id, frontend::BufferStreamId(void));
4726
52
    MOCK_CONST_METHOD0(valid, bool(void));
52
    MOCK_CONST_METHOD0(valid, bool(void));
4727
53
    MOCK_CONST_METHOD0(has_buffer, bool(void));
4728
53
    MOCK_METHOD1(buffer_available, void(mir::protobuf::Buffer const&));
54
    MOCK_METHOD1(buffer_available, void(mir::protobuf::Buffer const&));
4729
54
    MOCK_METHOD0(buffer_unavailable, void());
55
    MOCK_METHOD0(buffer_unavailable, void());
4730
55
    MOCK_METHOD1(set_size, void(geometry::Size));
56
    MOCK_METHOD1(set_size, void(geometry::Size));
4731
56
57
4732
=== modified file 'tests/include/mir/test/doubles/stub_buffer_stream_factory.h'
4733
--- tests/include/mir/test/doubles/stub_buffer_stream_factory.h	2017-03-13 08:12:52 +0000
4734
+++ tests/include/mir/test/doubles/stub_buffer_stream_factory.h	2017-03-28 00:17:49 +0000
4735
@@ -21,7 +21,10 @@
4736
21
21
4737
22
#include "mir/frontend/client_buffers.h"
22
#include "mir/frontend/client_buffers.h"
4738
23
#include "mir/scene/buffer_stream_factory.h"
23
#include "mir/scene/buffer_stream_factory.h"
4739
24
#include "mir/frontend/buffer_sink.h"
4740
24
#include "stub_buffer_stream.h"
25
#include "stub_buffer_stream.h"
4741
26
#include "stub_buffer.h"
4742
27
#include "mir_test_framework/stub_platform_native_buffer.h"
4743
25
28
4744
26
namespace mir
29
namespace mir
4745
27
{
30
{
4746
@@ -32,8 +35,20 @@
4747
32
35
4748
33
struct StubClientBuffers : frontend::ClientBuffers
36
struct StubClientBuffers : frontend::ClientBuffers
4749
34
{
37
{
4750
38
<<<<<<< TREE
4751
35
    graphics::BufferID add_buffer(std::shared_ptr<graphics::Buffer> const&) override
39
    graphics::BufferID add_buffer(std::shared_ptr<graphics::Buffer> const&) override
4752
36
    {
40
    {
4753
41
=======
4754
42
    StubClientBuffers(std::shared_ptr<frontend::BufferSink> const& sink)
4755
43
        : sink{sink}
4756
44
    {
4757
45
    }
4758
46
4759
47
    graphics::BufferID add_buffer(graphics::BufferProperties const& props) override
4760
48
    {
4761
49
        StubBuffer buf{std::make_shared<mir_test_framework::NativeBuffer>(props), props.size};
4762
50
        sink->add_buffer(buf);
4763
51
>>>>>>> MERGE-SOURCE
4764
37
        return {};
52
        return {};
4765
38
    }
53
    }
4766
39
    void remove_buffer(graphics::BufferID) override
54
    void remove_buffer(graphics::BufferID) override
4767
@@ -50,6 +65,7 @@
4768
50
    {
65
    {
4769
51
    }
66
    }
4770
52
    std::shared_ptr<graphics::Buffer> buffer;
67
    std::shared_ptr<graphics::Buffer> buffer;
4771
68
    std::shared_ptr<frontend::BufferSink> const sink;
4772
53
};
69
};
4773
54
70
4774
55
struct StubBufferStreamFactory : public scene::BufferStreamFactory
71
struct StubBufferStreamFactory : public scene::BufferStreamFactory
4775
@@ -61,9 +77,9 @@
4776
61
        frontend::BufferStreamId, std::shared_ptr<frontend::ClientBuffers> const&,
77
        frontend::BufferStreamId, std::shared_ptr<frontend::ClientBuffers> const&,
4777
62
        graphics::BufferProperties const&) { return std::make_shared<StubBufferStream>(); }
78
        graphics::BufferProperties const&) { return std::make_shared<StubBufferStream>(); }
4778
63
    std::shared_ptr<frontend::ClientBuffers> create_buffer_map(
79
    std::shared_ptr<frontend::ClientBuffers> create_buffer_map(
4780
64
        std::shared_ptr<frontend::BufferSink> const&)
80
        std::shared_ptr<frontend::BufferSink> const& sink)
4781
65
    {
81
    {
4783
66
        return std::make_shared<StubClientBuffers>();
82
        return std::make_shared<StubClientBuffers>(sink);
4784
67
    }
83
    }
4785
68
};
84
};
4786
69
}
85
}
4787
70
86
4788
=== added file 'tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h.THIS'
4789
--- tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h.THIS	1970-01-01 00:00:00 +0000
4790
+++ tests/include/mir/test/doubles/stub_client_buffer_stream_factory.h.THIS	2017-03-28 00:17:49 +0000
4791
@@ -0,0 +1,66 @@
4792
1
/*
4793
2
 * Copyright © 2015 Canonical Ltd.
4794
3
 *
4795
4
 * This program is free software: you can redistribute it and/or modify it
4796
5
 * under the terms of the GNU General Public License version 3,
4797
6
 * as published by the Free Software Foundation.
4798
7
 *
4799
8
 * This program is distributed in the hope that it will be useful,
4800
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4801
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4802
11
 * GNU General Public License for more details.
4803
12
 *
4804
13
 * You should have received a copy of the GNU General Public License
4805
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4806
15
 *
4807
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
4808
17
 */
4809
18
4810
19
#ifndef MIR_TEST_DOUBLES_STUB_CLIENT_BUFFER_STREAM_FACTORY_H_
4811
20
#define MIR_TEST_DOUBLES_STUB_CLIENT_BUFFER_STREAM_FACTORY_H_
4812
21
4813
22
#include "src/client/client_buffer_stream_factory.h"
4814
23
#include "src/client/buffer_stream.h"
4815
24
4816
25
namespace mir
4817
26
{
4818
27
namespace test
4819
28
{
4820
29
namespace doubles
4821
30
{
4822
31
4823
32
struct StubClientBufferStreamFactory : public client::ClientBufferStreamFactory
4824
33
{
4825
34
    std::shared_ptr<client::ClientBufferStream> make_consumer_stream(
4826
35
        MirConnection* /* allocating_connection */,
4827
36
        protobuf::DisplayServer& /* server */,
4828
37
        protobuf::BufferStream const& /* protobuf_bs */,
4829
38
        std::string const& /* surface_name */) override
4830
39
    {
4831
40
        return nullptr;
4832
41
    }
4833
42
4834
43
    std::shared_ptr<client::ClientBufferStream> make_producer_stream(
4835
44
        MirConnection* /* allocating_connection */,
4836
45
        protobuf::DisplayServer& /* server */,
4837
46
        protobuf::BufferStream const& /* protobuf_bs */,
4838
47
        std::string const& /* surface_name */) override
4839
48
    {
4840
49
        return nullptr;
4841
50
    }
4842
51
4843
52
    client::ClientBufferStream* make_producer_stream(
4844
53
       MirConnection* /* allocating_connection */,
4845
54
       protobuf::DisplayServer& /* server */,
4846
55
       protobuf::BufferStreamParameters const& /* params */,
4847
56
       mir_buffer_stream_callback /* callback */, void* /* context */) override
4848
57
    {
4849
58
        return nullptr;
4850
59
    }
4851
60
};
4852
61
4853
62
}
4854
63
}
4855
64
}
4856
65
4857
66
#endif // MIR_TEST_DOUBLES_STUB_CLIENT_BUFFER_STREAM_FACTORY_H_
4858
0
67
4859
=== modified file 'tests/integration-tests/test_buffer_scheduling.cpp'
4860
--- tests/integration-tests/test_buffer_scheduling.cpp	2017-03-13 08:12:52 +0000
4861
+++ tests/integration-tests/test_buffer_scheduling.cpp	2017-03-28 00:17:49 +0000
4862
@@ -27,6 +27,7 @@
4863
27
#include "src/client/connection_surface_map.h"
27
#include "src/client/connection_surface_map.h"
4864
28
#include "src/server/compositor/stream.h"
28
#include "src/server/compositor/stream.h"
4865
29
#include "src/server/compositor/buffer_map.h"
29
#include "src/server/compositor/buffer_map.h"
4866
30
#include "mir/dispatch/action_queue.h"
4867
30
#include "mir/test/doubles/stub_client_buffer_factory.h"
31
#include "mir/test/doubles/stub_client_buffer_factory.h"
4868
31
#include "mir/test/doubles/mock_client_buffer_factory.h"
32
#include "mir/test/doubles/mock_client_buffer_factory.h"
4869
32
#include "mir/test/doubles/stub_buffer_allocator.h"
33
#include "mir/test/doubles/stub_buffer_allocator.h"
4870
@@ -37,6 +38,7 @@
4871
37
38
4872
38
namespace mt  = mir::test;
39
namespace mt  = mir::test;
4873
39
namespace mtd = mir::test::doubles;
40
namespace mtd = mir::test::doubles;
4874
41
namespace md = mir::dispatch;
4875
40
namespace mcl = mir::client;
42
namespace mcl = mir::client;
4876
41
namespace mc = mir::compositor;
43
namespace mc = mir::compositor;
4877
42
namespace mg = mir::graphics;
44
namespace mg = mir::graphics;
4878
@@ -290,7 +292,7 @@
4879
290
{
292
{
4880
291
    ScheduledProducer(std::shared_ptr<StubIpcSystem> const& ipc_stub, int nbuffers) :
293
    ScheduledProducer(std::shared_ptr<StubIpcSystem> const& ipc_stub, int nbuffers) :
4881
292
        ipc(ipc_stub),
294
        ipc(ipc_stub),
4883
293
        map(std::make_shared<mcl::ConnectionSurfaceMap>()),
295
        map(std::make_shared<mcl::ConnectionSurfaceMap>(std::make_shared<md::ActionQueue>())),
4884
294
        factory(std::make_shared<mcl::BufferFactory>()),
296
        factory(std::make_shared<mcl::BufferFactory>()),
4885
295
        vault(
297
        vault(
4886
296
            std::make_shared<mtd::StubClientBufferFactory>(), factory,
298
            std::make_shared<mtd::StubClientBufferFactory>(), factory,
4887
297
299
4888
=== modified file 'tests/integration-tests/test_surfaceloop.cpp'
4889
--- tests/integration-tests/test_surfaceloop.cpp	2017-01-18 02:29:37 +0000
4890
+++ tests/integration-tests/test_surfaceloop.cpp	2017-03-28 00:17:49 +0000
4891
@@ -17,6 +17,7 @@
4892
17
 */
17
 */
4893
18
18
4894
19
#include "mir_toolkit/mir_client_library.h"
19
#include "mir_toolkit/mir_client_library.h"
4895
20
#include "mir/graphics/buffer_ipc_message.h"
4896
20
21
4897
21
#include "mir/test/doubles/stub_buffer.h"
22
#include "mir/test/doubles/stub_buffer.h"
4898
22
#include "mir/test/doubles/stub_buffer_allocator.h"
23
#include "mir/test/doubles/stub_buffer_allocator.h"
4899
@@ -33,6 +34,7 @@
4900
33
#include <condition_variable>
34
#include <condition_variable>
4901
34
#include <gmock/gmock.h>
35
#include <gmock/gmock.h>
4902
35
#include <gtest/gtest.h>
36
#include <gtest/gtest.h>
4903
37
#include <src/client/lttng/shared_library_prober_report_tp.h>
4904
36
#include "mir/test/gmock_fixes.h"
38
#include "mir/test/gmock_fixes.h"
4905
37
39
4906
38
namespace mc = mir::compositor;
40
namespace mc = mir::compositor;
4907
@@ -44,35 +46,6 @@
4908
44
46
4909
45
namespace
47
namespace
4910
46
{
48
{
4911
47
geom::Size const size{640, 480};
4912
48
MirPixelFormat const format{mir_pixel_format_abgr_8888};
4913
49
mg::BufferUsage const usage{mg::BufferUsage::hardware};
4914
50
mg::BufferProperties const buffer_properties{size, format, usage};
4915
51
4916
52
4917
53
class MockGraphicBufferAllocator : public mtd::StubBufferAllocator
4918
54
{
4919
55
 public:
4920
56
    MockGraphicBufferAllocator()
4921
57
    {
4922
58
        using testing::_;
4923
59
        ON_CALL(*this, alloc_buffer(_))
4924
60
            .WillByDefault(testing::Invoke(this, &MockGraphicBufferAllocator::on_create_swapper));
4925
61
    }
4926
62
4927
63
    MOCK_METHOD1(
4928
64
        alloc_buffer,
4929
65
        std::shared_ptr<mg::Buffer> (mg::BufferProperties const&));
4930
66
4931
67
4932
68
    std::shared_ptr<mg::Buffer> on_create_swapper(mg::BufferProperties const&)
4933
69
    {
4934
70
        return std::make_shared<mtd::StubBuffer>(::buffer_properties);
4935
71
    }
4936
72
4937
73
    ~MockGraphicBufferAllocator() noexcept {}
4938
74
};
4939
75
4940
76
class StubDisplay : public mtd::NullDisplay
49
class StubDisplay : public mtd::NullDisplay
4941
77
{
50
{
4942
78
public:
51
public:
4943
@@ -96,11 +69,13 @@
4944
96
    {
69
    {
4945
97
    public:
70
    public:
4946
98
71
4948
99
        CountingStubBuffer()
72
        CountingStubBuffer(mg::BufferProperties const& props)
4949
73
            : StubBuffer(props)
4950
100
        {
74
        {
4951
101
            std::lock_guard<std::mutex> lock{buffers_mutex};
75
            std::lock_guard<std::mutex> lock{buffers_mutex};
4952
102
            ++buffers_created;
76
            ++buffers_created;
4953
103
            buffers_cv.notify_one();
77
            buffers_cv.notify_one();
4954
78
            std::cout << "Created buffer with size " << size() << std::endl;
4955
104
        }
79
        }
4956
105
        ~CountingStubBuffer()
80
        ~CountingStubBuffer()
4957
106
        {
81
        {
4958
@@ -118,11 +93,61 @@
4959
118
    class StubGraphicBufferAllocator : public mtd::StubBufferAllocator
93
    class StubGraphicBufferAllocator : public mtd::StubBufferAllocator
4960
119
    {
94
    {
4961
120
     public:
95
     public:
4967
121
        std::shared_ptr<mg::Buffer> alloc_buffer(mg::BufferProperties const&) override
96
        std::shared_ptr<mg::Buffer> alloc_buffer(mg::BufferProperties const& props) override
4968
122
        {
97
        {
4969
123
            return std::make_shared<CountingStubBuffer>();
98
            return std::make_shared<CountingStubBuffer>(props);
4970
124
        }
99
        }
4971
125
    };
100
    };
4972
101
<<<<<<< TREE
4973
102
=======
4974
103
4975
104
    class StubPlatform : public mtd::NullPlatform
4976
105
    {
4977
106
    public:
4978
107
        mir::UniqueModulePtr<mg::GraphicBufferAllocator> create_buffer_allocator() override
4979
108
        {
4980
109
            return mir::make_module_ptr<StubGraphicBufferAllocator>();
4981
110
        }
4982
111
4983
112
        mir::UniqueModulePtr<mg::Display> create_display(
4984
113
            std::shared_ptr<mg::DisplayConfigurationPolicy> const&,
4985
114
            std::shared_ptr<mg::GLConfig> const&) override
4986
115
        {
4987
116
            return mir::make_module_ptr<StubDisplay>();
4988
117
        }
4989
118
4990
119
        mir::UniqueModulePtr<mg::PlatformIpcOperations> make_ipc_operations() const override
4991
120
        {
4992
121
            class BufferPackingIPCOperations : public mtd::NullPlatformIpcOperations
4993
122
            {
4994
123
            public:
4995
124
                void pack_buffer(
4996
125
                    mg::BufferIpcMessage& message,
4997
126
                    mg::Buffer const& buffer,
4998
127
                    mg::BufferIpcMsgType msg_type) const override
4999
128
                {
5000
129
                    if (msg_type == mg::BufferIpcMsgType::full_msg)
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Needs Fixing on 2015-04-15
Alexandros Frantzis (community)			Needs Fixing on 2015-04-14
Andreas Pokorny (community)			Approve on 2015-03-10
Robert Carr (community)			Approve on 2015-02-17
Kevin DuBois (community)		2015-01-28	Approve on 2015-01-29
Review via email: mp+247794@code.launchpad.net