1
=== modified file 'debian/control'
2
--- debian/control	2015-05-19 21:34:34 +0000
3
+++ debian/control	2015-06-01 09:48:29 +0000
4
@@ -138,7 +138,7 @@
5
138
 .
138
 .
6
139
 Contains header files required to build Mir servers.
139
 Contains header files required to build Mir servers.
7
140
140
9
141
Package: libmirclient8
141
Package: libmirclient9
10
142
Section: libs
142
Section: libs
11
143
Architecture: i386 amd64 armhf arm64
143
Architecture: i386 amd64 armhf arm64
12
144
Multi-Arch: same
144
Multi-Arch: same
13
@@ -156,7 +156,7 @@
14
156
Architecture: i386 amd64 armhf arm64
156
Architecture: i386 amd64 armhf arm64
15
157
Multi-Arch: same
157
Multi-Arch: same
16
158
Pre-Depends: ${misc:Pre-Depends}
158
Pre-Depends: ${misc:Pre-Depends}
18
159
Depends: libmirclient8 (= ${binary:Version}),
159
Depends: libmirclient9 (= ${binary:Version}),
19
160
         libmircommon-dev (= ${binary:Version}),
160
         libmircommon-dev (= ${binary:Version}),
20
161
         libprotobuf-dev (>= 2.4.1),
161
         libprotobuf-dev (>= 2.4.1),
21
162
         ${misc:Depends},
162
         ${misc:Depends},
22
163
163
23
=== renamed file 'debian/libmirclient8.install' => 'debian/libmirclient9.install'
24
--- debian/libmirclient8.install	2015-03-31 02:35:42 +0000
25
+++ debian/libmirclient9.install	2015-06-01 09:48:29 +0000
26
@@ -1,1 +1,1 @@
28
1
usr/lib/*/libmirclient.so.8
1
usr/lib/*/libmirclient.so.9
29
2
2
30
=== removed file 'include/client/mir_toolkit/mir_client_library_drm.h'
31
--- include/client/mir_toolkit/mir_client_library_drm.h	2015-05-19 21:34:34 +0000
32
+++ include/client/mir_toolkit/mir_client_library_drm.h	1970-01-01 00:00:00 +0000
33
@@ -1,59 +0,0 @@
34
1
/*
35
2
 * Copyright © 2012 Canonical Ltd.
36
3
 *
37
4
 * This program is free software: you can redistribute it and/or modify it
38
5
 * under the terms of the GNU Lesser General Public License version 3,
39
6
 * as published by the Free Software Foundation.
40
7
 *
41
8
 * This program is distributed in the hope that it will be useful,
42
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
43
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
44
11
 * GNU Lesser General Public License for more details.
45
12
 *
46
13
 * You should have received a copy of the GNU Lesser General Public License
47
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
48
15
 */
49
16
50
17
#ifndef MIR_CLIENT_LIBRARY_DRM_H_
51
18
#define MIR_CLIENT_LIBRARY_DRM_H_
52
19
53
20
#include "mir_toolkit/mir_client_library.h"
54
21
55
22
#ifdef __cplusplus
56
23
/**
57
24
 * \addtogroup mir_toolkit
58
25
 * @{
59
26
 */
60
27
extern "C" {
61
28
#endif
62
29
63
30
struct gbm_device;
64
31
65
32
typedef void (*mir_drm_auth_magic_callback)(int status, void *context);
66
33
67
34
/* Authenticates a DRM magic cookie */
68
35
MirWaitHandle *mir_connection_drm_auth_magic(MirConnection *connection,
69
36
                                             unsigned int magic,
70
37
                                             mir_drm_auth_magic_callback callback,
71
38
                                             void *context)
72
39
    __attribute__((__deprecated__("Use mir_connection_platform_operation() with operations from mir_toolkit/mesa/platform_operation.h")));
73
40
74
41
/**
75
42
 * Set the gbm_device to be used by the EGL implementation.
76
43
 * This is required if the application needs to create EGLImages from
77
44
 * gbm buffers objects created on that gbm device.
78
45
 * \param [in] connection  The connection
79
46
 * \param [in] dev         The gbm_device to set
80
47
 * \return                 A non-zero value if the operation was successful,
81
48
 *                         0 otherwise
82
49
 */
83
50
int mir_connection_drm_set_gbm_device(MirConnection* connection,
84
51
                                      struct gbm_device* dev)
85
52
    __attribute__((__deprecated__("Use mir_connection_platform_operation() with operations from mir_toolkit/mesa/platform_operation.h")));
86
53
87
54
#ifdef __cplusplus
88
55
}
89
56
/**@}*/
90
57
#endif
91
58
92
59
#endif /* MIR_CLIENT_LIBRARY_DRM_H_ */
93
60
0
94
=== modified file 'include/client/mir_toolkit/mir_connection.h'
95
--- include/client/mir_toolkit/mir_connection.h	2015-03-31 02:35:42 +0000
96
+++ include/client/mir_toolkit/mir_connection.h	2015-06-01 09:48:29 +0000
97
@@ -104,12 +104,6 @@
98
104
    mir_lifecycle_event_callback callback, void* context);
104
    mir_lifecycle_event_callback callback, void* context);
99
105
105
100
106
/**
106
/**
101
107
 * \deprecated Use mir_connection_create_display_config
102
108
 */
103
109
__attribute__((__deprecated__("Use mir_connection_create_display_config()")))
104
110
void mir_connection_get_display_info(MirConnection *connection, MirDisplayInfo *display_info);
105
111
106
112
/**
107
113
 * Query the display
107
 * Query the display
108
114
 *   \warning return value must be destroyed via mir_display_config_destroy()
108
 *   \warning return value must be destroyed via mir_display_config_destroy()
109
115
 *   \warning may return null if connection is invalid
109
 *   \warning may return null if connection is invalid
110
116
110
111
=== modified file 'include/client/mir_toolkit/mir_screencast.h'
112
--- include/client/mir_toolkit/mir_screencast.h	2015-03-31 02:35:42 +0000
113
+++ include/client/mir_toolkit/mir_screencast.h	2015-06-01 09:48:29 +0000
114
@@ -56,13 +56,6 @@
115
56
 */
56
 */
116
57
MirBufferStream* mir_screencast_get_buffer_stream(MirScreencast *screencast);
57
MirBufferStream* mir_screencast_get_buffer_stream(MirScreencast *screencast);
117
58
58
118
59
/**
119
60
 * Get a window type that can be used by EGL.
120
61
 *   \param [in] screencast  The screencast
121
62
 *   \return                 An EGLNativeWindowType that the client can use
122
63
 */
123
64
MirEGLNativeWindowType mir_screencast_egl_native_window(MirScreencast *screencast) __attribute__((__deprecated__("Use mir_screencast_get_buffer_stream and the corresponding mir_buffer_stream* function")));
124
65
125
66
#ifdef __cplusplus
59
#ifdef __cplusplus
126
67
}
60
}
127
68
/**@}*/
61
/**@}*/
128
69
62
129
=== modified file 'include/client/mir_toolkit/mir_surface.h'
130
--- include/client/mir_toolkit/mir_surface.h	2015-05-19 21:34:34 +0000
131
+++ include/client/mir_toolkit/mir_surface.h	2015-06-01 09:48:29 +0000
132
@@ -383,42 +383,6 @@
133
383
void mir_surface_spec_release(MirSurfaceSpec* spec);
383
void mir_surface_spec_release(MirSurfaceSpec* spec);
134
384
384
135
385
/**
385
/**
136
386
 * Request a new Mir surface on the supplied connection with the supplied
137
387
 * parameters. The returned handle remains valid until the surface has been
138
388
 * released.
139
389
 *   \warning callback could be called from another thread. You must do any
140
390
 *            locking appropriate to protect your data accessed in the
141
391
 *            callback.
142
392
 *   \note    This will soon be deprecated. Use the *_spec_for_* / mir_surface_create()
143
393
 *            two-stage process instead.
144
394
 *   \param [in] connection          The connection
145
395
 *   \param [in] surface_parameters  Request surface parameters
146
396
 *   \param [in] callback            Callback function to be invoked when
147
397
 *                                   request completes
148
398
 *   \param [in,out] context         User data passed to the callback function
149
399
 *   \return                         A handle that can be passed to
150
400
 *                                   mir_wait_for
151
401
 */
152
402
MirWaitHandle *mir_connection_create_surface(
153
403
    MirConnection *connection,
154
404
    MirSurfaceParameters const *surface_parameters,
155
405
    mir_surface_callback callback,
156
406
    void *context) __attribute__((__deprecated__("Use mir_surface_create()")));
157
407
158
408
/**
159
409
 * Create a surface like in mir_connection_create_surface(), but also wait for
160
410
 * creation to complete and return the resulting surface.
161
411
 *   \note    This will soon be deprecated. Use the create_spec_for/mir_surface_create()
162
412
 *            two-stage process instead.
163
413
 *   \param [in] connection  The connection
164
414
 *   \param [in] params      Parameters describing the desired surface
165
415
 *   \return                 The resulting surface
166
416
 */
167
417
MirSurface *mir_connection_create_surface_sync(
168
418
    MirConnection *connection,
169
419
    MirSurfaceParameters const *params) __attribute__((__deprecated__("Use mir_surface_create_sync()")));
170
420
171
421
/**
172
422
 * Set the event handler to be called when events arrive for a surface.
386
 * Set the event handler to be called when events arrive for a surface.
173
423
 *   \warning event_handler could be called from another thread. You must do
387
 *   \warning event_handler could be called from another thread. You must do
174
424
 *            any locking appropriate to protect your data accessed in the
388
 *            any locking appropriate to protect your data accessed in the
175
@@ -442,13 +406,6 @@
176
442
MirBufferStream* mir_surface_get_buffer_stream(MirSurface *surface);
406
MirBufferStream* mir_surface_get_buffer_stream(MirSurface *surface);
177
443
407
178
444
/**
408
/**
179
445
 * Get a window type that can be used for OpenGL ES 2.0 acceleration.
180
446
 *   \param [in] surface  The surface
181
447
 *   \return              An EGLNativeWindowType that the client can use
182
448
 */
183
449
MirEGLNativeWindowType mir_surface_get_egl_native_window(MirSurface *surface) __attribute__((__deprecated__("Use mir_surface_get_buffer_stream and the corresponding mir_buffer_stream* function")));
184
450
185
451
/**
186
452
 * Test for a valid surface
409
 * Test for a valid surface
187
453
 *   \param [in] surface  The surface
410
 *   \param [in] surface  The surface
188
454
 *   \return              True if the supplied surface is valid, or
411
 *   \return              True if the supplied surface is valid, or
189
@@ -476,58 +433,6 @@
190
476
void mir_surface_get_parameters(MirSurface *surface, MirSurfaceParameters *parameters);
433
void mir_surface_get_parameters(MirSurface *surface, MirSurfaceParameters *parameters);
191
477
434
192
478
/**
435
/**
193
479
 * Get the underlying platform type so the buffer obtained in "raw" representation
194
480
 * in mir_surface_get_current_buffer() can be understood
195
481
 *   \pre                     The surface is valid
196
482
 *   \param [in] surface      The surface
197
483
 *   \return                  One of mir_platform_type_android or mir_platform_type_gbm
198
484
 */
199
485
MirPlatformType mir_surface_get_platform_type(MirSurface *surface) __attribute__((__deprecated__("Use mir_surface_get_buffer_stream and the corresponding mir_buffer_stream* function")));
200
486
201
487
/**
202
488
 * Get a surface's buffer in "raw" representation.
203
489
 *   \pre                         The surface is valid
204
490
 *   \param [in] surface          The surface
205
491
 *   \param [out] buffer_package  Structure to be populated
206
492
 */
207
493
void mir_surface_get_current_buffer(MirSurface *surface, MirNativeBuffer **buffer_package) __attribute__((__deprecated__("Use mir_surface_get_buffer_stream and the corresponding mir_buffer_stream* function")));
208
494
209
495
/**
210
496
 * Get a surface's graphics_region, i.e., map the graphics buffer to main
211
497
 * memory.
212
498
 *   \pre                          The surface is valid
213
499
 *   \param [in] surface           The surface
214
500
 *   \param [out] graphics_region  Structure to be populated
215
501
 */
216
502
void mir_surface_get_graphics_region(
217
503
    MirSurface *surface,
218
504
    MirGraphicsRegion *graphics_region) __attribute__((__deprecated__("Use mir_surface_get_buffer_stream and the corresponding mir_buffer_stream* function")));
219
505
                                                                          /**
220
506
 * Advance a surface's buffer. The returned handle remains valid until the next
221
507
 * call to mir_surface_swap_buffers, until the surface has been released or the
222
508
 * connection to the server has been released.
223
509
 *   \warning callback could be called from another thread. You must do any
224
510
 *            locking appropriate to protect your data accessed in the
225
511
 *            callback.
226
512
 *   \param [in] surface      The surface
227
513
 *   \param [in] callback     Callback function to be invoked when the request
228
514
 *                            completes
229
515
 *   \param [in,out] context  User data passed to the callback function
230
516
 *   \return                  A handle that can be passed to mir_wait_for
231
517
 */
232
518
MirWaitHandle *mir_surface_swap_buffers(
233
519
    MirSurface *surface,
234
520
    mir_surface_callback callback,
235
521
    void *context) __attribute__((__deprecated__("Use mir_surface_get_buffer_stream and the corresponding mir_buffer_stream* function")));
236
522
237
523
/**
238
524
 * Advance a surface's buffer as in mir_surface_swap_buffers(), but also wait
239
525
 * for the operation to complete.
240
526
 *   \param [in] surface  The surface whose buffer to advance
241
527
 */
242
528
void mir_surface_swap_buffers_sync(MirSurface *surface) __attribute__((__deprecated__("Use mir_surface_get_buffer_stream and the corresponding mir_buffer_stream* function")));
243
529
244
530
/**
245
531
 * Release the supplied surface and any associated buffer. The returned wait
436
 * Release the supplied surface and any associated buffer. The returned wait
246
532
 * handle remains valid until the connection to the server is released.
437
 * handle remains valid until the connection to the server is released.
247
533
 *   \warning callback could be called from another thread. You must do any
438
 *   \warning callback could be called from another thread. You must do any
248
@@ -552,18 +457,6 @@
249
552
void mir_surface_release_sync(MirSurface *surface);
457
void mir_surface_release_sync(MirSurface *surface);
250
553
458
251
554
/**
459
/**
252
555
 * \deprecated Use mir_debug_surface_id()
253
556
 */
254
557
__attribute__((__deprecated__("Use mir_debug_surface_id()")))
255
558
int mir_surface_get_id(MirSurface *surface);
256
559
257
560
/**
258
561
 * \deprecated Use the mir_connection_create_spec_for_xxx family of APIs
259
562
 */
260
563
__attribute__((__deprecated__("Use mir_connection_create_spec_for_xxx()")))
261
564
MirWaitHandle* mir_surface_set_type(MirSurface *surface, MirSurfaceType type);
262
565
263
566
/**
264
567
 * Get the type (purpose) of a surface.
460
 * Get the type (purpose) of a surface.
265
568
 *   \param [in] surface  The surface to query
461
 *   \param [in] surface  The surface to query
266
569
 *   \return              The type of the surface
462
 *   \return              The type of the surface
267
570
463
268
=== modified file 'src/client/CMakeLists.txt'
269
--- src/client/CMakeLists.txt	2015-05-19 21:34:34 +0000
270
+++ src/client/CMakeLists.txt	2015-06-01 09:48:29 +0000
271
@@ -23,7 +23,7 @@
272
23
  ${DRM_INCLUDE_DIRS}
23
  ${DRM_INCLUDE_DIRS}
273
24
)
24
)
274
25
25
276
26
set(MIRCLIENT_ABI 8)
26
set(MIRCLIENT_ABI 9)
277
27
set(symbol_map ${CMAKE_SOURCE_DIR}/src/client/symbols.map)
27
set(symbol_map ${CMAKE_SOURCE_DIR}/src/client/symbols.map)
278
28
28
279
29
add_definitions(-DMIR_CLIENT_PLATFORM_PATH="${MIR_CLIENT_PLATFORM_PATH}/")
29
add_definitions(-DMIR_CLIENT_PLATFORM_PATH="${MIR_CLIENT_PLATFORM_PATH}/")
280
30
30
281
=== modified file 'src/client/mir_connection.h'
282
--- src/client/mir_connection.h	2015-05-15 07:32:33 +0000
283
+++ src/client/mir_connection.h	2015-06-01 09:48:29 +0000
284
@@ -29,7 +29,6 @@
285
29
#include "mir_protobuf.pb.h"
29
#include "mir_protobuf.pb.h"
286
30
30
287
31
#include "mir_toolkit/mir_client_library.h"
31
#include "mir_toolkit/mir_client_library.h"
288
32
#include "mir_toolkit/mir_client_library_drm.h"
289
33
32
290
34
#include "mir/client_platform.h"
33
#include "mir/client_platform.h"
291
35
#include "mir/client_context.h"
34
#include "mir/client_context.h"
292
36
35
293
=== modified file 'src/client/mir_connection_api.cpp'
294
--- src/client/mir_connection_api.cpp	2015-03-31 02:35:42 +0000
295
+++ src/client/mir_connection_api.cpp	2015-06-01 09:48:29 +0000
296
@@ -20,7 +20,6 @@
297
20
20
298
21
#include "mir_connection_api.h"
21
#include "mir_connection_api.h"
299
22
#include "mir_toolkit/mir_connection.h"
22
#include "mir_toolkit/mir_connection.h"
300
23
#include "mir_toolkit/mir_client_library_drm.h"
301
24
#include "mir/default_configuration.h"
23
#include "mir/default_configuration.h"
302
25
#include "mir/raii.h"
24
#include "mir/raii.h"
303
26
25
304
@@ -203,55 +202,6 @@
305
203
        connection->register_lifecycle_event_callback(callback, context);
202
        connection->register_lifecycle_event_callback(callback, context);
306
204
}
203
}
307
205
204
308
206
//TODO: DEPRECATED: remove this function
309
207
void mir_connection_get_display_info(
310
208
    MirConnection* connection,
311
209
    MirDisplayInfo* display_info)
312
210
{
313
211
    auto const config = mir::raii::deleter_for(
314
212
        mir_connection_create_display_config(connection),
315
213
        &mir_display_config_destroy);
316
214
317
215
    if (config->num_outputs < 1)
318
216
        return;
319
217
320
218
    MirDisplayOutput* state = nullptr;
321
219
    // We can't handle more than one display, so just populate based on the first
322
220
    // active display we find.
323
221
    for (unsigned int i = 0; i < config->num_outputs; ++i)
324
222
    {
325
223
        if (config->outputs[i].used && config->outputs[i].connected &&
326
224
            config->outputs[i].current_mode < config->outputs[i].num_modes)
327
225
        {
328
226
            state = &config->outputs[i];
329
227
            break;
330
228
        }
331
229
    }
332
230
    // Oh, oh! No connected outputs?!
333
231
    if (state == nullptr)
334
232
    {
335
233
        memset(display_info, 0, sizeof(*display_info));
336
234
        return;
337
235
    }
338
236
339
237
    MirDisplayMode mode = state->modes[state->current_mode];
340
238
341
239
    display_info->width = mode.horizontal_resolution;
342
240
    display_info->height = mode.vertical_resolution;
343
241
344
242
    unsigned int format_items;
345
243
    if (state->num_output_formats > mir_supported_pixel_format_max)
346
244
         format_items = mir_supported_pixel_format_max;
347
245
    else
348
246
         format_items = state->num_output_formats;
349
247
350
248
    display_info->supported_pixel_format_items = format_items;
351
249
    for(auto i=0u; i < format_items; i++)
352
250
    {
353
251
        display_info->supported_pixel_format[i] = state->output_formats[i];
354
252
    }
355
253
}
356
254
357
255
MirDisplayConfiguration* mir_connection_create_display_config(
205
MirDisplayConfiguration* mir_connection_create_display_config(
358
256
    MirConnection* connection)
206
    MirConnection* connection)
359
257
{
207
{
360
@@ -305,20 +255,7 @@
361
305
        connection->available_surface_formats(formats, format_size, *num_valid_formats);
255
        connection->available_surface_formats(formats, format_size, *num_valid_formats);
362
306
}
256
}
363
307
257
378
308
extern "C"
258
MirWaitHandle* mir_connection_platform_operation(
365
309
{
366
310
MirWaitHandle* new_mir_connection_platform_operation(
367
311
    MirConnection* connection,
368
312
    MirPlatformMessage const* request,
369
313
    mir_platform_operation_callback callback, void* context);
370
314
MirWaitHandle* old_mir_connection_platform_operation(
371
315
    MirConnection* connection, int /* opcode */,
372
316
    MirPlatformMessage const* request,
373
317
    mir_platform_operation_callback callback, void* context);
374
318
}
375
319
376
320
__asm__(".symver new_mir_connection_platform_operation,mir_connection_platform_operation@@MIR_CLIENT_8.3");
377
321
MirWaitHandle* new_mir_connection_platform_operation(
379
322
    MirConnection* connection,
259
    MirConnection* connection,
380
323
    MirPlatformMessage const* request,
260
    MirPlatformMessage const* request,
381
324
    mir_platform_operation_callback callback, void* context)
261
    mir_platform_operation_callback callback, void* context)
382
@@ -332,115 +269,4 @@
383
332
        MIR_LOG_UNCAUGHT_EXCEPTION(ex);
269
        MIR_LOG_UNCAUGHT_EXCEPTION(ex);
384
333
        return nullptr;
270
        return nullptr;
385
334
    }
271
    }
386
335
387
336
}
388
337
389
338
// TODO: Remove when we bump so name
390
339
__asm__(".symver old_mir_connection_platform_operation,mir_connection_platform_operation@MIR_CLIENT_8");
391
340
MirWaitHandle* old_mir_connection_platform_operation(
392
341
    MirConnection* connection, int /* opcode */,
393
342
    MirPlatformMessage const* request,
394
343
    mir_platform_operation_callback callback, void* context)
395
344
{
396
345
    return new_mir_connection_platform_operation(connection, request, callback, context);
397
346
}
398
347
399
348
/**************************
400
349
 * DRM specific functions *
401
350
 **************************/
402
351
403
352
namespace
404
353
{
405
354
406
355
struct AuthMagicPlatformOperationContext
407
356
{
408
357
    mir_drm_auth_magic_callback callback;
409
358
    void* context;
410
359
};
411
360
412
361
void platform_operation_to_auth_magic_callback(
413
362
    MirConnection*, MirPlatformMessage* response, void* context)
414
363
{
415
364
    auto const response_msg = mir::raii::deleter_for(
416
365
        response,
417
366
        &mir_platform_message_release);
418
367
    auto const auth_magic_context =
419
368
        std::unique_ptr<AuthMagicPlatformOperationContext>{
420
369
            static_cast<AuthMagicPlatformOperationContext*>(context)};
421
370
422
371
    auto response_data = mir_platform_message_get_data(response_msg.get());
423
372
    MirMesaAuthMagicResponse auth_response{-1};
424
373
425
374
    if (response_data.size == sizeof(auth_response))
426
375
        std::memcpy(&auth_response, response_data.data, response_data.size);
427
376
428
377
    auth_magic_context->callback(auth_response.status, auth_magic_context->context);
429
378
}
430
379
431
380
void assign_set_gbm_device_status(
432
381
    MirConnection*, MirPlatformMessage* response, void* context)
433
382
{
434
383
    auto const response_msg = mir::raii::deleter_for(
435
384
        response,
436
385
        &mir_platform_message_release);
437
386
438
387
    auto const response_data = mir_platform_message_get_data(response_msg.get());
439
388
    MirMesaSetGBMDeviceResponse set_gbm_device_response{-1};
440
389
441
390
    if (response_data.size == sizeof(set_gbm_device_response))
442
391
        std::memcpy(&set_gbm_device_response, response_data.data, response_data.size);
443
392
444
393
    auto status_ptr = static_cast<int*>(context);
445
394
    *status_ptr = set_gbm_device_response.status;
446
395
}
447
396
448
397
}
449
398
450
399
MirWaitHandle* mir_connection_drm_auth_magic(MirConnection* connection,
451
400
                                             unsigned int magic,
452
401
                                             mir_drm_auth_magic_callback callback,
453
402
                                             void* context)
454
403
{
455
404
    auto const msg = mir::raii::deleter_for(
456
405
        mir_platform_message_create(MirMesaPlatformOperation::auth_magic),
457
406
        &mir_platform_message_release);
458
407
459
408
    auto const auth_magic_op_context =
460
409
        new AuthMagicPlatformOperationContext{callback, context};
461
410
462
411
    MirMesaAuthMagicRequest request;
463
412
    request.magic = magic;
464
413
465
414
    mir_platform_message_set_data(msg.get(), &request, sizeof(request));
466
415
467
416
    return new_mir_connection_platform_operation(
468
417
        connection,
469
418
        msg.get(),
470
419
        platform_operation_to_auth_magic_callback,
471
420
        auth_magic_op_context);
472
421
}
473
422
474
423
int mir_connection_drm_set_gbm_device(MirConnection* connection,
475
424
                                      struct gbm_device* gbm_dev)
476
425
{
477
426
    MirMesaSetGBMDeviceRequest const request{gbm_dev};
478
427
479
428
    auto const msg = mir::raii::deleter_for(
480
429
        mir_platform_message_create(MirMesaPlatformOperation::set_gbm_device),
481
430
        &mir_platform_message_release);
482
431
483
432
    mir_platform_message_set_data(msg.get(), &request, sizeof(request));
484
433
485
434
    static int const success{0};
486
435
    int status{-1};
487
436
488
437
    auto wh = new_mir_connection_platform_operation(
489
438
        connection,
490
439
        msg.get(),
491
440
        assign_set_gbm_device_status,
492
441
        &status);
493
442
494
443
    mir_wait_for(wh);
495
444
496
445
    return status == success;
497
446
}
272
}
498
447
273
499
=== modified file 'src/client/mir_screencast_api.cpp'
500
--- src/client/mir_screencast_api.cpp	2015-03-31 02:35:42 +0000
501
+++ src/client/mir_screencast_api.cpp	2015-06-01 09:48:29 +0000
502
@@ -86,11 +86,6 @@
503
86
    delete screencast;
86
    delete screencast;
504
87
}
87
}
505
88
88
506
89
MirEGLNativeWindowType mir_screencast_egl_native_window(MirScreencast* screencast)
507
90
{
508
91
    return reinterpret_cast<MirEGLNativeWindowType>(mir_buffer_stream_get_egl_native_window(mir_screencast_get_buffer_stream(screencast)));
509
92
}
510
93
511
94
MirBufferStream *mir_screencast_get_buffer_stream(MirScreencast *screencast)
89
MirBufferStream *mir_screencast_get_buffer_stream(MirScreencast *screencast)
512
95
try
90
try
513
96
{
91
{
514
97
92
515
=== modified file 'src/client/mir_surface_api.cpp'
516
--- src/client/mir_surface_api.cpp	2015-05-19 21:34:34 +0000
517
+++ src/client/mir_surface_api.cpp	2015-06-01 09:48:29 +0000
518
@@ -229,57 +229,14 @@
519
229
    delete spec;
229
    delete spec;
520
230
}
230
}
521
231
231
522
232
MirWaitHandle* mir_connection_create_surface(
523
233
    MirConnection* connection,
524
234
    MirSurfaceParameters const* params,
525
235
    mir_surface_callback callback,
526
236
    void* context)
527
237
{
528
238
    MirSurfaceSpec spec{connection, *params};
529
239
    return mir_surface_create(&spec, callback, context);
530
240
}
531
241
532
242
MirSurface* mir_connection_create_surface_sync(
533
243
    MirConnection* connection,
534
244
    MirSurfaceParameters const* params)
535
245
{
536
246
    MirSurfaceSpec spec{connection, *params};
537
247
    return mir_surface_create_sync(&spec);
538
248
}
539
249
540
250
__asm__(".symver new_mir_surface_set_event_handler,mir_surface_set_event_handler@@MIR_CLIENT_8.4");
541
251
extern "C"
232
extern "C"
543
252
void new_mir_surface_set_event_handler(MirSurface* surface,
233
void mir_surface_set_event_handler(MirSurface* surface,
544
253
                                       mir_surface_event_callback callback,
234
                                       mir_surface_event_callback callback,
545
254
                                       void* context)
235
                                       void* context)
546
255
{
236
{
547
256
    surface->set_event_handler(callback, context);
237
    surface->set_event_handler(callback, context);
548
257
}
238
}
549
258
239
550
259
// Deprecated but ABI backward compatible --->
551
260
typedef struct MirEventDelegate
552
261
{
553
262
    mir_surface_event_callback callback;
554
263
    void *context;
555
264
} MirEventDelegate;
556
265
557
266
__asm__(".symver old_mir_surface_set_event_handler,mir_surface_set_event_handler@MIR_CLIENT_8");
558
267
extern "C"
559
268
void old_mir_surface_set_event_handler(MirSurface* surface,
560
269
                                       MirEventDelegate const* delegate)
561
270
{
562
271
    if (delegate)
563
272
        surface->set_event_handler(delegate->callback, delegate->context);
564
273
    else
565
274
        surface->set_event_handler(nullptr, nullptr);
566
275
}
567
276
// <--- Deprecated
568
277
569
278
MirEGLNativeWindowType mir_surface_get_egl_native_window(MirSurface* surface)
570
279
{
571
280
    return mir_buffer_stream_get_egl_native_window(
572
281
        mir_surface_get_buffer_stream(surface));
573
282
}
574
283
240
575
284
bool mir_surface_is_valid(MirSurface* surface)
241
bool mir_surface_is_valid(MirSurface* surface)
576
285
{
242
{
577
@@ -296,57 +253,6 @@
578
296
    *parameters = surface->get_parameters();
253
    *parameters = surface->get_parameters();
579
297
}
254
}
580
298
255
581
299
MirPlatformType mir_surface_get_platform_type(MirSurface* surface)
582
300
{
583
301
    return mir_buffer_stream_get_platform_type(mir_surface_get_buffer_stream(surface));
584
302
}
585
303
586
304
void mir_surface_get_current_buffer(MirSurface* surface, MirNativeBuffer** buffer_package_out)
587
305
{
588
306
    mir_buffer_stream_get_current_buffer(mir_surface_get_buffer_stream(surface), buffer_package_out);
589
307
}
590
308
591
309
void mir_surface_get_graphics_region(MirSurface* surface, MirGraphicsRegion* graphics_region)
592
310
{
593
311
    mir_buffer_stream_get_graphics_region(mir_surface_get_buffer_stream(surface), graphics_region);
594
312
}
595
313
596
314
namespace
597
315
{
598
316
void buffer_to_surface_thunk(MirBufferStream* /* stream */, void* context)
599
317
{
600
318
    auto cb = static_cast<std::function<void()>*>(context);
601
319
    (*cb)();
602
320
}
603
321
}
604
322
605
323
MirWaitHandle* mir_surface_swap_buffers(
606
324
    MirSurface* surface,
607
325
    mir_surface_callback callback,
608
326
    void* context)
609
327
try
610
328
{
611
329
    auto shim_callback = new std::function<void()>;
612
330
    *shim_callback = [surface, callback, context, shim_callback] ()
613
331
    {
614
332
        if (callback)
615
333
            callback(surface, context);
616
334
        delete shim_callback;
617
335
    };
618
336
    return mir_buffer_stream_swap_buffers(mir_surface_get_buffer_stream(surface), buffer_to_surface_thunk, shim_callback);
619
337
}
620
338
catch (std::exception const& ex)
621
339
{
622
340
    MIR_LOG_UNCAUGHT_EXCEPTION(ex);
623
341
    return nullptr;
624
342
}
625
343
626
344
void mir_surface_swap_buffers_sync(MirSurface* surface)
627
345
{
628
346
    mir_buffer_stream_swap_buffers_sync(
629
347
        mir_surface_get_buffer_stream(surface));
630
348
}
631
349
632
350
MirWaitHandle* mir_surface_release(
256
MirWaitHandle* mir_surface_release(
633
351
    MirSurface* surface,
257
    MirSurface* surface,
634
352
    mir_surface_callback callback, void* context)
258
    mir_surface_callback callback, void* context)
635
@@ -369,25 +275,6 @@
636
369
        nullptr));
275
        nullptr));
637
370
}
276
}
638
371
277
639
372
int mir_surface_get_id(MirSurface* /*surface*/)
640
373
{
641
374
    return 0;
642
375
}
643
376
644
377
MirWaitHandle* mir_surface_set_type(MirSurface* surf,
645
378
                                    MirSurfaceType type)
646
379
{
647
380
    try
648
381
    {
649
382
        return surf ? surf->configure(mir_surface_attrib_type, type) : nullptr;
650
383
    }
651
384
    catch (std::exception const& ex)
652
385
    {
653
386
        MIR_LOG_UNCAUGHT_EXCEPTION(ex);
654
387
        return nullptr;
655
388
    }
656
389
}
657
390
658
391
MirSurfaceType mir_surface_get_type(MirSurface* surf)
278
MirSurfaceType mir_surface_get_type(MirSurface* surf)
659
392
{
279
{
660
393
    MirSurfaceType type = mir_surface_type_normal;
280
    MirSurfaceType type = mir_surface_type_normal;
661
394
281
662
=== modified file 'src/client/symbols-debug.map'
663
--- src/client/symbols-debug.map	2015-03-31 02:35:42 +0000
664
+++ src/client/symbols-debug.map	2015-06-01 09:48:29 +0000
665
@@ -1,4 +1,4 @@
667
1
MIR_CLIENT_DEBUG_8 {
1
MIR_CLIENT_DEBUG_9 {
668
2
 global: 
2
 global: 
669
3
   mir_debug_*;
3
   mir_debug_*;
670
4
 local: *;
4
 local: *;
671
5
5
672
=== modified file 'src/client/symbols.map'
673
--- src/client/symbols.map	2015-05-21 19:25:51 +0000
674
+++ src/client/symbols.map	2015-06-01 09:48:29 +0000
675
@@ -1,23 +1,34 @@
677
1
MIR_CLIENT_8 {
1
MIR_CLIENT_9 {
678
2
 global:
2
 global:
679
3
    mir_arrow_cursor_name;
3
    mir_arrow_cursor_name;
680
4
    mir_buffer_stream_get_current_buffer;
681
5
    mir_buffer_stream_get_egl_native_window;
682
6
    mir_buffer_stream_get_graphics_region;
683
7
    mir_buffer_stream_get_platform_type;
684
8
    mir_buffer_stream_is_valid;
685
9
    mir_buffer_stream_release;
686
10
    mir_buffer_stream_release_sync;
687
11
    mir_buffer_stream_swap_buffers;
688
12
    mir_buffer_stream_swap_buffers_sync;
689
4
    mir_busy_cursor_name;
13
    mir_busy_cursor_name;
690
5
    mir_caret_cursor_name;
14
    mir_caret_cursor_name;
691
6
    mir_closed_hand_cursor_name;
15
    mir_closed_hand_cursor_name;
692
7
    mir_connect;
16
    mir_connect;
693
8
    mir_connection_api_impl;
17
    mir_connection_api_impl;
694
9
    mir_connection_apply_display_config;
18
    mir_connection_apply_display_config;
695
19
    mir_connection_create_buffer_stream;
696
20
    mir_connection_create_buffer_stream_sync;
697
10
    mir_connection_create_display_config;
21
    mir_connection_create_display_config;
698
11
    mir_connection_create_prompt_session_sync;
22
    mir_connection_create_prompt_session_sync;
699
12
    mir_connection_create_screencast_sync;
23
    mir_connection_create_screencast_sync;
700
24
    mir_connection_create_spec_for_changes;
701
25
    mir_connection_create_spec_for_dialog;
702
13
    mir_connection_create_spec_for_input_method;
26
    mir_connection_create_spec_for_input_method;
703
27
    mir_connection_create_spec_for_menu;
704
14
    mir_connection_create_spec_for_modal_dialog;
28
    mir_connection_create_spec_for_modal_dialog;
709
15
    mir_connection_create_surface;
29
    mir_connection_create_spec_for_normal_surface;
710
16
    mir_connection_create_surface_sync;
30
    mir_connection_create_spec_for_tooltip;
707
17
    mir_connection_drm_auth_magic;
708
18
    mir_connection_drm_set_gbm_device;
711
19
    mir_connection_get_available_surface_formats;
31
    mir_connection_get_available_surface_formats;
712
20
    mir_connection_get_display_info;
713
21
    mir_connection_get_egl_native_display;
32
    mir_connection_get_egl_native_display;
714
22
    mir_connection_get_error_message;
33
    mir_connection_get_error_message;
715
23
    mir_connection_get_platform;
34
    mir_connection_get_platform;
716
@@ -28,123 +39,29 @@
717
28
    mir_connection_set_lifecycle_event_callback;
39
    mir_connection_set_lifecycle_event_callback;
718
29
    mir_connect_sync;
40
    mir_connect_sync;
719
30
    mir_cursor_configuration_destroy;
41
    mir_cursor_configuration_destroy;
720
42
    mir_cursor_configuration_from_buffer_stream;
721
31
    mir_cursor_configuration_from_name;
43
    mir_cursor_configuration_from_name;
722
32
    mir_default_cursor_name;
44
    mir_default_cursor_name;
723
33
    mir_diagonal_resize_bottom_to_top_cursor_name;
45
    mir_diagonal_resize_bottom_to_top_cursor_name;
724
34
    mir_diagonal_resize_top_to_bottom_cursor_name;
46
    mir_diagonal_resize_top_to_bottom_cursor_name;
725
35
    mir_disabled_cursor_name;
47
    mir_disabled_cursor_name;
726
36
    mir_display_config_destroy;
48
    mir_display_config_destroy;
727
37
    mir_horizontal_resize_cursor_name;
728
38
    mir_hsplit_resize_cursor_name;
729
39
    mir_omnidirectional_resize_cursor_name;
730
40
    mir_open_hand_cursor_name;
731
41
    mir_platform_message_create;
732
42
    mir_platform_message_get_data;
733
43
    mir_platform_message_get_fds;
734
44
    mir_platform_message_get_opcode;
735
45
    mir_platform_message_release;
736
46
    mir_platform_message_set_data;
737
47
    mir_platform_message_set_fds;
738
48
    mir_pointing_hand_cursor_name;
739
49
    mir_prompt_session_error_message;
740
50
    mir_prompt_session_is_valid;
741
51
    mir_prompt_session_new_fds_for_prompt_providers;
742
52
    mir_prompt_session_release_sync;
743
53
    mir_screencast_egl_native_window;
744
54
    mir_screencast_release_sync;
745
55
    mir_surface_configure_cursor;
746
56
    mir_surface_get_current_buffer;
747
57
    mir_surface_get_dpi;
748
58
    mir_surface_get_egl_native_window;
749
59
    mir_surface_get_error_message;
750
60
    mir_surface_get_focus;
751
61
    mir_surface_get_graphics_region;
752
62
    mir_surface_get_id;
753
63
    mir_surface_get_orientation;
754
64
    mir_surface_get_parameters;
755
65
    mir_surface_get_platform_type;
756
66
    mir_surface_get_state;
757
67
    mir_surface_get_swapinterval;
758
68
    mir_surface_get_type;
759
69
    mir_surface_get_visibility;
760
70
    mir_surface_is_valid;
761
71
    mir_surface_release;
762
72
    mir_surface_release_sync;
763
73
    mir_surface_set_event_handler;
764
74
    mir_surface_set_state;
765
75
    mir_surface_set_swapinterval;
766
76
    mir_surface_set_type;
767
77
    mir_surface_spec_release;
768
78
    mir_surface_swap_buffers;
769
79
    mir_surface_swap_buffers_sync;
770
80
    mir_vertical_resize_cursor_name;
771
81
    mir_vsplit_resize_cursor_name;
772
82
    mir_wait_for;
773
83
    mir_wait_for_one;
774
84
 local: *;
775
85
};
776
86
MIR_CLIENT_8.1 {
777
87
 global:
778
88
    mir_connection_create_spec_for_normal_surface;
779
89
    mir_surface_create;
780
90
    mir_surface_create_sync;
781
91
    mir_surface_spec_set_buffer_usage;
782
92
    mir_surface_spec_set_fullscreen_on_output;
783
93
    mir_surface_spec_set_height;
784
94
    mir_surface_spec_set_name;
785
95
    mir_surface_spec_set_pixel_format;
786
96
    mir_surface_spec_set_width;
787
97
} MIR_CLIENT_8;
788
98
789
99
MIR_CLIENT_8.2 {
790
100
 global:
791
101
    mir_surface_get_preferred_orientation;
792
102
    mir_surface_set_preferred_orientation;
793
103
    mir_surface_spec_set_preferred_orientation;
794
104
} MIR_CLIENT_8.1;
795
105
796
106
MIR_CLIENT_8.3 {   # New in Mir 0.11
797
107
 global:
798
108
    mir_connection_create_spec_for_dialog;
799
109
    mir_connection_create_spec_for_menu;
800
110
    mir_connection_create_spec_for_tooltip;
801
111
    mir_connection_platform_operation;
802
112
} MIR_CLIENT_8.2;
803
113
804
114
MIR_CLIENT_8.4 {   # New in Mir 0.13
805
115
 global:
806
116
    mir_connection_create_spec_for_changes;
807
117
    mir_surface_apply_spec;
808
118
    mir_surface_set_event_handler;
809
119
    mir_default_cursor_name;
810
120
    mir_disabled_cursor_name;
811
121
    mir_arrow_cursor_name;
812
122
    mir_busy_cursor_name;
813
123
    mir_caret_cursor_name;
814
124
    mir_pointing_hand_cursor_name;
815
125
    mir_open_hand_cursor_name;
816
126
    mir_closed_hand_cursor_name;
817
127
    mir_horizontal_resize_cursor_name;
818
128
    mir_vertical_resize_cursor_name;
819
129
    mir_diagonal_resize_bottom_to_top_cursor_name;
820
130
    mir_diagonal_resize_top_to_bottom_cursor_name;
821
131
    mir_omnidirectional_resize_cursor_name;
822
132
    mir_vsplit_resize_cursor_name;
823
133
    mir_hsplit_resize_cursor_name;
824
134
    mir_event_get_close_surface_event;
49
    mir_event_get_close_surface_event;
825
50
    mir_event_get_input_configuration_event;
826
135
    mir_event_get_input_event;
51
    mir_event_get_input_event;
827
136
    mir_event_get_keymap_event;
52
    mir_event_get_keymap_event;
828
137
    mir_event_get_orientation_event;
53
    mir_event_get_orientation_event;
829
138
    mir_event_get_prompt_session_event;
54
    mir_event_get_prompt_session_event;
830
139
    mir_event_get_resize_event;
55
    mir_event_get_resize_event;
831
140
    mir_event_get_surface_event;
56
    mir_event_get_surface_event;
832
141
    mir_event_get_input_configuration_event;
833
142
    mir_event_get_type;
57
    mir_event_get_type;
834
58
    mir_event_ref;
835
59
    mir_event_unref;
836
60
    mir_horizontal_resize_cursor_name;
837
61
    mir_hsplit_resize_cursor_name;
838
143
    mir_input_configuration_event_get_action;
62
    mir_input_configuration_event_get_action;
839
63
    mir_input_configuration_event_get_device_id;
840
144
    mir_input_configuration_event_get_time;
64
    mir_input_configuration_event_get_time;
841
145
    mir_input_configuration_event_get_device_id;
842
146
    mir_event_ref;
843
147
    mir_event_unref;
844
148
    mir_input_event_get_device_id;
65
    mir_input_event_get_device_id;
845
149
    mir_input_event_get_event_time;
66
    mir_input_event_get_event_time;
846
150
    mir_input_event_get_keyboard_event;
67
    mir_input_event_get_keyboard_event;
847
@@ -156,50 +73,84 @@
848
156
    mir_keyboard_event_modifiers;
73
    mir_keyboard_event_modifiers;
849
157
    mir_keyboard_event_scan_code;
74
    mir_keyboard_event_scan_code;
850
158
    mir_keymap_event_get_rules;
75
    mir_keymap_event_get_rules;
851
76
    mir_omnidirectional_resize_cursor_name;
852
77
    mir_open_hand_cursor_name;
853
159
    mir_orientation_event_get_direction;
78
    mir_orientation_event_get_direction;
854
79
    mir_platform_message_create;
855
80
    mir_platform_message_get_data;
856
81
    mir_platform_message_get_fds;
857
82
    mir_platform_message_get_opcode;
858
83
    mir_platform_message_release;
859
84
    mir_platform_message_set_data;
860
85
    mir_platform_message_set_fds;
861
160
    mir_pointer_event_action;
86
    mir_pointer_event_action;
862
161
    mir_pointer_event_axis_value;
87
    mir_pointer_event_axis_value;
863
88
    mir_pointer_event_buttons;
864
162
    mir_pointer_event_button_state;
89
    mir_pointer_event_button_state;
865
163
    mir_pointer_event_modifiers;
90
    mir_pointer_event_modifiers;
866
91
    mir_pointing_hand_cursor_name;
867
92
    mir_prompt_session_error_message;
868
164
    mir_prompt_session_event_get_state;
93
    mir_prompt_session_event_get_state;
869
94
    mir_prompt_session_is_valid;
870
95
    mir_prompt_session_new_fds_for_prompt_providers;
871
96
    mir_prompt_session_release_sync;
872
165
    mir_resize_event_get_height;
97
    mir_resize_event_get_height;
873
166
    mir_resize_event_get_width;
98
    mir_resize_event_get_width;
874
99
    mir_screencast_get_buffer_stream;
875
100
    mir_screencast_release_sync;
876
101
    mir_surface_apply_spec;
877
102
    mir_surface_configure_cursor;
878
103
    mir_surface_create;
879
104
    mir_surface_create_sync;
880
167
    mir_surface_event_get_attribute;
105
    mir_surface_event_get_attribute;
881
168
    mir_surface_event_get_attribute_value;
106
    mir_surface_event_get_attribute_value;
882
107
    mir_surface_get_buffer_stream;
883
108
    mir_surface_get_dpi;
884
109
    mir_surface_get_error_message;
885
110
    mir_surface_get_focus;
886
111
    mir_surface_get_orientation;
887
112
    mir_surface_get_parameters;
888
113
    mir_surface_get_preferred_orientation;
889
114
    mir_surface_get_state;
890
115
    mir_surface_get_swapinterval;
891
116
    mir_surface_get_type;
892
117
    mir_surface_get_visibility;
893
118
    mir_surface_is_valid;
894
119
    mir_surface_release;
895
120
    mir_surface_release_sync;
896
121
    mir_surface_set_event_handler;
897
122
    mir_surface_set_preferred_orientation;
898
123
    mir_surface_set_state;
899
169
    mir_surface_set_swapinterval;
124
    mir_surface_set_swapinterval;
900
125
    mir_surface_spec_release;
901
126
    mir_surface_spec_set_buffer_usage;
902
127
    mir_surface_spec_set_fullscreen_on_output;
903
128
    mir_surface_spec_set_height;
904
170
    mir_surface_spec_set_height_increment;
129
    mir_surface_spec_set_height_increment;
905
171
    mir_surface_spec_set_max_aspect_ratio;
130
    mir_surface_spec_set_max_aspect_ratio;
906
131
    mir_surface_spec_set_max_height;
907
172
    mir_surface_spec_set_max_width;
132
    mir_surface_spec_set_max_width;
908
173
    mir_surface_spec_set_max_height;
909
174
    mir_surface_spec_set_min_aspect_ratio;
133
    mir_surface_spec_set_min_aspect_ratio;
910
134
    mir_surface_spec_set_min_height;
911
175
    mir_surface_spec_set_min_width;
135
    mir_surface_spec_set_min_width;
913
176
    mir_surface_spec_set_min_height;
136
    mir_surface_spec_set_name;
914
137
    mir_surface_spec_set_pixel_format;
915
138
    mir_surface_spec_set_preferred_orientation;
916
139
    mir_surface_spec_set_width;
917
177
    mir_surface_spec_set_width_increment;
140
    mir_surface_spec_set_width_increment;
918
178
    mir_surface_swap_buffers;
919
179
    mir_surface_swap_buffers_sync;
920
180
    mir_touch_event_modifiers;
921
181
    mir_touch_event_action;
141
    mir_touch_event_action;
922
182
    mir_touch_event_axis_value;
142
    mir_touch_event_axis_value;
923
143
    mir_touch_event_id;
924
144
    mir_touch_event_modifiers;
925
183
    mir_touch_event_point_count;
145
    mir_touch_event_point_count;
926
184
    mir_touch_event_id;
927
185
    mir_touch_event_tooltype;
146
    mir_touch_event_tooltype;
943
186
    mir_surface_get_buffer_stream;
147
    mir_vertical_resize_cursor_name;
944
187
    mir_buffer_stream_get_current_buffer;
148
    mir_vsplit_resize_cursor_name;
945
188
    mir_buffer_stream_get_platform_type;
149
    mir_wait_for;
946
189
    mir_buffer_stream_swap_buffers;
150
    mir_wait_for_one;
947
190
    mir_buffer_stream_swap_buffers_sync;
151
};
933
191
    mir_screencast_get_buffer_stream;
934
192
    mir_buffer_stream_get_egl_native_window;
935
193
    mir_buffer_stream_get_graphics_region;
936
194
    mir_connection_create_buffer_stream_sync;
937
195
    mir_cursor_configuration_from_buffer_stream;
938
196
    mir_buffer_stream_release;
939
197
    mir_buffer_stream_release_sync;
940
198
    mir_buffer_stream_is_valid;
941
199
    mir_pointer_event_buttons; # Move to 8.5
942
200
} MIR_CLIENT_8.3;
948
201
152
950
202
MIR_CLIENT_DETAIL_8 {
153
MIR_CLIENT_DETAIL_9 {
951
203
  global:
154
  global:
952
204
    extern "C++" { 
155
    extern "C++" { 
953
205
      mir::events::make_event*;
156
      mir::events::make_event*;
954
206
157
955
=== modified file 'tests/acceptance-tests/test_client_library.cpp'
956
--- tests/acceptance-tests/test_client_library.cpp	2015-05-19 21:34:34 +0000
957
+++ tests/acceptance-tests/test_client_library.cpp	2015-06-01 09:48:29 +0000
958
@@ -192,51 +192,6 @@
959
192
    mir_connection_release(connection);
192
    mir_connection_release(connection);
960
193
}
193
}
961
194
194
962
195
#pragma GCC diagnostic push
963
196
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
964
197
965
198
TEST_F(ClientLibrary, can_set_surface_types)
966
199
{
967
200
    mir_wait_for(mir_connect(new_connection().c_str(), __PRETTY_FUNCTION__, connection_callback, this));
968
201
969
202
    auto const spec =
970
203
        mir_connection_create_spec_for_normal_surface(
971
204
            connection, 640, 480, mir_pixel_format_abgr_8888);
972
205
973
206
    mir_wait_for(mir_surface_create(spec, create_surface_callback, this));
974
207
    mir_surface_spec_release(spec);
975
208
976
209
    EXPECT_THAT(mir_surface_get_type(surface), Eq(mir_surface_type_normal));
977
210
978
211
    mir_wait_for(mir_surface_set_type(surface, mir_surface_type_freestyle));
979
212
    EXPECT_THAT(mir_surface_get_type(surface), Eq(mir_surface_type_freestyle));
980
213
981
214
    mir_wait_for(mir_surface_set_type(surface, static_cast<MirSurfaceType>(999)));
982
215
    EXPECT_THAT(mir_surface_get_type(surface), Eq(mir_surface_type_freestyle));
983
216
984
217
    mir_wait_for(mir_surface_set_type(surface, mir_surface_type_dialog));
985
218
    EXPECT_THAT(mir_surface_get_type(surface), Eq(mir_surface_type_dialog));
986
219
987
220
    mir_wait_for(mir_surface_set_type(surface, static_cast<MirSurfaceType>(888)));
988
221
    EXPECT_THAT(mir_surface_get_type(surface), Eq(mir_surface_type_dialog));
989
222
990
223
    // Stress-test synchronization logic with some flooding
991
224
    for (int i = 0; i < 100; i++)
992
225
    {
993
226
        mir_surface_set_type(surface, mir_surface_type_normal);
994
227
        mir_surface_set_type(surface, mir_surface_type_utility);
995
228
        mir_surface_set_type(surface, mir_surface_type_dialog);
996
229
        mir_surface_set_type(surface, mir_surface_type_gloss);
997
230
        mir_surface_set_type(surface, mir_surface_type_freestyle);
998
231
        mir_wait_for(mir_surface_set_type(surface, mir_surface_type_menu));
999
232
        ASSERT_THAT(mir_surface_get_type(surface), Eq(mir_surface_type_menu));
1000
233
    }
1001
234
1002
235
    mir_wait_for(mir_surface_release(surface, release_surface_callback, this));
1003
236
    mir_connection_release(connection);
1004
237
}
1005
238
#pragma GCC diagnostic pop
1006
239
1007
240
TEST_F(ClientLibrary, can_set_surface_state)
195
TEST_F(ClientLibrary, can_set_surface_state)
1008
241
{
196
{
1009
242
    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
197
    connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
1010
243
198
1011
=== modified file 'tests/client-language/c99.c'
1012
--- tests/client-language/c99.c	2015-01-21 07:34:50 +0000
1013
+++ tests/client-language/c99.c	2015-06-01 09:48:29 +0000
1014
@@ -21,7 +21,6 @@
1015
21
 */
21
 */
1016
22
22
1017
23
#include "mir_toolkit/mir_client_library.h"
23
#include "mir_toolkit/mir_client_library.h"
1018
24
#include "mir_toolkit/mir_client_library_drm.h"
1019
25
#include "mir_toolkit/debug/surface.h"
24
#include "mir_toolkit/debug/surface.h"
1020
26
#include "mir_toolkit/event.h"
25
#include "mir_toolkit/event.h"
1021
27
26
1022
28
27
1023
=== modified file 'tests/integration-tests/CMakeLists.txt'
1024
--- tests/integration-tests/CMakeLists.txt	2015-05-19 21:34:34 +0000
1025
+++ tests/integration-tests/CMakeLists.txt	2015-06-01 09:48:29 +0000
1026
@@ -61,7 +61,6 @@
1027
61
    ${CMAKE_SOURCE_DIR}
61
    ${CMAKE_SOURCE_DIR}
1028
62
  )
62
  )
1029
63
  add_subdirectory(graphics/mesa)
63
  add_subdirectory(graphics/mesa)
1030
64
  list(APPEND INTEGRATION_TESTS_SRCS test_drm_auth_magic.cpp)
1031
65
endif()
64
endif()
1032
66
65
1033
67
link_directories(${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
66
link_directories(${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
1034
68
67
1035
=== removed file 'tests/integration-tests/test_drm_auth_magic.cpp'
1036
--- tests/integration-tests/test_drm_auth_magic.cpp	2015-05-19 21:34:34 +0000
1037
+++ tests/integration-tests/test_drm_auth_magic.cpp	1970-01-01 00:00:00 +0000
1038
@@ -1,152 +0,0 @@
1039
1
/*
1040
2
 * Copyright © 2012 Canonical Ltd.
1041
3
 *
1042
4
 * This program is free software: you can redistribute it and/or modify
1043
5
 * it under the terms of the GNU General Public License version 3 as
1044
6
 * published by the Free Software Foundation.
1045
7
 *
1046
8
 * This program is distributed in the hope that it will be useful,
1047
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1048
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1049
11
 * GNU General Public License for more details.
1050
12
 *
1051
13
 * You should have received a copy of the GNU General Public License
1052
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1053
15
 *
1054
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
1055
17
 */
1056
18
1057
19
#include "mir/graphics/display.h"
1058
20
#include "mir/graphics/platform_ipc_package.h"
1059
21
#include "mir/graphics/buffer_ipc_message.h"
1060
22
#include "mir/graphics/buffer_basic.h"
1061
23
1062
24
#include <boost/exception/errinfo_errno.hpp>
1063
25
#include <boost/throw_exception.hpp>
1064
26
1065
27
#include "mir_test_doubles/stub_buffer_allocator.h"
1066
28
#include "mir_test_doubles/null_platform.h"
1067
29
#include "mir_test_framework/display_server_test_fixture.h"
1068
30
1069
31
#include "mir_toolkit/mir_client_library.h"
1070
32
#include "mir_toolkit/mir_client_library_drm.h"
1071
33
#include "mir_toolkit/mesa/platform_operation.h"
1072
34
1073
35
#include <gmock/gmock.h>
1074
36
#include <gtest/gtest.h>
1075
37
1076
38
#include <cstring>
1077
39
1078
40
namespace mg = mir::graphics;
1079
41
namespace mc = mir::compositor;
1080
42
namespace geom = mir::geometry;
1081
43
namespace mtf = mir_test_framework;
1082
44
namespace mtd = mir::test::doubles;
1083
45
namespace
1084
46
{
1085
47
1086
48
char const* const mir_test_socket = mtf::test_socket_file().c_str();
1087
49
1088
50
struct MockAuthenticatingIpcOps : public mg::PlatformIpcOperations
1089
51
{
1090
52
    MOCK_CONST_METHOD3(pack_buffer, void(mg::BufferIpcMessage&, mg::Buffer const&, mg::BufferIpcMsgType));
1091
53
    MOCK_CONST_METHOD2(unpack_buffer, void(mg::BufferIpcMessage&, mg::Buffer const&));
1092
54
    MOCK_METHOD0(connection_ipc_package, std::shared_ptr<mg::PlatformIPCPackage>());
1093
55
    MOCK_METHOD2(platform_operation, mg::PlatformOperationMessage(
1094
56
        unsigned int const, mg::PlatformOperationMessage const&));
1095
57
};
1096
58
1097
59
class StubAuthenticatingPlatform : public mtd::NullPlatform
1098
60
{
1099
61
public:
1100
62
    StubAuthenticatingPlatform(std::shared_ptr<mg::PlatformIpcOperations> const& ops) :
1101
63
        ops{ops}
1102
64
    {
1103
65
    }
1104
66
1105
67
    std::shared_ptr<mg::GraphicBufferAllocator> create_buffer_allocator() override
1106
68
    {
1107
69
        return std::make_shared<mtd::StubBufferAllocator>();
1108
70
    }
1109
71
    std::shared_ptr<mg::PlatformIpcOperations> make_ipc_operations() const override
1110
72
    {
1111
73
        return ops;
1112
74
    }
1113
75
1114
76
private:
1115
77
    std::shared_ptr<mg::PlatformIpcOperations> const ops;
1116
78
};
1117
79
1118
80
void connection_callback(MirConnection* connection, void* context)
1119
81
{
1120
82
    auto connection_ptr = static_cast<MirConnection**>(context);
1121
83
    *connection_ptr = connection;
1122
84
}
1123
85
1124
86
void drm_auth_magic_callback(int status, void* client_context)
1125
87
{
1126
88
    auto status_ptr = static_cast<int*>(client_context);
1127
89
    *status_ptr = status;
1128
90
}
1129
91
1130
92
}
1131
93
1132
94
#pragma GCC diagnostic warning "-Wdeprecated-declarations"
1133
95
1134
96
TEST_F(BespokeDisplayServerTestFixture, client_drm_auth_magic_calls_platform)
1135
97
{
1136
98
    static unsigned int const magic{0x10111213};
1137
99
    static MirMesaAuthMagicResponse const auth_magic_response{123};
1138
100
1139
101
    struct ServerConfig : TestingServerConfiguration
1140
102
    {
1141
103
        std::shared_ptr<mg::Platform> the_graphics_platform()
1142
104
        {
1143
105
            using namespace testing;
1144
106
            if (!platform)
1145
107
            {
1146
108
                mg::PlatformOperationMessage pkg;
1147
109
                pkg.data.resize(sizeof(auth_magic_response));
1148
110
                std::memcpy(pkg.data.data(), &auth_magic_response,
1149
111
                            sizeof(auth_magic_response));
1150
112
1151
113
                auto ipc_ops = std::make_shared<NiceMock<MockAuthenticatingIpcOps>>();
1152
114
                EXPECT_CALL(*ipc_ops, platform_operation(_,_))
1153
115
                    .Times(1)
1154
116
                    .WillRepeatedly(Return(pkg));
1155
117
                ON_CALL(*ipc_ops, connection_ipc_package())
1156
118
                    .WillByDefault(Return(std::make_shared<mg::PlatformIPCPackage>()));
1157
119
                platform = std::make_shared<StubAuthenticatingPlatform>(ipc_ops);
1158
120
            }
1159
121
1160
122
            return platform;
1161
123
        }
1162
124
1163
125
        std::shared_ptr<StubAuthenticatingPlatform> platform;
1164
126
    } server_config;
1165
127
1166
128
    launch_server_process(server_config);
1167
129
1168
130
    struct Client : TestingClientConfiguration
1169
131
    {
1170
132
        void exec()
1171
133
        {
1172
134
            MirConnection* connection{nullptr};
1173
135
            mir_wait_for(mir_connect(mir_test_socket, __PRETTY_FUNCTION__,
1174
136
                                     connection_callback, &connection));
1175
137
1176
138
            int status{67};
1177
139
1178
140
            ASSERT_TRUE(mir_connection_is_valid(connection));
1179
141
1180
142
            mir_wait_for(mir_connection_drm_auth_magic(connection, magic,
1181
143
                                                       drm_auth_magic_callback,
1182
144
                                                       &status));
1183
145
            EXPECT_EQ(auth_magic_response.status, status);
1184
146
1185
147
            mir_connection_release(connection);
1186
148
        }
1187
149
    } client_config;
1188
150
1189
151
    launch_client_process(client_config);
1190
152
}
Status:	Merged
Approved by:	Alan Griffiths on 2015-06-02
Approved revision:	no longer in the source branch.
Merged at revision:	2610
Proposed branch:	lp:~alan-griffiths/mir/bump-client-ABI
Merge into:	lp:mir
Diff against target:	1190 lines (+87/-807) 17 files modified debian/control (+2/-2) debian/libmirclient9.install (+1/-1) include/client/mir_toolkit/mir_client_library_drm.h (+0/-59) include/client/mir_toolkit/mir_connection.h (+0/-6) include/client/mir_toolkit/mir_screencast.h (+0/-7) include/client/mir_toolkit/mir_surface.h (+0/-107) src/client/CMakeLists.txt (+1/-1) src/client/mir_connection.h (+0/-1) src/client/mir_connection_api.cpp (+1/-175) src/client/mir_screencast_api.cpp (+0/-5) src/client/mir_surface_api.cpp (+1/-114) src/client/symbols-debug.map (+1/-1) src/client/symbols.map (+80/-129) tests/acceptance-tests/test_client_library.cpp (+0/-45) tests/client-language/c99.c (+0/-1) tests/integration-tests/CMakeLists.txt (+0/-1) tests/integration-tests/test_drm_auth_magic.cpp (+0/-152)
To merge this branch:	bzr merge lp:~alan-griffiths/mir/bump-client-ABI
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Alexandros Frantzis (community)			Approve on 2015-06-02
Daniel van Vugt		2015-05-11	Approve on 2015-06-02
PS Jenkins bot (community)	continuous-integration		Approve on 2015-06-01
Review via email: mp+258769@code.launchpad.net