1
=== modified file 'examples/CMakeLists.txt'
2
--- examples/CMakeLists.txt	2017-06-05 11:06:24 +0000
3
+++ examples/CMakeLists.txt	2017-06-06 16:26:39 +0000
4
@@ -312,3 +312,7 @@
5
312
target_link_libraries(mir_demo_client_chain_jumping_buffers
312
target_link_libraries(mir_demo_client_chain_jumping_buffers
6
313
  mirclient
313
  mirclient
7
314
)
314
)
8
315
9
316
mir_add_wrapped_executable(mir_demo_client_screencast screencast.cpp)
10
317
11
318
target_link_libraries(mir_demo_client_screencast mirclient)
12
315
319
13
=== added file 'examples/screencast.cpp'
14
--- examples/screencast.cpp	1970-01-01 00:00:00 +0000
15
+++ examples/screencast.cpp	2017-06-06 16:26:39 +0000
16
@@ -0,0 +1,149 @@
17
1
/*
18
2
 * Copyright © 2017 Canonical Ltd.
19
3
 *
20
4
 * This program is free software: you can redistribute it and/or modify
21
5
 * it under the terms of the GNU General Public License version 3 as
22
6
 * published by the Free Software Foundation.
23
7
 *
24
8
 * This program is distributed in the hope that it will be useful,
25
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27
11
 * GNU General Public License for more details.
28
12
 *
29
13
 * You should have received a copy of the GNU General Public License
30
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
31
15
 *
32
16
 * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
33
17
 */
34
18
35
19
#include "mir_toolkit/mir_client_library.h"
36
20
#include "mir_toolkit/mir_screencast.h"
37
21
#include "mir_toolkit/mir_buffer.h"
38
22
#include <memory>
39
23
#include <iostream>
40
24
#include <unistd.h>
41
25
#include <getopt.h>
42
26
#include <fstream>
43
27
44
28
int main(int argc, char *argv[])
45
29
try
46
30
{
47
31
    int arg = -1;
48
32
    static char const* socket_file = NULL;
49
33
    static char const* output_file = "screencap_output.raw";
50
34
    unsigned int width = 400;
51
35
    unsigned int height = 300;
52
36
53
37
    auto disp_id = 0;
54
38
    while ((arg = getopt (argc, argv, "m:f:d:s:h:")) != -1)
55
39
    {
56
40
        switch (arg)
57
41
        {
58
42
        case 'm':
59
43
            socket_file = optarg;
60
44
            break;
61
45
        case 'f':
62
46
            output_file = optarg;
63
47
            break;
64
48
        case 'd':
65
49
            disp_id = atoi(optarg);
66
50
            break;
67
51
        case 's':
68
52
            if (sscanf(optarg, "%ux%u", &width, &height) != 2 || width == 0 || height == 0)
69
53
            {
70
54
                std::cerr << "could not parse size " << optarg << '\n';
71
55
                return -1;
72
56
            }
73
57
            break;
74
58
        case 'h':
75
59
        default:
76
60
            std::cout << argv[0] << std::endl;
77
61
            std::cout << "Usage:\n";
78
62
            std::cout << "    -m <Mir server socket>\n";
79
63
            std::cout << "    -f file to output to\n";
80
64
            std::cout << "    -d output id to capture\n";
81
65
            std::cout << "    -s size of capture buffer (WxH)\n";
82
66
            std::cout << "    -h help dialog\n";
83
67
            return -1;
84
68
        }
85
69
    }
86
70
87
71
    int rc = 0;
88
72
    auto connection = mir_connect_sync(socket_file, "screencap_to_buffer");
89
73
    if (!mir_connection_is_valid(connection))
90
74
    {
91
75
        std::cerr << "could not connect to server\n";
92
76
        return -1;
93
77
    }
94
78
95
79
    auto display_config = mir_connection_create_display_configuration(connection);
96
80
    if (disp_id < 0 || disp_id > mir_display_config_get_num_outputs(display_config))
97
81
    {
98
82
        std::cerr << "invalid display id set\n";
99
83
        return -1;
100
84
    }
101
85
102
86
    auto output = mir_display_config_get_output(display_config, disp_id);
103
87
    auto mode = mir_output_get_current_mode(output);
104
88
105
89
    auto pf = mir_pixel_format_abgr_8888;
106
90
    MirRectangle rect {
107
91
        mir_output_get_position_x(output),
108
92
        mir_output_get_position_y(output),
109
93
        static_cast<unsigned int>(mir_output_mode_get_width(mode)),
110
94
        static_cast<unsigned int>(mir_output_mode_get_height(mode)) };
111
95
    mir_display_config_release(display_config);
112
96
113
97
    auto spec = mir_create_screencast_spec(connection);
114
98
    mir_screencast_spec_set_capture_region(spec, &rect);
115
99
    mir_screencast_spec_set_mirror_mode(spec, mir_mirror_mode_horizontal);
116
100
    //TODO: the default screencast spec will capture a buffer when creating the screencast.
117
101
    //      Set to zero to avoid this, and when the old screencast-bufferstream method is removed,
118
102
    //      the initial capture will be removed. 
119
103
    mir_screencast_spec_set_number_of_buffers(spec, 0);
120
104
121
105
    auto screencast = mir_screencast_create_sync(spec);
122
106
    mir_screencast_spec_release(spec);
123
107
124
108
    auto buffer = mir_connection_allocate_buffer_sync(connection, width, height, pf);
125
109
126
110
    if (auto status = mir_screencast_capture_to_buffer_sync(screencast, buffer))
127
111
    {
128
112
        switch (status)
129
113
        {
130
114
            case mir_screencast_error_failure:
131
115
                std::cerr << "screencast failed" << std::endl;
132
116
                rc = -1;
133
117
                break;
134
118
            default:
135
119
                break;
136
120
        }
137
121
    }  
138
122
139
123
    std::ofstream file(output_file);
140
124
    if (!rc && output)
141
125
    {
142
126
        MirBufferLayout layout;
143
127
        MirGraphicsRegion region;
144
128
        mir_buffer_map(buffer, &region, &layout);
145
129
146
130
        auto addr = region.vaddr;
147
131
        for (int i = 0; i < region.height; i++)
148
132
        {
149
133
            file.write(addr, region.width * MIR_BYTES_PER_PIXEL(pf));
150
134
            addr += region.stride;
151
135
        }
152
136
153
137
        mir_buffer_unmap(buffer);
154
138
    }
155
139
156
140
    mir_buffer_release(buffer);
157
141
    mir_screencast_release_sync(screencast);
158
142
    mir_connection_release(connection);
159
143
    return EXIT_SUCCESS;
160
144
}
161
145
catch(std::exception& e)
162
146
{
163
147
    std::cerr << "error : " << e.what() << std::endl;
164
148
    return EXIT_FAILURE;
165
149
}
166
0
150
167
=== modified file 'include/client/mir_toolkit/mir_screencast.h'
168
--- include/client/mir_toolkit/mir_screencast.h	2017-05-25 08:58:03 +0000
169
+++ include/client/mir_toolkit/mir_screencast.h	2017-06-06 16:26:39 +0000
170
@@ -28,6 +28,22 @@
171
28
extern "C" {
28
extern "C" {
172
29
#endif
29
#endif
173
30
30
174
31
typedef enum MirScreencastResult
175
32
{
176
33
    /**
177
34
     * Screencasting to the MirBuffer succeeded.
178
35
     */
179
36
    mir_screencast_success,
180
37
181
38
    /**
182
39
     * Screencasting failed.
183
40
     */
184
41
    mir_screencast_error_failure,
185
42
} MirScreencastResult;
186
43
187
44
typedef void (*MirScreencastBufferCallback)(
188
45
    MirScreencastResult status, MirBuffer* buffer, void* context);
189
46
190
31
/**
47
/**
191
32
 * Create a screencast specification.
48
 * Create a screencast specification.
192
33
 *
49
 *
193
@@ -161,6 +177,29 @@
194
161
 */
177
 */
195
162
MirBufferStream* mir_screencast_get_buffer_stream(MirScreencast* screencast);
178
MirBufferStream* mir_screencast_get_buffer_stream(MirScreencast* screencast);
196
163
179
197
180
/** Capture the contents of the screen to a particular buffer.
198
181
 *
199
182
 *   \param [in] screencast         The screencast
200
183
 *   \param [in] buffer             The buffer
201
184
 *   \param [in] available_callback Callback triggered when buffer is available again
202
185
 *   \param [in] available_context  The context for the above callback
203
186
 **/
204
187
void mir_screencast_capture_to_buffer(
205
188
    MirScreencast* screencast,
206
189
    MirBuffer* buffer,
207
190
    MirScreencastBufferCallback available_callback, void* available_context);
208
191
209
192
/** Capture the contents of the screen to a particular buffer and wait for the
210
193
 *  capture to complete.
211
194
 *
212
195
 *   \warning   The returned MirError will be valid until the next call
213
196
 *              to mir_screencast_capture_to_buffer or mir_screencast_capture_to_buffer_sync.
214
197
 *   \param [in] screencast         The screencast
215
198
 *   \param [in] buffer             The buffer
216
199
 *   \return                        The error condition
217
200
 **/
218
201
MirScreencastResult mir_screencast_capture_to_buffer_sync(MirScreencast* screencast, MirBuffer* buffer);
219
202
220
164
#ifdef __cplusplus
203
#ifdef __cplusplus
221
165
}
204
}
222
166
/**@}*/
205
/**@}*/
223
167
206
224
=== renamed file 'tests/include/mir/test/doubles/mock_gl.h' => 'include/test/mir/test/doubles/mock_gl.h'
225
=== modified file 'include/test/mir/test/doubles/stub_session_authorizer.h'
226
--- include/test/mir/test/doubles/stub_session_authorizer.h	2017-05-08 03:04:26 +0000
227
+++ include/test/mir/test/doubles/stub_session_authorizer.h	2017-06-06 16:26:39 +0000
228
@@ -20,6 +20,7 @@
229
20
#define MIR_TEST_DOUBLES_STUB_SESSION_AUTHORIZER_H_
20
#define MIR_TEST_DOUBLES_STUB_SESSION_AUTHORIZER_H_
230
21
21
231
22
#include "mir/frontend/session_authorizer.h"
22
#include "mir/frontend/session_authorizer.h"
232
23
#include <gmock/gmock.h>
233
23
24
234
24
namespace mir
25
namespace mir
235
25
{
26
{
236
@@ -60,6 +61,11 @@
237
60
    }
61
    }
238
61
};
62
};
239
62
63
240
64
struct MockSessionAuthorizer : StubSessionAuthorizer
241
65
{
242
66
    MOCK_METHOD1(screencast_is_allowed, bool(frontend::SessionCredentials const&));
243
67
};
244
68
245
63
}
69
}
246
64
}
70
}
247
65
} // namespace mir
71
} // namespace mir
248
66
72
249
=== modified file 'src/client/mir_screencast.cpp'
250
--- src/client/mir_screencast.cpp	2017-05-08 03:04:26 +0000
251
+++ src/client/mir_screencast.cpp	2017-06-06 16:26:39 +0000
252
@@ -21,10 +21,12 @@
253
21
#include "mir_protobuf.pb.h"
21
#include "mir_protobuf.pb.h"
254
22
#include "make_protobuf_object.h"
22
#include "make_protobuf_object.h"
255
23
#include "mir/mir_buffer_stream.h"
23
#include "mir/mir_buffer_stream.h"
256
24
#include "mir/mir_buffer.h"
257
24
#include "mir/frontend/client_constants.h"
25
#include "mir/frontend/client_constants.h"
258
25
#include "mir_toolkit/mir_native_buffer.h"
26
#include "mir_toolkit/mir_native_buffer.h"
259
26
27
260
27
#include <boost/throw_exception.hpp>
28
#include <boost/throw_exception.hpp>
261
29
#include <algorithm>
262
28
30
263
29
namespace mcl = mir::client;
31
namespace mcl = mir::client;
264
30
namespace mp = mir::protobuf;
32
namespace mp = mir::protobuf;
265
@@ -55,6 +57,16 @@
266
55
        message.mutable_region()->set_height(region.height);
57
        message.mutable_region()->set_height(region.height);
267
56
    }
58
    }
268
57
59
269
60
    if (spec.num_buffers.is_set() && spec.num_buffers.value() == 0)
270
61
    {
271
62
        if (!spec.pixel_format.is_set())
272
63
            message.set_pixel_format(mir_pixel_format_abgr_8888);
273
64
        if (!spec.width.is_set())
274
65
            message.set_width(1);
275
66
        if (!spec.width.is_set())
276
67
            message.set_height(1);
277
68
    }
278
69
        
279
58
    return message;
70
    return message;
280
59
}
71
}
281
60
72
282
@@ -72,9 +84,6 @@
283
72
84
284
73
#define THROW_IF_ZERO(option) THROW_IF_EQ(option, 0)
85
#define THROW_IF_ZERO(option) THROW_IF_EQ(option, 0)
285
74
86
286
75
    THROW_IF_ZERO(width);
287
76
    THROW_IF_ZERO(height);
288
77
    THROW_IF_EQ(pixel_format, mir_pixel_format_invalid);
289
78
    THROW_IF_UNSET(capture_region);
87
    THROW_IF_UNSET(capture_region);
290
79
88
291
80
    if (spec.capture_region.is_set())
89
    if (spec.capture_region.is_set())
292
@@ -85,6 +94,14 @@
293
85
        if (region.height == 0)
94
        if (region.height == 0)
294
86
            BOOST_THROW_EXCEPTION(std::runtime_error("Invalid capture region height"));
95
            BOOST_THROW_EXCEPTION(std::runtime_error("Invalid capture region height"));
295
87
    }
96
    }
296
97
297
98
    //zero nbuffers don't need to set pixel format, width, or height
298
99
    if (!spec.num_buffers.is_set() || spec.num_buffers.value() > 0)
299
100
    {
300
101
        THROW_IF_ZERO(width);
301
102
        THROW_IF_ZERO(height);
302
103
        THROW_IF_EQ(pixel_format, mir_pixel_format_invalid);
303
104
    }
304
88
}
105
}
305
89
}
106
}
306
90
107
307
@@ -180,13 +197,13 @@
308
180
void MirScreencast::screencast_created(
197
void MirScreencast::screencast_created(
309
181
    MirScreencastCallback callback, void* context)
198
    MirScreencastCallback callback, void* context)
310
182
{
199
{
312
183
    if (!protobuf_screencast->has_error() && connection)
200
    if (connection && !protobuf_screencast->has_error() &&
313
201
        protobuf_screencast->has_buffer_stream() && protobuf_screencast->buffer_stream().has_buffer())
314
184
    {
202
    {
315
185
        std::lock_guard<decltype(mutex)> lock(mutex);
203
        std::lock_guard<decltype(mutex)> lock(mutex);
316
186
        try
204
        try
317
187
        {
205
        {
320
188
            buffer_stream = connection->make_consumer_stream(
206
            buffer_stream = connection->make_consumer_stream(protobuf_screencast->buffer_stream());
319
189
                protobuf_screencast->buffer_stream());
321
190
        }
207
        }
322
191
        catch (...)
208
        catch (...)
323
192
        {
209
        {
324
@@ -207,7 +224,7 @@
325
207
224
326
208
    {
225
    {
327
209
        std::lock_guard<decltype(mutex)> lock(mutex);
226
        std::lock_guard<decltype(mutex)> lock(mutex);
329
210
        if (connection)
227
        if (buffer_stream)
330
211
            connection->release_consumer_stream(buffer_stream.get());
228
            connection->release_consumer_stream(buffer_stream.get());
331
212
        buffer_stream.reset();
229
        buffer_stream.reset();
332
213
    }
230
    }
333
@@ -219,3 +236,38 @@
334
219
    std::lock_guard<decltype(mutex)> lock(mutex);
236
    std::lock_guard<decltype(mutex)> lock(mutex);
335
220
    return buffer_stream.get();
237
    return buffer_stream.get();
336
221
}
238
}
337
239
338
240
void MirScreencast::screencast_done(ScreencastRequest* request)
339
241
{
340
242
    auto const status = request->response.has_error() ? mir_screencast_error_failure : mir_screencast_success;
341
243
342
244
    request->available_callback(status, reinterpret_cast<MirBuffer*>(request->buffer), request->available_context);
343
245
344
246
    std::unique_lock<decltype(mutex)> lk(mutex);
345
247
    auto it = std::find_if(requests.begin(), requests.end(),
346
248
        [&request] (auto const& it) { return it.get() == request; } );
347
249
    if (it != requests.end())
348
250
        requests.erase(it);
349
251
}
350
252
351
253
void MirScreencast::screencast_to_buffer(
352
254
    mcl::MirBuffer* buffer,
353
255
    MirScreencastBufferCallback cb,
354
256
    void* context)
355
257
{
356
258
    if (!server) //construction with nullptr should be invalid
357
259
        BOOST_THROW_EXCEPTION(std::runtime_error("invalid screencast"));
358
260
    
359
261
    std::unique_lock<decltype(mutex)> lk(mutex);
360
262
361
263
    requests.emplace_back(std::make_unique<ScreencastRequest>(buffer, cb, context));
362
264
363
265
    mir::protobuf::ScreencastRequest request;
364
266
    request.set_buffer_id(buffer->rpc_id());
365
267
    request.mutable_id()->set_value(protobuf_screencast->screencast_id().value());
366
268
367
269
    server->screencast_to_buffer(
368
270
        &request,
369
271
        &(requests.back()->response),
370
272
        google::protobuf::NewCallback(this, &MirScreencast::screencast_done, requests.back().get()));
371
273
}
372
222
274
373
=== modified file 'src/client/mir_screencast.h'
374
--- src/client/mir_screencast.h	2017-05-08 03:04:26 +0000
375
+++ src/client/mir_screencast.h	2017-06-06 16:26:39 +0000
376
@@ -20,10 +20,11 @@
377
20
#define MIR_CLIENT_MIR_SCREENCAST_H_
20
#define MIR_CLIENT_MIR_SCREENCAST_H_
378
21
21
379
22
#include "mir_wait_handle.h"
22
#include "mir_wait_handle.h"
381
23
#include "mir_toolkit/client_types.h"
23
#include "mir_toolkit/mir_screencast.h"
382
24
#include "mir/optional_value.h"
24
#include "mir/optional_value.h"
383
25
#include "mir/geometry/size.h"
25
#include "mir/geometry/size.h"
384
26
#include "mir/geometry/rectangle.h"
26
#include "mir/geometry/rectangle.h"
385
27
#include "mir_protobuf.pb.h"
386
27
28
387
28
#include <EGL/eglplatform.h>
29
#include <EGL/eglplatform.h>
388
29
30
389
@@ -38,6 +39,7 @@
390
38
}
39
}
391
39
namespace client
40
namespace client
392
40
{
41
{
393
42
class MirBuffer;
394
41
namespace rpc
43
namespace rpc
395
42
{
44
{
396
43
class DisplayServer;
45
class DisplayServer;
397
@@ -85,6 +87,11 @@
398
85
87
399
86
    MirBufferStream* get_buffer_stream();
88
    MirBufferStream* get_buffer_stream();
400
87
89
401
90
    void screencast_to_buffer(
402
91
        mir::client::MirBuffer* buffer,
403
92
        MirScreencastBufferCallback available_callback,
404
93
        void* available_context);
405
94
406
88
private:
95
private:
407
89
    void screencast_created(
96
    void screencast_created(
408
90
        MirScreencastCallback callback, void* context);
97
        MirScreencastCallback callback, void* context);
409
@@ -103,6 +110,23 @@
410
103
    MirWaitHandle release_wait_handle;
110
    MirWaitHandle release_wait_handle;
411
104
111
412
105
    std::string const empty_error_message;
112
    std::string const empty_error_message;
413
113
414
114
    struct ScreencastRequest
415
115
    {
416
116
        ScreencastRequest(mir::client::MirBuffer* b, MirScreencastBufferCallback cb, void* context) :
417
117
            buffer(b),
418
118
            available_callback(cb),
419
119
            available_context(context)
420
120
        {
421
121
        }
422
122
 
423
123
        mir::client::MirBuffer* buffer;
424
124
        MirScreencastBufferCallback available_callback;
425
125
        void* available_context;
426
126
        mir::protobuf::Void response;
427
127
    };
428
128
    std::vector<std::unique_ptr<ScreencastRequest>> requests;
429
129
    void screencast_done(ScreencastRequest* request);
430
106
};
130
};
431
107
131
432
108
#endif /* MIR_CLIENT_MIR_SCREENCAST_H_ */
132
#endif /* MIR_CLIENT_MIR_SCREENCAST_H_ */
433
109
133
434
=== modified file 'src/client/mir_screencast_api.cpp'
435
--- src/client/mir_screencast_api.cpp	2017-05-08 03:04:26 +0000
436
+++ src/client/mir_screencast_api.cpp	2017-06-06 16:26:39 +0000
437
@@ -19,11 +19,13 @@
438
19
#define MIR_LOG_COMPONENT "MirScreencastAPI"
19
#define MIR_LOG_COMPONENT "MirScreencastAPI"
439
20
20
440
21
#include "mir_toolkit/mir_screencast.h"
21
#include "mir_toolkit/mir_screencast.h"
441
22
#include "mir_toolkit/mir_buffer.h"
442
22
#include "mir_screencast.h"
23
#include "mir_screencast.h"
443
23
#include "mir_connection.h"
24
#include "mir_connection.h"
444
24
#include "mir/raii.h"
25
#include "mir/raii.h"
445
25
#include "mir/require.h"
26
#include "mir/require.h"
446
26
#include "mir/uncaught.h"
27
#include "mir/uncaught.h"
447
28
#include "no_tls_future-inl.h"
448
27
29
449
28
#include <stdexcept>
30
#include <stdexcept>
450
29
#include <boost/throw_exception.hpp>
31
#include <boost/throw_exception.hpp>
451
@@ -131,3 +133,38 @@
452
131
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
133
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
453
132
    return nullptr;
134
    return nullptr;
454
133
}
135
}
455
136
456
137
void mir_screencast_capture_to_buffer(
457
138
    MirScreencast* screencast,
458
139
    MirBuffer* b,
459
140
    MirScreencastBufferCallback available_callback, void* available_context)
460
141
try
461
142
{
462
143
    mir::require(b);
463
144
    mir::require(screencast);
464
145
465
146
    auto buffer = reinterpret_cast<mir::client::MirBuffer*>(b);
466
147
    screencast->screencast_to_buffer(buffer, available_callback, available_context);
467
148
}
468
149
catch (std::exception const& ex)
469
150
{
470
151
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
471
152
    available_callback(mir_screencast_error_failure, nullptr, available_context);
472
153
}
473
154
474
155
MirScreencastResult mir_screencast_capture_to_buffer_sync(MirScreencast* screencast, MirBuffer* buffer)
475
156
try
476
157
{
477
158
    mir::client::NoTLSPromise<MirScreencastResult> promise;
478
159
    mir_screencast_capture_to_buffer(screencast, buffer,
479
160
        [](MirScreencastResult status, MirBuffer* /*buffer*/, void* context)
480
161
        {
481
162
            reinterpret_cast<mir::client::NoTLSPromise<MirScreencastResult>*>(context)->set_value(status);
482
163
        }, &promise);
483
164
    return promise.get_future().get();
484
165
}
485
166
catch (std::exception const& ex)
486
167
{
487
168
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
488
169
    return mir_screencast_error_failure;
489
170
}
490
134
171
491
=== modified file 'src/client/symbols.map'
492
--- src/client/symbols.map	2017-05-25 08:58:03 +0000
493
+++ src/client/symbols.map	2017-06-06 16:26:39 +0000
494
@@ -584,6 +584,8 @@
495
584
    mir_buffer_stream_get_microseconds_till_vblank;
584
    mir_buffer_stream_get_microseconds_till_vblank;
496
585
    mir_connection_apply_session_input_config;
585
    mir_connection_apply_session_input_config;
497
586
    mir_connection_set_base_input_config;
586
    mir_connection_set_base_input_config;
498
587
    mir_screencast_capture_to_buffer;
499
588
    mir_screencast_capture_to_buffer_sync;
500
587
    mir_create_freestyle_window_spec;
589
    mir_create_freestyle_window_spec;
501
588
    mir_create_gloss_window_spec;
590
    mir_create_gloss_window_spec;
502
589
    mir_create_satellite_window_spec;
591
    mir_create_satellite_window_spec;
503
590
592
504
=== modified file 'src/server/compositor/compositing_screencast.cpp'
505
--- src/server/compositor/compositing_screencast.cpp	2017-05-08 03:04:26 +0000
506
+++ src/server/compositor/compositing_screencast.cpp	2017-06-06 16:26:39 +0000
507
@@ -26,6 +26,7 @@
508
26
#include "mir/graphics/display_buffer.h"
26
#include "mir/graphics/display_buffer.h"
509
27
#include "mir/graphics/graphic_buffer_allocator.h"
27
#include "mir/graphics/graphic_buffer_allocator.h"
510
28
#include "mir/compositor/display_buffer_compositor_factory.h"
28
#include "mir/compositor/display_buffer_compositor_factory.h"
511
29
#include "mir/graphics/transformation.h"
512
29
#include "mir/compositor/display_buffer_compositor.h"
30
#include "mir/compositor/display_buffer_compositor.h"
513
30
#include "mir/geometry/rectangles.h"
31
#include "mir/geometry/rectangles.h"
514
31
#include "mir/raii.h"
32
#include "mir/raii.h"
515
@@ -71,21 +72,20 @@
516
71
    ScreencastSessionContext(
72
    ScreencastSessionContext(
517
72
        std::shared_ptr<Scene> const& scene,
73
        std::shared_ptr<Scene> const& scene,
518
73
        mg::Display& display,
74
        mg::Display& display,
519
74
        mg::GraphicBufferAllocator& buffer_allocator,
520
75
        DisplayBufferCompositorFactory& db_compositor_factory,
75
        DisplayBufferCompositorFactory& db_compositor_factory,
521
76
        std::vector<std::shared_ptr<mg::Buffer>> const& buffers,
522
76
        geom::Rectangle const& capture_region,
77
        geom::Rectangle const& capture_region,
523
77
        geom::Size const& capture_size,
78
        geom::Size const& capture_size,
524
78
        MirPixelFormat pixel_format,
525
79
        int nbuffers,
526
80
        MirMirrorMode mirror_mode)
79
        MirMirrorMode mirror_mode)
527
81
    : scene{scene},
80
    : scene{scene},
528
82
      display_buffer{std::make_unique<ScreencastDisplayBuffer>(capture_region, capture_size, mirror_mode, free_queue, ready_queue, display)},
81
      display_buffer{std::make_unique<ScreencastDisplayBuffer>(capture_region, capture_size, mirror_mode, free_queue, ready_queue, display)},
529
83
      display_buffer_compositor{db_compositor_factory.create_compositor_for(*display_buffer)},
82
      display_buffer_compositor{db_compositor_factory.create_compositor_for(*display_buffer)},
531
84
      virtual_output{make_virtual_output(display, capture_region)}
83
      virtual_output{make_virtual_output(display, capture_region)},
532
84
      queue_size(capture_size),
533
85
      mirror_mode(mirror_mode)
534
85
    {
86
    {
538
86
        mg::BufferProperties const buffer_properties{capture_size, pixel_format, mg::BufferUsage::hardware};
87
        for (auto buffer : buffers)
539
87
        for (int i = 0; i < nbuffers; i++)
88
            free_queue.schedule(buffer);
537
88
            free_queue.schedule(buffer_allocator.alloc_buffer(buffer_properties));
540
89
89
541
90
        scene->register_compositor(this);
90
        scene->register_compositor(this);
542
91
        if (virtual_output)
91
        if (virtual_output)
543
@@ -99,6 +99,9 @@
544
99
    std::shared_ptr<mg::Buffer> capture()
99
    std::shared_ptr<mg::Buffer> capture()
545
100
    {
100
    {
546
101
        std::lock_guard<decltype(mutex)> lk(mutex);
101
        std::lock_guard<decltype(mutex)> lk(mutex);
547
102
        if (queue_size != display_buffer->renderbuffer_size())
548
103
            display_buffer->set_renderbuffer_size(queue_size);
549
104
550
102
        //FIXME:: the client needs a better way to express it is no longer
105
        //FIXME:: the client needs a better way to express it is no longer
551
103
        //using the last captured buffer
106
        //using the last captured buffer
552
104
        if (last_captured_buffer)
107
        if (last_captured_buffer)
553
@@ -113,6 +116,23 @@
554
113
    void capture(std::shared_ptr<mg::Buffer> const& buffer)
116
    void capture(std::shared_ptr<mg::Buffer> const& buffer)
555
114
    {
117
    {
556
115
        std::lock_guard<decltype(mutex)> lk(mutex);
118
        std::lock_guard<decltype(mutex)> lk(mutex);
557
119
        if (buffer->size() != display_buffer->renderbuffer_size())
558
120
            display_buffer->set_renderbuffer_size(buffer->size());
559
121
       
560
122
        //a bit confusingly, the old way of screencasting had the mirror_mode_none
561
123
        //produce upside down buffers.
562
124
        if (mirror_mode == mir_mirror_mode_none)
563
125
            display_buffer->set_transformation(mg::transformation(mir_mirror_mode_vertical));
564
126
        if (mirror_mode == mir_mirror_mode_vertical)
565
127
            display_buffer->set_transformation(mg::transformation(mir_mirror_mode_none));
566
128
        if (mirror_mode == mir_mirror_mode_horizontal)
567
129
        {
568
130
            glm::mat2 mat;
569
131
            mat[0][0] = -1;
570
132
            mat[1][1] = -1;
571
133
            display_buffer->set_transformation(mat);
572
134
        }
573
135
 
574
116
        auto scheduled = free_queue.num_scheduled();
136
        auto scheduled = free_queue.num_scheduled();
575
117
        free_queue.schedule(buffer);
137
        free_queue.schedule(buffer);
576
118
        for(auto i = 0u; i < scheduled; i++)
138
        for(auto i = 0u; i < scheduled; i++)
577
@@ -121,6 +141,8 @@
578
121
        display_buffer_compositor->composite(scene->scene_elements_for(this));
141
        display_buffer_compositor->composite(scene->scene_elements_for(this));
579
122
        if (buffer != ready_queue.next_buffer())
142
        if (buffer != ready_queue.next_buffer())
580
123
            throw std::runtime_error("unable to capture to buffer");
143
            throw std::runtime_error("unable to capture to buffer");
581
144
582
145
        display_buffer->set_transformation(mg::transformation(mirror_mode));
583
124
    }
146
    }
584
125
147
585
126
private:
148
private:
586
@@ -133,6 +155,8 @@
587
133
    std::unique_ptr<compositor::DisplayBufferCompositor> display_buffer_compositor;
155
    std::unique_ptr<compositor::DisplayBufferCompositor> display_buffer_compositor;
588
134
    std::unique_ptr<graphics::VirtualOutput> virtual_output;
156
    std::unique_ptr<graphics::VirtualOutput> virtual_output;
589
135
    std::shared_ptr<mg::Buffer> last_captured_buffer;
157
    std::shared_ptr<mg::Buffer> last_captured_buffer;
590
158
    geom::Size queue_size;
591
159
    MirMirrorMode mirror_mode;
592
136
};
160
};
593
137
161
594
138
162
595
@@ -159,14 +183,20 @@
596
159
        size.height.as_int() == 0 ||
183
        size.height.as_int() == 0 ||
597
160
        region.size.width.as_int() == 0 ||
184
        region.size.width.as_int() == 0 ||
598
161
        region.size.height.as_int() == 0 ||
185
        region.size.height.as_int() == 0 ||
601
162
        pixel_format == mir_pixel_format_invalid ||
186
        ((nbuffers > 1) && (pixel_format == mir_pixel_format_invalid)))
600
163
        nbuffers < 0)
602
164
    {
187
    {
603
165
        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid parameters"));
188
        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid parameters"));
604
166
    }
189
    }
605
167
    std::lock_guard<decltype(session_mutex)> lock{session_mutex};
190
    std::lock_guard<decltype(session_mutex)> lock{session_mutex};
606
168
    auto const id = next_available_session_id();
191
    auto const id = next_available_session_id();
608
169
    session_contexts[id] = create_session_context(region, size, pixel_format, nbuffers, mirror_mode);
192
609
193
    std::vector<std::shared_ptr<mg::Buffer>> buffers(nbuffers);
610
194
    for (auto& buffer : buffers)
611
195
    {
612
196
        buffer = buffer_allocator->alloc_buffer(
613
197
            mg::BufferProperties{size, pixel_format, mg::BufferUsage::hardware});
614
198
    }
615
199
    session_contexts[id] = create_session_context(region, size, buffers, mirror_mode);
616
170
200
617
171
    return id;
201
    return id;
618
172
}
202
}
619
@@ -204,13 +234,11 @@
620
204
mc::CompositingScreencast::create_session_context(
234
mc::CompositingScreencast::create_session_context(
621
205
    geometry::Rectangle const& rect,
235
    geometry::Rectangle const& rect,
622
206
    geometry::Size const& size,
236
    geometry::Size const& size,
625
207
    MirPixelFormat pixel_format,
237
    std::vector<std::shared_ptr<mg::Buffer>> const& buffers,
624
208
    int nbuffers,
626
209
    MirMirrorMode mirror_mode)
238
    MirMirrorMode mirror_mode)
627
210
{
239
{
628
211
    return std::make_shared<detail::ScreencastSessionContext>(
240
    return std::make_shared<detail::ScreencastSessionContext>(
631
212
        scene, *display, *buffer_allocator, *db_compositor_factory,
241
        scene, *display, *db_compositor_factory, buffers, rect, size, mirror_mode);
630
213
        rect, size, pixel_format, nbuffers, mirror_mode);
632
214
}
242
}
633
215
243
634
216
void mc::CompositingScreencast::capture(
244
void mc::CompositingScreencast::capture(
635
217
245
636
=== modified file 'src/server/compositor/compositing_screencast.h'
637
--- src/server/compositor/compositing_screencast.h	2017-05-08 03:04:26 +0000
638
+++ src/server/compositor/compositing_screencast.h	2017-06-06 16:26:39 +0000
639
@@ -64,8 +64,7 @@
640
64
    std::shared_ptr<detail::ScreencastSessionContext>
64
    std::shared_ptr<detail::ScreencastSessionContext>
641
65
        create_session_context(geometry::Rectangle const& rect,
65
        create_session_context(geometry::Rectangle const& rect,
642
66
            geometry::Size const& size,
66
            geometry::Size const& size,
645
67
            MirPixelFormat pixel_format,
67
            std::vector<std::shared_ptr<graphics::Buffer>> const& buffers,
644
68
            int nbuffers,
646
69
            MirMirrorMode mirror_mode);
68
            MirMirrorMode mirror_mode);
647
70
   std::shared_ptr<detail::ScreencastSessionContext> session(frontend::ScreencastSessionId id);
69
   std::shared_ptr<detail::ScreencastSessionContext> session(frontend::ScreencastSessionId id);
648
71
70
649
72
71
650
=== modified file 'src/server/compositor/screencast_display_buffer.cpp'
651
--- src/server/compositor/screencast_display_buffer.cpp	2017-05-08 03:04:26 +0000
652
+++ src/server/compositor/screencast_display_buffer.cpp	2017-06-06 16:26:39 +0000
653
@@ -72,7 +72,8 @@
654
72
      rect(rect),
72
      rect(rect),
655
73
      transform(mg::transformation(mirror_mode)),
73
      transform(mg::transformation(mirror_mode)),
656
74
      free_queue(free_queue), ready_queue(ready_queue),
74
      free_queue(free_queue), ready_queue(ready_queue),
658
75
      old_fbo(), old_viewport()
75
      old_fbo(), old_viewport(),
659
76
      current_size(size)
660
76
{
77
{
661
77
    auto const gl_context_raii = mir::raii::paired_calls(
78
    auto const gl_context_raii = mir::raii::paired_calls(
662
78
        [this] { gl_context->make_current(); },
79
        [this] { gl_context->make_current(); },
663
@@ -182,3 +183,31 @@
664
182
{
183
{
665
183
    return this;
184
    return this;
666
184
}
185
}
667
186
668
187
geom::Size mc::ScreencastDisplayBuffer::renderbuffer_size()
669
188
{
670
189
    return current_size;
671
190
}
672
191
673
192
void mc::ScreencastDisplayBuffer::set_renderbuffer_size(geom::Size size)
674
193
{
675
194
    if (size == current_size)
676
195
        return;
677
196
678
197
    auto depth_buffer = allocate_gl_resource<glGenRenderbuffers, glDeleteRenderbuffers>();
679
198
    glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
680
199
    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
681
200
                          size.width.as_uint32_t(),
682
201
                          size.height.as_uint32_t());
683
202
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
684
203
                              GL_RENDERBUFFER, depth_buffer);
685
204
686
205
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
687
206
        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to create FBO for buffer"));
688
207
    depth_rbo =  std::move(depth_buffer);
689
208
}
690
209
691
210
void mc::ScreencastDisplayBuffer::set_transformation(glm::mat2 const& t)
692
211
{
693
212
    transform = t;
694
213
}
695
185
214
696
=== modified file 'src/server/compositor/screencast_display_buffer.h'
697
--- src/server/compositor/screencast_display_buffer.h	2017-05-08 03:04:26 +0000
698
+++ src/server/compositor/screencast_display_buffer.h	2017-06-06 16:26:39 +0000
699
@@ -116,6 +116,10 @@
700
116
116
701
117
    NativeDisplayBuffer* native_display_buffer() override;
117
    NativeDisplayBuffer* native_display_buffer() override;
702
118
118
703
119
    geometry::Size renderbuffer_size();
704
120
    void set_renderbuffer_size(geometry::Size);
705
121
    void set_transformation(glm::mat2 const& transform);
706
122
707
119
private:
123
private:
708
120
    std::unique_ptr<renderer::gl::Context> gl_context;
124
    std::unique_ptr<renderer::gl::Context> gl_context;
709
121
    geometry::Rectangle const rect;
125
    geometry::Rectangle const rect;
710
@@ -131,6 +135,8 @@
711
131
    detail::GLResource<glDeleteTextures> color_tex;
135
    detail::GLResource<glDeleteTextures> color_tex;
712
132
    detail::GLResource<glDeleteRenderbuffers> depth_rbo;
136
    detail::GLResource<glDeleteRenderbuffers> depth_rbo;
713
133
    detail::GLResource<glDeleteFramebuffers> fbo;
137
    detail::GLResource<glDeleteFramebuffers> fbo;
714
138
715
139
    geometry::Size current_size;
716
134
};
140
};
717
135
141
718
136
}
142
}
719
137
143
720
=== modified file 'src/server/frontend/protobuf_message_processor.cpp'
721
--- src/server/frontend/protobuf_message_processor.cpp	2017-05-08 03:04:26 +0000
722
+++ src/server/frontend/protobuf_message_processor.cpp	2017-06-06 16:26:39 +0000
723
@@ -425,7 +425,7 @@
724
425
void mfd::ProtobufMessageProcessor::send_response(
425
void mfd::ProtobufMessageProcessor::send_response(
725
426
    ::google::protobuf::uint32 id, mir::protobuf::Screencast* response)
426
    ::google::protobuf::uint32 id, mir::protobuf::Screencast* response)
726
427
{
427
{
728
428
    if (response->has_buffer_stream())
428
    if (response->has_buffer_stream() && response->buffer_stream().has_buffer())
729
429
        sender->send_response(id, response,
429
        sender->send_response(id, response,
730
430
            {extract_fds_from(response->mutable_buffer_stream()->mutable_buffer())});
430
            {extract_fds_from(response->mutable_buffer_stream()->mutable_buffer())});
731
431
    else
431
    else
732
432
432
733
=== modified file 'src/server/frontend/session_mediator.cpp'
734
--- src/server/frontend/session_mediator.cpp	2017-05-25 08:58:03 +0000
735
+++ src/server/frontend/session_mediator.cpp	2017-06-06 16:26:39 +0000
736
@@ -826,6 +826,7 @@
737
826
    protobuf_screencast->mutable_buffer_stream()->set_pixel_format(pixel_format);
826
    protobuf_screencast->mutable_buffer_stream()->set_pixel_format(pixel_format);
738
827
    protobuf_screencast->mutable_buffer_stream()->mutable_id()->set_value(
827
    protobuf_screencast->mutable_buffer_stream()->mutable_id()->set_value(
739
828
        screencast_session_id.as_value());
828
        screencast_session_id.as_value());
740
829
    protobuf_screencast->mutable_buffer_stream()->set_pixel_format(pixel_format);
741
829
830
742
830
    done->Run();
831
    done->Run();
743
831
}
832
}
744
@@ -869,7 +870,6 @@
745
869
    auto session = weak_session.lock();
870
    auto session = weak_session.lock();
746
870
    ScreencastSessionId const screencast_session_id{request->id().value()};
871
    ScreencastSessionId const screencast_session_id{request->id().value()};
747
871
    auto buffer = session->get_buffer(mg::BufferID{request->buffer_id()});
872
    auto buffer = session->get_buffer(mg::BufferID{request->buffer_id()});
748
872
    mf::ScreencastSessionId const screencast_id{request->id().value()};
749
873
    screencast->capture(screencast_session_id, buffer);
873
    screencast->capture(screencast_session_id, buffer);
750
874
    done->Run();
874
    done->Run();
751
875
}
875
}
752
876
876
753
=== modified file 'tests/acceptance-tests/test_client_screencast.cpp'
754
--- tests/acceptance-tests/test_client_screencast.cpp	2017-05-08 03:04:26 +0000
755
+++ tests/acceptance-tests/test_client_screencast.cpp	2017-06-06 16:26:39 +0000
756
@@ -24,6 +24,7 @@
757
24
#include "mir_test_framework/connected_client_headless_server.h"
24
#include "mir_test_framework/connected_client_headless_server.h"
758
25
#include "mir/test/doubles/stub_session_authorizer.h"
25
#include "mir/test/doubles/stub_session_authorizer.h"
759
26
#include "mir/test/fake_shared.h"
26
#include "mir/test/fake_shared.h"
760
27
#include "mir/test/doubles/mock_gl.h"
761
27
28
762
28
#include <gtest/gtest.h>
29
#include <gtest/gtest.h>
763
29
#include <gmock/gmock.h>
30
#include <gmock/gmock.h>
764
@@ -32,6 +33,8 @@
765
32
namespace mtd = mir::test::doubles;
33
namespace mtd = mir::test::doubles;
766
33
namespace mf = mir::frontend;
34
namespace mf = mir::frontend;
767
34
namespace mt = mir::test;
35
namespace mt = mir::test;
768
36
using namespace testing;
769
37
using namespace std::literals::chrono_literals;
770
35
38
771
36
namespace
39
namespace
772
37
{
40
{
773
@@ -48,6 +51,7 @@
774
48
struct Screencast : mtf::HeadlessInProcessServer
51
struct Screencast : mtf::HeadlessInProcessServer
775
49
{
52
{
776
50
    MockSessionAuthorizer mock_authorizer;
53
    MockSessionAuthorizer mock_authorizer;
777
54
    NiceMock<mtd::MockGL> mockgl;
778
51
55
779
52
    void SetUp() override
56
    void SetUp() override
780
53
    {
57
    {
781
@@ -126,3 +130,84 @@
782
126
    mir_screencast_release_sync(screencast);
130
    mir_screencast_release_sync(screencast);
783
127
    mir_connection_release(connection);
131
    mir_connection_release(connection);
784
128
}
132
}
785
133
786
134
TEST_F(Screencast, can_cast_to_buffer)
787
135
{
788
136
    EXPECT_CALL(mock_authorizer, screencast_is_allowed(_))
789
137
        .WillOnce(Return(true));
790
138
    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
791
139
792
140
    auto const buffer = mir_connection_allocate_buffer_sync(
793
141
        connection, default_width, default_height, default_pixel_format);
794
142
795
143
    ASSERT_TRUE(buffer);
796
144
797
145
    MirScreencastSpec* spec = mir_create_screencast_spec(connection);
798
146
    //We have to set nbuffers == 0 now to avoid capturing at startup. Current default is 1.
799
147
    mir_screencast_spec_set_number_of_buffers(spec, 0);
800
148
801
149
    mir_screencast_spec_set_capture_region(spec, &default_capture_region);
802
150
    auto screencast = mir_screencast_create_sync(spec);
803
151
    mir_screencast_spec_release(spec);
804
152
805
153
    struct Capture
806
154
    {
807
155
        std::mutex mutex;
808
156
        std::condition_variable cv;
809
157
        bool capture = false;
810
158
    } capture;
811
159
812
160
    mir_screencast_capture_to_buffer(screencast, buffer,
813
161
        [] (MirScreencastResult /*status*/, MirBuffer* /*buffer*/, void* context) {
814
162
            auto c = reinterpret_cast<Capture*>(context);
815
163
            std::unique_lock<decltype(c->mutex)> lk(c->mutex);
816
164
            c->capture = true;
817
165
            c->cv.notify_all();
818
166
        }, &capture );
819
167
820
168
    std::unique_lock<decltype(capture.mutex)> lk2(capture.mutex);
821
169
    ASSERT_TRUE(capture.cv.wait_for(lk2, 5s, [&] { return capture.capture; }));
822
170
    EXPECT_THAT(mir_buffer_get_error_message(buffer), StrEq(""));
823
171
824
172
    mir_screencast_release_sync(screencast);
825
173
    mir_connection_release(connection);
826
174
}
827
175
828
176
TEST_F(Screencast, can_cast_to_buffer_sync)
829
177
{
830
178
    EXPECT_CALL(mock_authorizer, screencast_is_allowed(_))
831
179
        .WillOnce(Return(true));
832
180
    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
833
181
834
182
    struct BufferSync
835
183
    {
836
184
        MirBuffer* buffer = nullptr;
837
185
        std::mutex mutex;
838
186
        std::condition_variable cv;
839
187
    } buffer_info;
840
188
841
189
    mir_connection_allocate_buffer(
842
190
        connection,
843
191
        default_width, default_height, default_pixel_format,
844
192
        [](MirBuffer* b, void* ctxt) {
845
193
            auto info = reinterpret_cast<BufferSync*>(ctxt);
846
194
            std::unique_lock<decltype(info->mutex)> lk(info->mutex);
847
195
            info->buffer = b;
848
196
            info->cv.notify_all(); 
849
197
        }, &buffer_info);
850
198
    std::unique_lock<decltype(buffer_info.mutex)> lk(buffer_info.mutex);
851
199
    ASSERT_TRUE(buffer_info.cv.wait_for(lk, 5s, [&] { return buffer_info.buffer; }));
852
200
853
201
    MirScreencastSpec* spec = mir_create_screencast_spec(connection);
854
202
    //We have to set nbuffers == 0 now to avoid capturing at startup. Current default is 1.
855
203
    mir_screencast_spec_set_number_of_buffers(spec, 0);
856
204
857
205
    mir_screencast_spec_set_capture_region(spec, &default_capture_region);
858
206
    auto screencast = mir_screencast_create_sync(spec);
859
207
860
208
    mir_screencast_spec_release(spec);
861
209
    mir_screencast_capture_to_buffer_sync(screencast, buffer_info.buffer);
862
210
863
211
    mir_screencast_release_sync(screencast);
864
212
    mir_connection_release(connection);
865
213
}
866
129
214
867
=== modified file 'tests/unit-tests/compositor/test_compositing_screencast.cpp'
868
--- tests/unit-tests/compositor/test_compositing_screencast.cpp	2017-05-08 03:04:26 +0000
869
+++ tests/unit-tests/compositor/test_compositing_screencast.cpp	2017-06-06 16:26:39 +0000
870
@@ -251,7 +251,6 @@
871
251
    EXPECT_THROW(screencast.create_session(invalid_region, default_size, default_pixel_format, default_num_buffers, default_mirror_mode), std::runtime_error);
251
    EXPECT_THROW(screencast.create_session(invalid_region, default_size, default_pixel_format, default_num_buffers, default_mirror_mode), std::runtime_error);
872
252
    EXPECT_THROW(screencast.create_session(default_region, invalid_size, default_pixel_format, default_num_buffers, default_mirror_mode), std::runtime_error);
252
    EXPECT_THROW(screencast.create_session(default_region, invalid_size, default_pixel_format, default_num_buffers, default_mirror_mode), std::runtime_error);
873
253
    EXPECT_THROW(screencast.create_session(default_region, default_size, mir_pixel_format_invalid, default_num_buffers, default_mirror_mode), std::runtime_error);
253
    EXPECT_THROW(screencast.create_session(default_region, default_size, mir_pixel_format_invalid, default_num_buffers, default_mirror_mode), std::runtime_error);
874
254
    EXPECT_THROW(screencast.create_session(default_region, default_size, mir_pixel_format_invalid, 0, default_mirror_mode), std::runtime_error);
875
255
}
254
}
876
256
255
877
257
TEST_F(CompositingScreencastTest, throws_on_capture_with_invalid_session_id)
256
TEST_F(CompositingScreencastTest, throws_on_capture_with_invalid_session_id)
Status:	Merged
Approved by:	Alberto Aguirre on 2017-06-06
Approved revision:	no longer in the source branch.
Merged at revision:	4189
Proposed branch:	lp:~alan-griffiths/mir/screenshot-to-buffer
Merge into:	lp:mir
Diff against target:	877 lines (+487/-28) 16 files modified examples/CMakeLists.txt (+4/-0) examples/screencast.cpp (+149/-0) include/client/mir_toolkit/mir_screencast.h (+39/-0) include/test/mir/test/doubles/stub_session_authorizer.h (+6/-0) src/client/mir_screencast.cpp (+59/-7) src/client/mir_screencast.h (+25/-1) src/client/mir_screencast_api.cpp (+37/-0) src/client/symbols.map (+2/-0) src/server/compositor/compositing_screencast.cpp (+42/-14) src/server/compositor/compositing_screencast.h (+1/-2) src/server/compositor/screencast_display_buffer.cpp (+30/-1) src/server/compositor/screencast_display_buffer.h (+6/-0) src/server/frontend/protobuf_message_processor.cpp (+1/-1) src/server/frontend/session_mediator.cpp (+1/-1) tests/acceptance-tests/test_client_screencast.cpp (+85/-0) tests/unit-tests/compositor/test_compositing_screencast.cpp (+0/-1)
To merge this branch:	bzr merge lp:~alan-griffiths/mir/screenshot-to-buffer
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration	2017-06-01	Approve on 2017-06-06
Alberto Aguirre (community)		2017-06-01	Approve on 2017-06-06
Daniel van Vugt		2017-06-01	Pending
Mir development team		2017-06-01	Pending
Review via email: mp+324943@code.launchpad.net