1
=== modified file 'src/client/connection_surface_map.h'
2
--- src/client/connection_surface_map.h	2015-12-15 12:24:10 +0000
3
+++ src/client/connection_surface_map.h	2016-01-13 19:10:37 +0000
4
@@ -40,7 +40,7 @@
5
40
    ~ConnectionSurfaceMap() noexcept;
40
    ~ConnectionSurfaceMap() noexcept;
6
41
41
7
42
    void with_surface_do(frontend::SurfaceId surface_id, std::function<void(MirSurface*)> const& exec) const override;
42
    void with_surface_do(frontend::SurfaceId surface_id, std::function<void(MirSurface*)> const& exec) const override;
9
43
    void insert(frontend::SurfaceId surface_id, MirSurface* surface);
43
    void insert(frontend::SurfaceId surface_id, std::shared_ptr<MirSurface> const& surface);
10
44
    void erase(frontend::SurfaceId surface_id);
44
    void erase(frontend::SurfaceId surface_id);
11
45
45
12
46
    void with_stream_do(frontend::BufferStreamId stream_id, std::function<void(ClientBufferStream*)> const& exec) const override;
46
    void with_stream_do(frontend::BufferStreamId stream_id, std::function<void(ClientBufferStream*)> const& exec) const override;
13
@@ -50,7 +50,7 @@
14
50
50
15
51
private:
51
private:
16
52
    std::shared_timed_mutex mutable guard;
52
    std::shared_timed_mutex mutable guard;
18
53
    std::unordered_map<frontend::SurfaceId, MirSurface*> surfaces;
53
    std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirSurface>> surfaces;
19
54
    std::unordered_map<frontend::BufferStreamId, StreamInfo> streams;
54
    std::unordered_map<frontend::BufferStreamId, StreamInfo> streams;
20
55
};
55
};
21
56
56
22
57
57
23
=== modified file 'src/client/mir_connection.cpp'
24
--- src/client/mir_connection.cpp	2016-01-04 07:26:59 +0000
25
+++ src/client/mir_connection.cpp	2016-01-13 19:10:37 +0000
26
@@ -53,6 +53,76 @@
27
53
53
28
54
namespace
54
namespace
29
55
{
55
{
30
56
mir::protobuf::SurfaceParameters serialize_spec(MirSurfaceSpec const& spec)
31
57
{
32
58
    mp::SurfaceParameters message;
33
59
34
60
#define SERIALIZE_OPTION_IF_SET(option) \
35
61
    if (spec.option.is_set()) \
36
62
        message.set_##option(spec.option.value());
37
63
38
64
    SERIALIZE_OPTION_IF_SET(width);
39
65
    SERIALIZE_OPTION_IF_SET(height);
40
66
    SERIALIZE_OPTION_IF_SET(pixel_format);
41
67
    SERIALIZE_OPTION_IF_SET(buffer_usage);
42
68
    SERIALIZE_OPTION_IF_SET(surface_name);
43
69
    SERIALIZE_OPTION_IF_SET(output_id);
44
70
    SERIALIZE_OPTION_IF_SET(type);
45
71
    SERIALIZE_OPTION_IF_SET(state);
46
72
    SERIALIZE_OPTION_IF_SET(pref_orientation);
47
73
    SERIALIZE_OPTION_IF_SET(edge_attachment);
48
74
    SERIALIZE_OPTION_IF_SET(min_width);
49
75
    SERIALIZE_OPTION_IF_SET(min_height);
50
76
    SERIALIZE_OPTION_IF_SET(max_width);
51
77
    SERIALIZE_OPTION_IF_SET(max_height);
52
78
    SERIALIZE_OPTION_IF_SET(width_inc);
53
79
    SERIALIZE_OPTION_IF_SET(height_inc);
54
80
    // min_aspect is a special case (below)
55
81
    // max_aspect is a special case (below)
56
82
57
83
    if (spec.parent.is_set() && spec.parent.value() != nullptr)
58
84
        message.set_parent_id(spec.parent.value()->id());
59
85
60
86
    if (spec.parent_id)
61
87
    {
62
88
        auto id = message.mutable_parent_persistent_id();
63
89
        id->set_value(spec.parent_id->as_string());
64
90
    }
65
91
66
92
    if (spec.aux_rect.is_set())
67
93
    {
68
94
        message.mutable_aux_rect()->set_left(spec.aux_rect.value().left);
69
95
        message.mutable_aux_rect()->set_top(spec.aux_rect.value().top);
70
96
        message.mutable_aux_rect()->set_width(spec.aux_rect.value().width);
71
97
        message.mutable_aux_rect()->set_height(spec.aux_rect.value().height);
72
98
    }
73
99
74
100
    if (spec.min_aspect.is_set())
75
101
    {
76
102
        message.mutable_min_aspect()->set_width(spec.min_aspect.value().width);
77
103
        message.mutable_min_aspect()->set_height(spec.min_aspect.value().height);
78
104
    }
79
105
80
106
    if (spec.max_aspect.is_set())
81
107
    {
82
108
        message.mutable_max_aspect()->set_width(spec.max_aspect.value().width);
83
109
        message.mutable_max_aspect()->set_height(spec.max_aspect.value().height);
84
110
    }
85
111
86
112
    if (spec.input_shape.is_set())
87
113
    {
88
114
        for (auto const& rect : spec.input_shape.value())
89
115
        {
90
116
            auto const new_shape = message.add_input_shape();
91
117
            new_shape->set_left(rect.left);
92
118
            new_shape->set_top(rect.top);
93
119
            new_shape->set_width(rect.width);
94
120
            new_shape->set_height(rect.height);
95
121
        }
96
122
    }
97
123
98
124
    return message;
99
125
}
100
56
126
101
57
class MirDisplayConfigurationStore
127
class MirDisplayConfigurationStore
102
58
{
128
{
103
@@ -175,10 +245,106 @@
104
175
    mir_surface_callback callback,
245
    mir_surface_callback callback,
105
176
    void * context)
246
    void * context)
106
177
{
247
{
111
178
    auto surface = new MirSurface(this, server, &debug, buffer_stream_factory,
248
    auto response = std::make_shared<mp::Surface>();
112
179
        input_platform, spec, callback, context);
249
    auto c = std::make_shared<MirConnection::SurfaceCreationRequest>(callback, context, spec);
113
180
250
    c->wh->expect_result();
114
181
    return surface->get_create_wait_handle();
251
    auto const message = serialize_spec(spec);
115
252
    {
116
253
        std::lock_guard<decltype(mutex)> lock(mutex);
117
254
        surface_requests.emplace_back(c);
118
255
    }
119
256
120
257
    try 
121
258
    {
122
259
        server.create_surface(&message, c->response.get(),
123
260
            gp::NewCallback(this, &MirConnection::surface_created, c.get()));
124
261
    }
125
262
    catch (std::exception const& ex)
126
263
    {
127
264
        std::unique_lock<decltype(mutex)> lock(mutex);
128
265
        auto request = std::find_if(surface_requests.begin(), surface_requests.end(),
129
266
            [&](std::shared_ptr<MirConnection::SurfaceCreationRequest> c2) { return c.get() == c2.get(); });
130
267
        if (request != surface_requests.end())
131
268
        {
132
269
            auto id = next_error_id(lock);
133
270
            auto surf = std::make_shared<MirSurface>(
134
271
                std::string{"Error creating surface: "} + boost::diagnostic_information(ex), this, id, (*request)->wh);
135
272
            surface_map->insert(id, surf);
136
273
            auto wh = (*request)->wh;
137
274
            surface_requests.erase(request);
138
275
139
276
            lock.unlock();
140
277
            callback(surf.get(), context);
141
278
            wh->result_received();
142
279
        }
143
280
    }
144
281
    return c->wh.get();
145
282
}
146
283
147
284
mf::SurfaceId MirConnection::next_error_id(std::unique_lock<std::mutex> const&)
148
285
{
149
286
    return mf::SurfaceId{surface_error_id--};
150
287
}
151
288
152
289
void MirConnection::surface_created(SurfaceCreationRequest* request)
153
290
{
154
291
    std::unique_lock<decltype(mutex)> lock(mutex);
155
292
    std::shared_ptr<MirSurface> surf {nullptr};
156
293
    std::shared_ptr<mcl::ClientBufferStream> stream {nullptr};
157
294
    //make sure this request actually was made.
158
295
    auto request_it = std::find_if(surface_requests.begin(), surface_requests.end(),
159
296
        [&request](std::shared_ptr<MirConnection::SurfaceCreationRequest> r){ return request == r.get(); });
160
297
    if (request_it == surface_requests.end())
161
298
        return;
162
299
163
300
    auto surface_proto = request->response; 
164
301
    auto callback = request->cb;
165
302
    auto context = request->context;
166
303
    auto const& spec = request->spec;
167
304
168
305
    try
169
306
    {
170
307
        stream = buffer_stream_factory->make_producer_stream(
171
308
            this, server, surface_proto->buffer_stream(), std::string{},
172
309
            {surface_proto->width(), surface_proto->height()});
173
310
    }
174
311
    catch (std::exception const& error)
175
312
    {
176
313
        if (!surface_proto->has_error())
177
314
            surface_proto->set_error(error.what());
178
315
        // failed to create buffer_stream, so clean up FDs it doesn't own
179
316
        for (auto i = 0; i < surface_proto->fd_size(); i++)
180
317
            ::close(surface_proto->fd(i));
181
318
        if (surface_proto->has_buffer_stream() && surface_proto->buffer_stream().has_buffer())
182
319
            for (int i = 0; i < surface_proto->buffer_stream().buffer().fd_size(); i++)
183
320
                ::close(surface_proto->buffer_stream().buffer().fd(i));
184
321
    }
185
322
186
323
    if (surface_proto->has_error() || !surface_proto->has_id())
187
324
    {
188
325
        std::string reason;
189
326
        if (surface_proto->has_error())
190
327
            reason += surface_proto->error();
191
328
        if (surface_proto->has_error() && !surface_proto->has_id())
192
329
            reason += " and ";
193
330
        if (!surface_proto->has_id()) 
194
331
            reason +=  "Server assigned surface no id";
195
332
        auto id = next_error_id(lock);
196
333
        surf = std::make_shared<MirSurface>(reason, this, id, request->wh);
197
334
        surface_map->insert(id, surf);
198
335
    }
199
336
    else
200
337
    {
201
338
        surf = std::make_shared<MirSurface>(
202
339
            this, server, &debug, stream, input_platform, spec, *surface_proto, request->wh);
203
340
204
341
        surface_map->insert(mf::SurfaceId{surface_proto->id().value()}, surf);
205
342
    }
206
343
207
344
    callback(surf.get(), context);
208
345
    request->wh->result_received();
209
346
210
347
    surface_requests.erase(request_it);
211
182
}
348
}
212
183
349
213
184
char const * MirConnection::get_error_message()
350
char const * MirConnection::get_error_message()
214
@@ -228,9 +394,7 @@
215
228
394
216
229
void MirConnection::released(SurfaceRelease data)
395
void MirConnection::released(SurfaceRelease data)
217
230
{
396
{
221
231
    surface_map->erase(mf::SurfaceId(data.surface->id()));
397
    // releasing this surface from surface_map means that it will no longer receive events
219
232
220
233
    // Erasing this surface from surface_map means that it will no longer receive events
222
234
    // If it's still focused, send an unfocused event before we kill it entirely
398
    // If it's still focused, send an unfocused event before we kill it entirely
223
235
    if (data.surface->attrib(mir_surface_attrib_focus) == mir_surface_focused)
399
    if (data.surface->attrib(mir_surface_attrib_focus) == mir_surface_focused)
224
236
    {
400
    {
225
@@ -239,7 +403,7 @@
226
239
    }
403
    }
227
240
    data.callback(data.surface, data.context);
404
    data.callback(data.surface, data.context);
228
241
    data.handle->result_received();
405
    data.handle->result_received();
230
242
    delete data.surface;
406
    surface_map->erase(mf::SurfaceId(data.surface->id()));
231
243
}
407
}
232
244
408
233
245
MirWaitHandle* MirConnection::release_surface(
409
MirWaitHandle* MirConnection::release_surface(
234
@@ -248,17 +412,26 @@
235
248
        void * context)
412
        void * context)
236
249
{
413
{
237
250
    auto new_wait_handle = new MirWaitHandle;
414
    auto new_wait_handle = new MirWaitHandle;
238
415
    {
239
416
        std::lock_guard<decltype(release_wait_handle_guard)> rel_lock(release_wait_handle_guard);
240
417
        release_wait_handles.push_back(new_wait_handle);
241
418
    }
242
419
243
420
    if (!mir_surface_is_valid(surface))
244
421
    {
245
422
        new_wait_handle->expect_result();
246
423
        new_wait_handle->result_received();
247
424
        callback(surface, context);
248
425
        auto id = surface->id();
249
426
        surface_map->erase(mf::SurfaceId(id));
250
427
        return new_wait_handle;    
251
428
    }
252
251
429
253
252
    SurfaceRelease surf_release{surface, new_wait_handle, callback, context};
430
    SurfaceRelease surf_release{surface, new_wait_handle, callback, context};
254
253
431
255
254
    mp::SurfaceId message;
432
    mp::SurfaceId message;
256
255
    message.set_value(surface->id());
433
    message.set_value(surface->id());
257
256
434
258
257
    {
259
258
        std::lock_guard<decltype(release_wait_handle_guard)> rel_lock(release_wait_handle_guard);
260
259
        release_wait_handles.push_back(new_wait_handle);
261
260
    }
262
261
263
262
    new_wait_handle->expect_result();
435
    new_wait_handle->expect_result();
264
263
    server.release_surface(&message, void_response.get(),
436
    server.release_surface(&message, void_response.get(),
265
264
                           gp::NewCallback(this, &MirConnection::released, surf_release));
437
                           gp::NewCallback(this, &MirConnection::released, surf_release));
266
@@ -537,11 +710,6 @@
267
537
    surface_map->insert(mf::BufferStreamId(id), stream);
710
    surface_map->insert(mf::BufferStreamId(id), stream);
268
538
}
711
}
269
539
712
270
540
void MirConnection::on_surface_created(int id, MirSurface* surface)
271
541
{
272
542
    surface_map->insert(mf::SurfaceId(id), surface);
273
543
}
274
544
275
545
void MirConnection::register_lifecycle_event_callback(mir_lifecycle_event_callback callback, void* context)
713
void MirConnection::register_lifecycle_event_callback(mir_lifecycle_event_callback callback, void* context)
276
546
{
714
{
277
547
    lifecycle_control->set_callback(std::bind(callback, this, std::placeholders::_1, context));
715
    lifecycle_control->set_callback(std::bind(callback, this, std::placeholders::_1, context));
278
548
716
279
=== modified file 'src/client/mir_connection.h'
280
--- src/client/mir_connection.h	2016-01-04 21:41:00 +0000
281
+++ src/client/mir_connection.h	2016-01-13 19:10:37 +0000
282
@@ -26,8 +26,10 @@
283
26
26
284
27
#include "mir/geometry/size.h"
27
#include "mir/geometry/size.h"
285
28
#include "mir/client_platform.h"
28
#include "mir/client_platform.h"
286
29
#include "mir/frontend/surface_id.h"
287
29
#include "mir/client_context.h"
30
#include "mir/client_context.h"
288
30
#include "mir_toolkit/mir_client_library.h"
31
#include "mir_toolkit/mir_client_library.h"
289
32
#include "mir_surface.h"
290
31
33
291
32
#include <atomic>
34
#include <atomic>
292
33
#include <memory>
35
#include <memory>
293
@@ -100,9 +102,9 @@
294
100
        mir_surface_callback callback,
102
        mir_surface_callback callback,
295
101
        void * context);
103
        void * context);
296
102
    MirWaitHandle* release_surface(
104
    MirWaitHandle* release_surface(
300
103
            MirSurface *surface,
105
        MirSurface *surface,
301
104
            mir_surface_callback callback,
106
        mir_surface_callback callback,
302
105
            void *context);
107
        void *context);
303
106
108
304
107
    MirPromptSession* create_prompt_session();
109
    MirPromptSession* create_prompt_session();
305
108
110
306
@@ -152,7 +154,6 @@
307
152
    EGLNativeDisplayType egl_native_display();
154
    EGLNativeDisplayType egl_native_display();
308
153
    MirPixelFormat       egl_pixel_format(EGLDisplay, EGLConfig) const;
155
    MirPixelFormat       egl_pixel_format(EGLDisplay, EGLConfig) const;
309
154
156
310
155
    void on_surface_created(int id, MirSurface* surface);
311
156
    void on_stream_created(int id, mir::client::ClientBufferStream* stream);
157
    void on_stream_created(int id, mir::client::ClientBufferStream* stream);
312
157
158
313
158
    MirWaitHandle* configure_display(MirDisplayConfiguration* configuration);
159
    MirWaitHandle* configure_display(MirDisplayConfiguration* configuration);
314
@@ -167,9 +168,28 @@
315
167
    }
168
    }
316
168
169
317
169
    mir::client::rpc::DisplayServer& display_server();
170
    mir::client::rpc::DisplayServer& display_server();
318
171
    mir::client::rpc::DisplayServerDebug& debug_display_server();
319
170
    std::shared_ptr<mir::logging::Logger> const& the_logger() const;
172
    std::shared_ptr<mir::logging::Logger> const& the_logger() const;
320
171
173
321
172
private:
174
private:
322
175
    //google cant have callbacks with more than 2 args
323
176
    struct SurfaceCreationRequest
324
177
    {
325
178
        SurfaceCreationRequest(mir_surface_callback cb, void* context,  MirSurfaceSpec const& spec) :
326
179
            cb(cb), context(context), spec(spec),
327
180
            response(std::make_shared<mir::protobuf::Surface>()),
328
181
            wh(std::make_shared<MirWaitHandle>())
329
182
        {
330
183
        }
331
184
        mir_surface_callback cb;
332
185
        void* context;
333
186
        MirSurfaceSpec const spec;
334
187
        std::shared_ptr<mir::protobuf::Surface> response;
335
188
        std::shared_ptr<MirWaitHandle> wh;
336
189
    };
337
190
    std::vector<std::shared_ptr<SurfaceCreationRequest>> surface_requests;
338
191
    void surface_created(SurfaceCreationRequest*);
339
192
340
173
    void populate_server_package(MirPlatformPackage& platform_package) override;
193
    void populate_server_package(MirPlatformPackage& platform_package) override;
341
174
    // MUST be first data member so it is destroyed last.
194
    // MUST be first data member so it is destroyed last.
342
175
    struct Deregisterer
195
    struct Deregisterer
343
@@ -191,6 +211,9 @@
344
191
    std::unique_ptr<mir::protobuf::Void> set_base_display_configuration_response;
211
    std::unique_ptr<mir::protobuf::Void> set_base_display_configuration_response;
345
192
    std::atomic<bool> disconnecting{false};
212
    std::atomic<bool> disconnecting{false};
346
193
213
347
214
    mir::frontend::SurfaceId next_error_id(std::unique_lock<std::mutex> const&);
348
215
    int surface_error_id{-1};
349
216
350
194
    std::shared_ptr<mir::client::ClientPlatformFactory> const client_platform_factory;
217
    std::shared_ptr<mir::client::ClientPlatformFactory> const client_platform_factory;
351
195
    std::shared_ptr<mir::client::ClientPlatform> platform;
218
    std::shared_ptr<mir::client::ClientPlatform> platform;
352
196
    std::shared_ptr<EGLNativeDisplayType> native_display;
219
    std::shared_ptr<EGLNativeDisplayType> native_display;
353
197
220
354
=== modified file 'src/client/mir_surface.cpp'
355
--- src/client/mir_surface.cpp	2015-12-17 15:58:42 +0000
356
+++ src/client/mir_surface.cpp	2016-01-13 19:10:37 +0000
357
@@ -49,77 +49,6 @@
358
49
{
49
{
359
50
std::mutex handle_mutex;
50
std::mutex handle_mutex;
360
51
std::unordered_set<MirSurface*> valid_surfaces;
51
std::unordered_set<MirSurface*> valid_surfaces;
361
52
362
53
mir::protobuf::SurfaceParameters serialize_spec(MirSurfaceSpec const& spec)
363
54
{
364
55
    mp::SurfaceParameters message;
365
56
366
57
#define SERIALIZE_OPTION_IF_SET(option) \
367
58
    if (spec.option.is_set()) \
368
59
        message.set_##option(spec.option.value());
369
60
370
61
    SERIALIZE_OPTION_IF_SET(width);
371
62
    SERIALIZE_OPTION_IF_SET(height);
372
63
    SERIALIZE_OPTION_IF_SET(pixel_format);
373
64
    SERIALIZE_OPTION_IF_SET(buffer_usage);
374
65
    SERIALIZE_OPTION_IF_SET(surface_name);
375
66
    SERIALIZE_OPTION_IF_SET(output_id);
376
67
    SERIALIZE_OPTION_IF_SET(type);
377
68
    SERIALIZE_OPTION_IF_SET(state);
378
69
    SERIALIZE_OPTION_IF_SET(pref_orientation);
379
70
    SERIALIZE_OPTION_IF_SET(edge_attachment);
380
71
    SERIALIZE_OPTION_IF_SET(min_width);
381
72
    SERIALIZE_OPTION_IF_SET(min_height);
382
73
    SERIALIZE_OPTION_IF_SET(max_width);
383
74
    SERIALIZE_OPTION_IF_SET(max_height);
384
75
    SERIALIZE_OPTION_IF_SET(width_inc);
385
76
    SERIALIZE_OPTION_IF_SET(height_inc);
386
77
    // min_aspect is a special case (below)
387
78
    // max_aspect is a special case (below)
388
79
389
80
    if (spec.parent.is_set() && spec.parent.value() != nullptr)
390
81
        message.set_parent_id(spec.parent.value()->id());
391
82
392
83
    if (spec.parent_id)
393
84
    {
394
85
        auto id = message.mutable_parent_persistent_id();
395
86
        id->set_value(spec.parent_id->as_string());
396
87
    }
397
88
398
89
    if (spec.aux_rect.is_set())
399
90
    {
400
91
        message.mutable_aux_rect()->set_left(spec.aux_rect.value().left);
401
92
        message.mutable_aux_rect()->set_top(spec.aux_rect.value().top);
402
93
        message.mutable_aux_rect()->set_width(spec.aux_rect.value().width);
403
94
        message.mutable_aux_rect()->set_height(spec.aux_rect.value().height);
404
95
    }
405
96
406
97
    if (spec.min_aspect.is_set())
407
98
    {
408
99
        message.mutable_min_aspect()->set_width(spec.min_aspect.value().width);
409
100
        message.mutable_min_aspect()->set_height(spec.min_aspect.value().height);
410
101
    }
411
102
412
103
    if (spec.max_aspect.is_set())
413
104
    {
414
105
        message.mutable_max_aspect()->set_width(spec.max_aspect.value().width);
415
106
        message.mutable_max_aspect()->set_height(spec.max_aspect.value().height);
416
107
    }
417
108
418
109
    if (spec.input_shape.is_set())
419
110
    {
420
111
        for (auto const& rect : spec.input_shape.value())
421
112
        {
422
113
            auto const new_shape = message.add_input_shape();
423
114
            new_shape->set_left(rect.left);
424
115
            new_shape->set_top(rect.top);
425
116
            new_shape->set_width(rect.width);
426
117
            new_shape->set_height(rect.height);
427
118
        }
428
119
    }
429
120
430
121
    return message;
431
122
}
432
123
}
52
}
433
124
53
434
125
MirSurfaceSpec::MirSurfaceSpec(
54
MirSurfaceSpec::MirSurfaceSpec(
435
@@ -159,10 +88,17 @@
436
159
    return string_id;
88
    return string_id;
437
160
}
89
}
438
161
90
441
162
MirSurface::MirSurface(std::string const& error)
91
MirSurface::MirSurface(
442
163
    : surface{mcl::make_protobuf_object<mir::protobuf::Surface>()}
92
    std::string const& error,
443
93
    MirConnection* conn,
444
94
    mir::frontend::SurfaceId id,
445
95
    std::shared_ptr<MirWaitHandle> const& handle) :
446
96
    surface{mcl::make_protobuf_object<mir::protobuf::Surface>()},
447
97
    connection_(conn),
448
98
    creation_handle(handle)
449
164
{
99
{
450
165
    surface->set_error(error);
100
    surface->set_error(error);
451
101
    surface->mutable_id()->set_value(id.as_value());
452
166
102
453
167
    std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
103
    std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
454
168
    valid_surfaces.insert(this);
104
    valid_surfaces.insert(this);
455
@@ -172,25 +108,30 @@
456
172
    MirConnection *allocating_connection,
108
    MirConnection *allocating_connection,
457
173
    mclr::DisplayServer& the_server,
109
    mclr::DisplayServer& the_server,
458
174
    mclr::DisplayServerDebug* debug,
110
    mclr::DisplayServerDebug* debug,
460
175
    std::shared_ptr<mcl::ClientBufferStreamFactory> const& buffer_stream_factory,
111
    std::shared_ptr<mcl::ClientBufferStream> const& buffer_stream,
461
176
    std::shared_ptr<mircv::InputPlatform> const& input_platform,
112
    std::shared_ptr<mircv::InputPlatform> const& input_platform,
462
177
    MirSurfaceSpec const& spec,
113
    MirSurfaceSpec const& spec,
464
178
    mir_surface_callback callback, void * context)
114
    mir::protobuf::Surface const& surface_proto,
465
115
    std::shared_ptr<MirWaitHandle> const& handle)
466
179
    : server{&the_server},
116
    : server{&the_server},
467
180
      debug{debug},
117
      debug{debug},
469
181
      surface{mcl::make_protobuf_object<mir::protobuf::Surface>()},
118
      surface{mcl::make_protobuf_object<mir::protobuf::Surface>(surface_proto)},
470
182
      persistent_id{mcl::make_protobuf_object<mir::protobuf::PersistentSurfaceId>()},
119
      persistent_id{mcl::make_protobuf_object<mir::protobuf::PersistentSurfaceId>()},
471
183
      name{spec.surface_name.is_set() ? spec.surface_name.value() : ""},
120
      name{spec.surface_name.is_set() ? spec.surface_name.value() : ""},
472
184
      void_response{mcl::make_protobuf_object<mir::protobuf::Void>()},
121
      void_response{mcl::make_protobuf_object<mir::protobuf::Void>()},
473
185
      modify_result{mcl::make_protobuf_object<mir::protobuf::Void>()},
122
      modify_result{mcl::make_protobuf_object<mir::protobuf::Void>()},
476
186
      connection(allocating_connection),
123
      connection_(allocating_connection),
477
187
      buffer_stream_factory(buffer_stream_factory),
124
      buffer_stream(buffer_stream),
478
188
      input_platform(input_platform),
125
      input_platform(input_platform),
479
189
      keymapper(std::make_shared<mircv::XKBMapper>()),
126
      keymapper(std::make_shared<mircv::XKBMapper>()),
481
190
      configure_result{mcl::make_protobuf_object<mir::protobuf::SurfaceSetting>()}
127
      configure_result{mcl::make_protobuf_object<mir::protobuf::SurfaceSetting>()},
482
128
      creation_handle(handle)
483
191
{
129
{
486
192
    for (int i = 0; i < mir_surface_attribs; i++)
130
    for(int i = 0; i < surface_proto.attributes_size(); i++)
487
193
        attrib_cache[i] = -1;
131
    {
488
132
        auto const& attrib = surface_proto.attributes(i);
489
133
        attrib_cache[attrib.attrib()] = attrib.ivalue();
490
134
    }
491
194
135
492
195
    if (spec.event_handler.is_set())
136
    if (spec.event_handler.is_set())
493
196
    {
137
    {
494
@@ -201,16 +142,10 @@
495
201
            spec.event_handler.value().context);
142
            spec.event_handler.value().context);
496
202
    }
143
    }
497
203
144
508
204
    auto const message = serialize_spec(spec);
145
    if (surface_proto.fd_size() > 0 && handle_event_callback)
509
205
    create_wait_handle.expect_result();
146
    {
510
206
    try 
147
        input_thread = std::make_shared<md::ThreadedDispatcher>("Input dispatch", 
511
207
    {
148
            input_platform->create_input_receiver( surface_proto.fd(0), keymapper, handle_event_callback));
502
208
        server->create_surface(&message, surface.get(), gp::NewCallback(this, &MirSurface::created, callback, context));
503
209
    }
504
210
    catch (std::exception const& ex)
505
211
    {
506
212
        surface->set_error(std::string{"Error invoking create surface: "} +
507
213
                          boost::diagnostic_information(ex));
512
214
    }
149
    }
513
215
150
514
216
    std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
151
    std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
515
@@ -303,11 +238,6 @@
516
303
    return &persistent_id_wait_handle;
238
    return &persistent_id_wait_handle;
517
304
}
239
}
518
305
240
519
306
MirWaitHandle* MirSurface::get_create_wait_handle()
520
307
{
521
308
    return &create_wait_handle;
522
309
}
523
310
524
311
/* todo: all these conversion functions are a bit of a kludge, probably
241
/* todo: all these conversion functions are a bit of a kludge, probably
525
312
         better to have a more developed MirPixelFormat that can handle this */
242
         better to have a more developed MirPixelFormat that can handle this */
526
313
MirPixelFormat MirSurface::convert_ipc_pf_to_geometry(gp::int32 pf) const
243
MirPixelFormat MirSurface::convert_ipc_pf_to_geometry(gp::int32 pf) const
527
@@ -315,89 +245,6 @@
528
315
    return static_cast<MirPixelFormat>(pf);
245
    return static_cast<MirPixelFormat>(pf);
529
316
}
246
}
530
317
247
531
318
void MirSurface::created(mir_surface_callback callback, void * context)
532
319
{
533
320
    {
534
321
    std::lock_guard<decltype(mutex)> lock(mutex);
535
322
    if (!surface->has_id())
536
323
    {
537
324
        if (!surface->has_error())
538
325
            surface->set_error("Error processing surface create response, no ID (disconnected?)");
539
326
540
327
        callback(this, context);
541
328
        create_wait_handle.result_received();
542
329
        return;
543
330
    }
544
331
    }
545
332
    try
546
333
    {
547
334
        {
548
335
            geom::Size size{surface->width(), surface->height()};
549
336
            auto stream = buffer_stream_factory->
550
337
                make_producer_stream(connection, *server, surface->buffer_stream(), name, size);
551
338
552
339
            std::lock_guard<decltype(mutex)> lock(mutex);
553
340
            buffer_stream = std::move(stream);
554
341
            for(int i = 0; i < surface->attributes_size(); i++)
555
342
            {
556
343
                auto const& attrib = surface->attributes(i);
557
344
                attrib_cache[attrib.attrib()] = attrib.ivalue();
558
345
            }
559
346
        }
560
347
561
348
        connection->on_surface_created(id(), this);
562
349
    }
563
350
    catch (std::exception const& error)
564
351
    {
565
352
        // failed to create buffer_stream, so clean up FDs it doesn't own
566
353
        if (!buffer_stream)
567
354
            for (int i = 0; i < surface->buffer_stream().buffer().fd_size(); i++)
568
355
                ::close(surface->buffer_stream().buffer().fd(i));
569
356
570
357
        surface->set_error(std::string{"Error processing Surface creating response:"} +
571
358
                          boost::diagnostic_information(error));
572
359
    }
573
360
574
361
    if (surface->fd_size() > 0 && handle_event_callback)
575
362
    {
576
363
        auto input_dispatcher = input_platform->create_input_receiver(surface->fd(0),
577
364
                                                                      keymapper,
578
365
                                                                      handle_event_callback);
579
366
        input_thread = std::make_shared<md::ThreadedDispatcher>("Input dispatch", input_dispatcher);
580
367
    }
581
368
582
369
    callback(this, context);
583
370
    create_wait_handle.result_received();
584
371
}
585
372
586
373
MirWaitHandle* MirSurface::release_surface(
587
374
        mir_surface_callback callback,
588
375
        void * context)
589
376
{
590
377
    bool was_valid = false;
591
378
    {
592
379
        std::lock_guard<decltype(handle_mutex)> lock(handle_mutex);
593
380
        if (valid_surfaces.count(this))
594
381
            was_valid = true;
595
382
        valid_surfaces.erase(this);
596
383
    }
597
384
    if (this->surface->has_error())
598
385
        was_valid = false;
599
386
600
387
    MirWaitHandle* wait_handle{nullptr};
601
388
    if (connection && was_valid)
602
389
    {
603
390
        wait_handle = connection->release_surface(this, callback, context);
604
391
    }
605
392
    else
606
393
    {
607
394
        callback(this, context);
608
395
        delete this;
609
396
    }
610
397
611
398
    return wait_handle;
612
399
}
613
400
614
401
MirWaitHandle* MirSurface::configure_cursor(MirCursorConfiguration const* cursor)
248
MirWaitHandle* MirSurface::configure_cursor(MirCursorConfiguration const* cursor)
615
402
{
249
{
616
403
    mp::CursorSetting setting;
250
    mp::CursorSetting setting;
617
@@ -779,3 +626,8 @@
618
779
626
619
780
    return &modify_wait_handle;
627
    return &modify_wait_handle;
620
781
}
628
}
621
629
622
630
MirConnection* MirSurface::connection() const
623
631
{
624
632
    return connection_;
625
633
}
626
782
634
627
=== modified file 'src/client/mir_surface.h'
628
--- src/client/mir_surface.h	2015-12-17 15:51:08 +0000
629
+++ src/client/mir_surface.h	2016-01-13 19:10:37 +0000
630
@@ -25,6 +25,7 @@
631
25
#include "rpc/mir_display_server_debug.h"
25
#include "rpc/mir_display_server_debug.h"
632
26
26
633
27
#include "mir/client_platform.h"
27
#include "mir/client_platform.h"
634
28
#include "mir/frontend/surface_id.h"
635
28
#include "mir/optional_value.h"
29
#include "mir/optional_value.h"
636
29
#include "mir/geometry/dimensions.h"
30
#include "mir/geometry/dimensions.h"
637
30
#include "mir_toolkit/common.h"
31
#include "mir_toolkit/common.h"
638
@@ -100,7 +101,7 @@
639
100
    mir::optional_value<MirOrientationMode> pref_orientation;
101
    mir::optional_value<MirOrientationMode> pref_orientation;
640
101
102
641
102
    mir::optional_value<MirSurface*> parent;
103
    mir::optional_value<MirSurface*> parent;
643
103
    std::unique_ptr<MirPersistentId> parent_id;
104
    std::shared_ptr<MirPersistentId> parent_id;
644
104
    mir::optional_value<MirRectangle> aux_rect;
105
    mir::optional_value<MirRectangle> aux_rect;
645
105
    mir::optional_value<MirEdgeAttachment> edge_attachment;
106
    mir::optional_value<MirEdgeAttachment> edge_attachment;
646
106
107
647
@@ -140,28 +141,27 @@
648
140
    MirSurface(MirSurface const &) = delete;
141
    MirSurface(MirSurface const &) = delete;
649
141
    MirSurface& operator=(MirSurface const &) = delete;
142
    MirSurface& operator=(MirSurface const &) = delete;
650
142
143
652
143
    MirSurface(std::string const& error);
144
    MirSurface(
653
145
        std::string const& error,
654
146
        MirConnection *allocating_connection,
655
147
        mir::frontend::SurfaceId surface_id,
656
148
        std::shared_ptr<MirWaitHandle> const& handle);
657
144
149
658
145
    MirSurface(
150
    MirSurface(
659
146
        MirConnection *allocating_connection,
151
        MirConnection *allocating_connection,
660
147
        mir::client::rpc::DisplayServer& server,
152
        mir::client::rpc::DisplayServer& server,
661
148
        mir::client::rpc::DisplayServerDebug* debug,
153
        mir::client::rpc::DisplayServerDebug* debug,
663
149
        std::shared_ptr<mir::client::ClientBufferStreamFactory> const& buffer_stream_factory,
154
        std::shared_ptr<mir::client::ClientBufferStream> const& buffer_stream,
664
150
        std::shared_ptr<mir::input::receiver::InputPlatform> const& input_platform,
155
        std::shared_ptr<mir::input::receiver::InputPlatform> const& input_platform,
667
151
        MirSurfaceSpec const& spec,
156
        MirSurfaceSpec const& spec, mir::protobuf::Surface const& surface_proto,
668
152
        mir_surface_callback callback, void * context);
157
        std::shared_ptr<MirWaitHandle> const& handle);
669
153
158
670
154
    ~MirSurface();
159
    ~MirSurface();
671
155
160
672
156
    MirWaitHandle* release_surface(
673
157
        mir_surface_callback callback,
674
158
        void *context);
675
159
676
160
    MirSurfaceParameters get_parameters() const;
161
    MirSurfaceParameters get_parameters() const;
677
161
    char const * get_error_message();
162
    char const * get_error_message();
678
162
    int id() const;
163
    int id() const;
679
163
164
680
164
    MirWaitHandle* get_create_wait_handle();
681
165
    MirWaitHandle* configure(MirSurfaceAttrib a, int value);
165
    MirWaitHandle* configure(MirSurfaceAttrib a, int value);
682
166
166
683
167
    // TODO: Some sort of extension mechanism so that this can be moved
167
    // TODO: Some sort of extension mechanism so that this can be moved
684
@@ -192,12 +192,12 @@
685
192
    static bool is_valid(MirSurface* query);
192
    static bool is_valid(MirSurface* query);
686
193
193
687
194
    MirWaitHandle* request_persistent_id(mir_surface_id_callback callback, void* context);
194
    MirWaitHandle* request_persistent_id(mir_surface_id_callback callback, void* context);
688
195
    MirConnection* connection() const;
689
195
private:
196
private:
690
196
    std::mutex mutable mutex; // Protects all members of *this
197
    std::mutex mutable mutex; // Protects all members of *this
691
197
198
692
198
    void on_configured();
199
    void on_configured();
693
199
    void on_cursor_configured();
200
    void on_cursor_configured();
694
200
    void created(mir_surface_callback callback, void* context);
695
201
    void acquired_persistent_id(mir_surface_id_callback callback, void* context);
201
    void acquired_persistent_id(mir_surface_id_callback callback, void* context);
696
202
    MirPixelFormat convert_ipc_pf_to_geometry(google::protobuf::int32 pf) const;
202
    MirPixelFormat convert_ipc_pf_to_geometry(google::protobuf::int32 pf) const;
697
203
203
698
@@ -213,14 +213,12 @@
699
213
    MirWaitHandle modify_wait_handle;
213
    MirWaitHandle modify_wait_handle;
700
214
    std::unique_ptr<mir::protobuf::Void> const modify_result;
214
    std::unique_ptr<mir::protobuf::Void> const modify_result;
701
215
215
703
216
    MirConnection* const connection{nullptr};
216
    MirConnection* const connection_;
704
217
217
705
218
    MirWaitHandle create_wait_handle;
706
219
    MirWaitHandle configure_wait_handle;
218
    MirWaitHandle configure_wait_handle;
707
220
    MirWaitHandle configure_cursor_wait_handle;
219
    MirWaitHandle configure_cursor_wait_handle;
708
221
    MirWaitHandle persistent_id_wait_handle;
220
    MirWaitHandle persistent_id_wait_handle;
709
222
221
710
223
    std::shared_ptr<mir::client::ClientBufferStreamFactory> const buffer_stream_factory;
711
224
    std::shared_ptr<mir::client::ClientBufferStream> buffer_stream;
222
    std::shared_ptr<mir::client::ClientBufferStream> buffer_stream;
712
225
    std::shared_ptr<mir::input::receiver::InputPlatform> const input_platform;
223
    std::shared_ptr<mir::input::receiver::InputPlatform> const input_platform;
713
226
    std::shared_ptr<mir::input::receiver::XKBMapper> const keymapper;
224
    std::shared_ptr<mir::input::receiver::XKBMapper> const keymapper;
714
@@ -234,6 +232,10 @@
715
234
    std::function<void(MirEvent const*)> handle_event_callback;
232
    std::function<void(MirEvent const*)> handle_event_callback;
716
235
    std::shared_ptr<mir::dispatch::ThreadedDispatcher> input_thread;
233
    std::shared_ptr<mir::dispatch::ThreadedDispatcher> input_thread;
717
236
    bool auto_resize_stream{true};
234
    bool auto_resize_stream{true};
718
235
719
236
    //a bit batty, but the creation handle has to exist for as long as the MirSurface does,
720
237
    //as we don't really manage the lifetime of MirWaitHandle sensibly.
721
238
    std::shared_ptr<MirWaitHandle> const creation_handle;
722
237
};
239
};
723
238
240
724
239
#endif /* MIR_CLIENT_PRIVATE_MIR_WAIT_HANDLE_H_ */
241
#endif /* MIR_CLIENT_PRIVATE_MIR_WAIT_HANDLE_H_ */
725
240
242
726
=== modified file 'src/client/mir_surface_api.cpp'
727
--- src/client/mir_surface_api.cpp	2015-10-14 16:16:08 +0000
728
+++ src/client/mir_surface_api.cpp	2016-01-13 19:10:37 +0000
729
@@ -152,9 +152,6 @@
730
152
    }
152
    }
731
153
    catch (std::exception const& error)
153
    catch (std::exception const& error)
732
154
    {
154
    {
733
155
        auto error_surf = new MirSurface{std::string{"Failed to create surface: "} +
734
156
                                         boost::diagnostic_information(error)};
735
157
        (*callback)(error_surf, context);
736
158
        return nullptr;
155
        return nullptr;
737
159
    }
156
    }
738
160
}
157
}
739
@@ -258,9 +255,10 @@
740
258
    MirSurface* surface,
255
    MirSurface* surface,
741
259
    mir_surface_callback callback, void* context)
256
    mir_surface_callback callback, void* context)
742
260
{
257
{
743
258
    auto connection = surface->connection();
744
261
    try
259
    try
745
262
    {
260
    {
747
263
        return surface->release_surface(callback, context);
261
        return connection->release_surface(surface, callback, context);
748
264
    }
262
    }
749
265
    catch (std::exception const& ex)
263
    catch (std::exception const& ex)
750
266
    {
264
    {
751
267
265
752
=== modified file 'src/client/surface_map.cpp'
753
--- src/client/surface_map.cpp	2015-12-15 15:42:37 +0000
754
+++ src/client/surface_map.cpp	2016-01-13 19:10:37 +0000
755
@@ -31,7 +31,7 @@
756
31
31
757
32
mcl::ConnectionSurfaceMap::~ConnectionSurfaceMap() noexcept
32
mcl::ConnectionSurfaceMap::~ConnectionSurfaceMap() noexcept
758
33
{
33
{
760
34
    std::unordered_map<frontend::SurfaceId, MirSurface*> surface_map;
34
    std::unordered_map<frontend::SurfaceId, std::shared_ptr<MirSurface>> surface_map;
761
35
    std::unordered_map<frontend::BufferStreamId, StreamInfo> stream_map;
35
    std::unordered_map<frontend::BufferStreamId, StreamInfo> stream_map;
762
36
    {
36
    {
763
37
        //Prevent TSAN from flagging lock ordering issues
37
        //Prevent TSAN from flagging lock ordering issues
764
@@ -42,14 +42,8 @@
765
42
        stream_map = std::move(streams);
42
        stream_map = std::move(streams);
766
43
    }
43
    }
767
44
44
769
45
    // Unless the client has screwed up there should be no surfaces left
45
    // Unless the client has screwed up there should be no streams left
770
46
    // here. (OTOH *we* don't need to leak memory when clients screw up.)
46
    // here. (OTOH *we* don't need to leak memory when clients screw up.)
771
47
    for (auto const& surface : surface_map)
772
48
    {
773
49
        if (MirSurface::is_valid(surface.second))
774
50
            delete surface.second;
775
51
    }
776
52
777
53
    for (auto const& info : stream_map)
47
    for (auto const& info : stream_map)
778
54
    {
48
    {
779
55
        if (info.second.owned)
49
        if (info.second.owned)
780
@@ -65,7 +59,7 @@
781
65
    if (it != surfaces.end())
59
    if (it != surfaces.end())
782
66
    {
60
    {
783
67
        auto const surface = it->second;
61
        auto const surface = it->second;
785
68
        exec(surface);
62
        exec(surface.get());
786
69
    }
63
    }
787
70
    else
64
    else
788
71
    {
65
    {
789
@@ -75,7 +69,7 @@
790
75
    }
69
    }
791
76
}
70
}
792
77
71
794
78
void mcl::ConnectionSurfaceMap::insert(mf::SurfaceId surface_id, MirSurface* surface)
72
void mcl::ConnectionSurfaceMap::insert(mf::SurfaceId surface_id, std::shared_ptr<MirSurface> const& surface)
795
79
{
73
{
796
80
    // get_buffer_stream has internal locks - call before locking mutex to
74
    // get_buffer_stream has internal locks - call before locking mutex to
797
81
    // avoid locking ordering issues
75
    // avoid locking ordering issues
798
82
76
799
=== modified file 'src/client/surface_map.h'
800
--- src/client/surface_map.h	2015-07-16 07:03:19 +0000
801
+++ src/client/surface_map.h	2016-01-13 19:10:37 +0000
802
@@ -22,6 +22,7 @@
803
22
#include "mir/frontend/surface_id.h"
22
#include "mir/frontend/surface_id.h"
804
23
#include "mir/frontend/buffer_stream_id.h"
23
#include "mir/frontend/buffer_stream_id.h"
805
24
#include <functional>
24
#include <functional>
806
25
#include <memory>
807
25
26
808
26
struct MirSurface;
27
struct MirSurface;
809
27
28
810
28
29
811
=== modified file 'tests/unit-tests/client/test_client_mir_surface.cpp'
812
--- tests/unit-tests/client/test_client_mir_surface.cpp	2015-12-16 20:01:21 +0000
813
+++ tests/unit-tests/client/test_client_mir_surface.cpp	2016-01-13 19:10:37 +0000
814
@@ -51,8 +51,7 @@
815
51
51
816
52
#include <boost/throw_exception.hpp>
52
#include <boost/throw_exception.hpp>
817
53
#include "mir/test/doubles/stub_client_buffer_factory.h"
53
#include "mir/test/doubles/stub_client_buffer_factory.h"
820
54
#include "mir/test/doubles/stub_client_buffer_stream_factory.h"
54
#include "mir/test/doubles/stub_buffer_stream.h"
819
55
#include "mir/test/doubles/mock_client_buffer_stream_factory.h"
821
56
#include "mir/test/doubles/mock_client_buffer_stream.h"
55
#include "mir/test/doubles/mock_client_buffer_stream.h"
822
57
56
823
58
#include "mir_test_framework/stub_client_platform_factory.h"
57
#include "mir_test_framework/stub_client_platform_factory.h"
824
@@ -139,7 +138,6 @@
825
139
138
826
140
    static std::map<int, int> sent_surface_attributes;
139
    static std::map<int, int> sent_surface_attributes;
827
141
140
828
142
private:
829
143
    void generate_unique_buffer()
141
    void generate_unique_buffer()
830
144
    {
142
    {
831
145
        global_buffer_id++;
143
        global_buffer_id++;
832
@@ -278,10 +276,6 @@
833
278
{
276
{
834
279
}
277
}
835
280
278
836
281
void null_surface_callback(MirSurface*, void*)
837
282
{
838
283
}
839
284
840
285
void null_event_callback(MirSurface*, MirEvent const*, void*)
279
void null_event_callback(MirSurface*, MirEvent const*, void*)
841
286
{
280
{
842
287
}
281
}
843
@@ -294,6 +288,8 @@
844
294
{
288
{
845
295
    MirClientSurfaceTest()
289
    MirClientSurfaceTest()
846
296
    {
290
    {
847
291
        mock_server_tool->create_surface_response(&surface_proto);
848
292
        ON_CALL(*stub_buffer_stream, swap_interval()).WillByDefault(testing::Return(1));
849
297
        start_test_server();
293
        start_test_server();
850
298
        connect_to_test_server();
294
        connect_to_test_server();
851
299
    }
295
    }
852
@@ -333,50 +329,47 @@
853
333
            connection.get(),
329
            connection.get(),
854
334
            server_stub,
330
            server_stub,
855
335
            nullptr,
331
            nullptr,
857
336
            stub_buffer_stream_factory,
332
            stub_buffer_stream,
858
337
            input_platform,
333
            input_platform,
859
338
            spec,
334
            spec,
862
339
            &null_surface_callback,
335
            surface_proto,
863
340
            nullptr);
336
            wh);
864
341
    }
337
    }
865
342
338
866
343
    std::shared_ptr<MirSurface> create_surface_with(
339
    std::shared_ptr<MirSurface> create_surface_with(
867
344
        mclr::DisplayServer& server_stub,
340
        mclr::DisplayServer& server_stub,
869
345
        std::shared_ptr<mcl::ClientBufferStreamFactory> const& buffer_stream_factory)
341
        std::shared_ptr<mcl::ClientBufferStream> const& buffer_stream)
870
346
    {
342
    {
871
347
        return std::make_shared<MirSurface>(
343
        return std::make_shared<MirSurface>(
872
348
            connection.get(),
344
            connection.get(),
873
349
            server_stub,
345
            server_stub,
874
350
            nullptr,
346
            nullptr,
876
351
            buffer_stream_factory,
347
            buffer_stream,
877
352
            input_platform,
348
            input_platform,
878
353
            spec,
349
            spec,
881
354
            &null_surface_callback,
350
            surface_proto,
882
355
            nullptr);
351
            wh);
883
356
    }
352
    }
884
357
353
885
358
    std::shared_ptr<MirSurface> create_and_wait_for_surface_with(
354
    std::shared_ptr<MirSurface> create_and_wait_for_surface_with(
886
359
        mclr::DisplayServer& server_stub)
355
        mclr::DisplayServer& server_stub)
887
360
    {
356
    {
888
361
        auto surface = create_surface_with(server_stub);
357
        auto surface = create_surface_with(server_stub);
889
362
        surface->get_create_wait_handle()->wait_for_all();
890
363
        return surface;
358
        return surface;
891
364
    }
359
    }
892
365
360
893
366
    std::shared_ptr<MirSurface> create_and_wait_for_surface_with(
361
    std::shared_ptr<MirSurface> create_and_wait_for_surface_with(
894
367
        mclr::DisplayServer& server_stub,
362
        mclr::DisplayServer& server_stub,
896
368
        std::shared_ptr<mcl::ClientBufferStreamFactory> const& buffer_stream_factory)
363
        std::shared_ptr<mcl::ClientBufferStream> const& buffer_stream)
897
369
    {
364
    {
900
370
        auto surface = create_surface_with(server_stub, buffer_stream_factory);
365
        auto surface = create_surface_with(server_stub, buffer_stream);
899
371
        surface->get_create_wait_handle()->wait_for_all();
901
372
        return surface;
366
        return surface;
902
373
    }
367
    }
903
374
368
904
375
    std::shared_ptr<MirConnection> connection;
369
    std::shared_ptr<MirConnection> connection;
905
376
370
906
377
    MirSurfaceSpec const spec{nullptr, 33, 45, mir_pixel_format_abgr_8888};
371
    MirSurfaceSpec const spec{nullptr, 33, 45, mir_pixel_format_abgr_8888};
909
378
    std::shared_ptr<mtd::StubClientBufferStreamFactory> const stub_buffer_stream_factory =
372
    std::shared_ptr<mtd::MockClientBufferStream> stub_buffer_stream{std::make_shared<mtd::MockClientBufferStream>()};
908
379
        std::make_shared<mtd::StubClientBufferStreamFactory>();
910
380
    std::shared_ptr<StubClientInputPlatform> const input_platform =
373
    std::shared_ptr<StubClientInputPlatform> const input_platform =
911
381
        std::make_shared<StubClientInputPlatform>();
374
        std::make_shared<StubClientInputPlatform>();
912
382
    std::shared_ptr<MockServerPackageGenerator> const mock_server_tool =
375
    std::shared_ptr<MockServerPackageGenerator> const mock_server_tool =
913
@@ -385,6 +378,8 @@
914
385
    std::shared_ptr<mcl::ConnectionSurfaceMap> surface_map;
378
    std::shared_ptr<mcl::ConnectionSurfaceMap> surface_map;
915
386
    std::shared_ptr<mt::TestProtobufServer> test_server;
379
    std::shared_ptr<mt::TestProtobufServer> test_server;
916
387
    std::shared_ptr<mclr::DisplayServer> client_comm_channel;
380
    std::shared_ptr<mclr::DisplayServer> client_comm_channel;
917
381
    mir::protobuf::Surface surface_proto;
918
382
    std::shared_ptr<MirWaitHandle> const wh{std::make_shared<MirWaitHandle>()};
919
388
383
920
389
    std::chrono::milliseconds const pause_time{10};
384
    std::chrono::milliseconds const pause_time{10};
921
390
};
385
};
922
@@ -403,22 +398,6 @@
923
403
    }
398
    }
924
404
}
399
}
925
405
400
926
406
TEST_F(MirClientSurfaceTest, create_wait_handle_really_blocks)
927
407
{
928
408
    using namespace testing;
929
409
930
410
    FakeRpcChannel fake_channel;
931
411
    mclr::DisplayServer unresponsive_server{mt::fake_shared(fake_channel)};
932
412
933
413
    auto const surface = create_surface_with(unresponsive_server);
934
414
    auto wait_handle = surface->get_create_wait_handle();
935
415
936
416
    auto expected_end = std::chrono::steady_clock::now() + pause_time;
937
417
    wait_handle->wait_for_pending(pause_time);
938
418
939
419
    EXPECT_GE(std::chrono::steady_clock::now(), expected_end);
940
420
}
941
421
942
422
TEST_F(MirClientSurfaceTest, creates_input_thread_with_input_dispatcher_when_delegate_specified)
401
TEST_F(MirClientSurfaceTest, creates_input_thread_with_input_dispatcher_when_delegate_specified)
943
423
{
402
{
944
424
    using namespace ::testing;
403
    using namespace ::testing;
945
@@ -432,9 +411,7 @@
946
432
        .WillOnce(Return(mock_input_dispatcher));
411
        .WillOnce(Return(mock_input_dispatcher));
947
433
412
948
434
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
413
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
952
435
        stub_buffer_stream_factory, mock_input_platform, spec, &null_surface_callback, nullptr};
414
        stub_buffer_stream, mock_input_platform, spec, surface_proto, wh};
950
436
    auto wait_handle = surface.get_create_wait_handle();
951
437
    wait_handle->wait_for_all();
953
438
    surface.set_event_handler(null_event_callback, nullptr);
415
    surface.set_event_handler(null_event_callback, nullptr);
954
439
416
955
440
    mock_input_dispatcher->trigger();
417
    mock_input_dispatcher->trigger();
956
@@ -455,9 +432,7 @@
957
455
        .WillOnce(Return(mock_input_dispatcher));
432
        .WillOnce(Return(mock_input_dispatcher));
958
456
433
959
457
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
434
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
963
458
        stub_buffer_stream_factory, mock_input_platform, spec, &null_surface_callback, nullptr};
435
        stub_buffer_stream, mock_input_platform, spec, surface_proto, wh};
961
459
    auto wait_handle = surface.get_create_wait_handle();
962
460
    wait_handle->wait_for_all();
964
461
    surface.set_event_handler(null_event_callback, nullptr);
436
    surface.set_event_handler(null_event_callback, nullptr);
965
462
437
966
463
    // Should now not get dispatched.
438
    // Should now not get dispatched.
967
@@ -478,9 +453,7 @@
968
478
    EXPECT_CALL(*mock_input_platform, create_input_receiver(_, _, _)).Times(0);
453
    EXPECT_CALL(*mock_input_platform, create_input_receiver(_, _, _)).Times(0);
969
479
454
970
480
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
455
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
974
481
        stub_buffer_stream_factory, mock_input_platform, spec, &null_surface_callback, nullptr};
456
        stub_buffer_stream, mock_input_platform, spec, surface_proto, wh};
972
482
    auto wait_handle = surface.get_create_wait_handle();
973
483
    wait_handle->wait_for_all();
975
484
}
457
}
976
485
458
977
486
TEST_F(MirClientSurfaceTest, valid_surface_is_valid)
459
TEST_F(MirClientSurfaceTest, valid_surface_is_valid)
978
@@ -531,12 +504,7 @@
979
531
{
504
{
980
532
    using namespace testing;
505
    using namespace testing;
981
533
    auto mock_stream = std::make_shared<mtd::MockClientBufferStream>(); 
506
    auto mock_stream = std::make_shared<mtd::MockClientBufferStream>(); 
982
534
    auto mock_stream_factory = std::make_shared<NiceMock<mtd::MockClientBufferStreamFactory>>();
983
535
    auto mock_input_platform = std::make_shared<NiceMock<MockClientInputPlatform>>();
507
    auto mock_input_platform = std::make_shared<NiceMock<MockClientInputPlatform>>();
984
536
    ON_CALL(*mock_stream_factory, make_producer_stream(_,_,_,_,An<void*>()))
985
537
        .WillByDefault(Return(mock_stream.get()));
986
538
    ON_CALL(*mock_stream_factory, make_producer_stream(_,_,_,_,An<geom::Size>()))
987
539
        .WillByDefault(Return(mock_stream));
988
540
    ON_CALL(*mock_input_platform, create_input_receiver(_,_,_))
508
    ON_CALL(*mock_input_platform, create_input_receiver(_,_,_))
989
541
        .WillByDefault(Return(std::make_shared<mt::TestDispatchable>([]{})));
509
        .WillByDefault(Return(std::make_shared<mt::TestDispatchable>([]{})));
990
542
    ON_CALL(*mock_stream, rpc_id()).WillByDefault(Return(mir::frontend::BufferStreamId(2)));
510
    ON_CALL(*mock_stream, rpc_id()).WillByDefault(Return(mir::frontend::BufferStreamId(2)));
991
@@ -545,11 +513,8 @@
992
545
    EXPECT_CALL(*mock_stream, set_size(size));
513
    EXPECT_CALL(*mock_stream, set_size(size));
993
546
    auto ev = mir::events::make_event(mir::frontend::SurfaceId(2), size);
514
    auto ev = mir::events::make_event(mir::frontend::SurfaceId(2), size);
994
547
515
995
548
    //FIXME: difficult construction
996
549
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
516
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
1000
550
        mock_stream_factory, mock_input_platform, spec, &null_surface_callback, nullptr};
517
        mock_stream, mock_input_platform, spec, surface_proto, wh};
998
551
    auto wait_handle = surface.get_create_wait_handle();
999
552
    wait_handle->wait_for_all();
1001
553
    surface.handle_event(*ev);
518
    surface.handle_event(*ev);
1002
554
    surface_map->erase(mir::frontend::BufferStreamId(2));
519
    surface_map->erase(mir::frontend::BufferStreamId(2));
1003
555
}
520
}
1004
@@ -558,13 +523,8 @@
1005
558
{
523
{
1006
559
    using namespace testing;
524
    using namespace testing;
1007
560
    auto mock_stream = std::make_shared<NiceMock<mtd::MockClientBufferStream>>();
525
    auto mock_stream = std::make_shared<NiceMock<mtd::MockClientBufferStream>>();
1008
561
    auto mock_stream_factory = std::make_shared<NiceMock<mtd::MockClientBufferStreamFactory>>();
1009
562
    auto mock_input_platform = std::make_shared<NiceMock<MockClientInputPlatform>>();
526
    auto mock_input_platform = std::make_shared<NiceMock<MockClientInputPlatform>>();
1010
563
    ON_CALL(*mock_stream, rpc_id()).WillByDefault(Return(mir::frontend::BufferStreamId(2)));
527
    ON_CALL(*mock_stream, rpc_id()).WillByDefault(Return(mir::frontend::BufferStreamId(2)));
1011
564
    ON_CALL(*mock_stream_factory, make_producer_stream(_,_,_,_,An<void*>()))
1012
565
        .WillByDefault(Return(mock_stream.get()));
1013
566
    ON_CALL(*mock_stream_factory, make_producer_stream(_,_,_,_,An<geom::Size>()))
1014
567
        .WillByDefault(Return(mock_stream));
1015
568
    ON_CALL(*mock_input_platform, create_input_receiver(_,_,_))
528
    ON_CALL(*mock_input_platform, create_input_receiver(_,_,_))
1016
569
        .WillByDefault(Return(std::make_shared<mt::TestDispatchable>([]{})));
529
        .WillByDefault(Return(std::make_shared<mt::TestDispatchable>([]{})));
1017
570
530
1018
@@ -572,8 +532,7 @@
1019
572
    EXPECT_CALL(*mock_stream, set_size(size)).Times(0);
532
    EXPECT_CALL(*mock_stream, set_size(size)).Times(0);
1020
573
    auto ev = mir::events::make_event(mir::frontend::SurfaceId(2), size);
533
    auto ev = mir::events::make_event(mir::frontend::SurfaceId(2), size);
1021
574
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
534
    MirSurface surface{connection.get(), *client_comm_channel, nullptr,
1024
575
        mock_stream_factory, mock_input_platform, spec, &null_surface_callback, nullptr};
535
        mock_stream, mock_input_platform, spec, surface_proto, wh};
1023
576
    surface.get_create_wait_handle()->wait_for_all();
1025
577
536
1026
578
    MirSurfaceSpec spec;
537
    MirSurfaceSpec spec;
1027
579
    std::vector<MirBufferStreamInfo> info =
538
    std::vector<MirBufferStreamInfo> info =
1028
580
539
1029
=== modified file 'tests/unit-tests/client/test_connection_resource_map.cpp'
1030
--- tests/unit-tests/client/test_connection_resource_map.cpp	2015-07-16 07:03:19 +0000
1031
+++ tests/unit-tests/client/test_connection_resource_map.cpp	2016-01-13 19:10:37 +0000
1032
@@ -27,7 +27,8 @@
1033
27
27
1034
28
struct ConnectionResourceMap : testing::Test
28
struct ConnectionResourceMap : testing::Test
1035
29
{
29
{
1037
30
    MirSurface surface{"a string"};
30
    std::shared_ptr<MirWaitHandle> wh { std::make_shared<MirWaitHandle>() };
1038
31
    std::shared_ptr<MirSurface> surface{std::make_shared<MirSurface>("a string", nullptr, mf::SurfaceId{2}, wh)};
1039
31
    mtd::MockClientBufferStream stream; 
32
    mtd::MockClientBufferStream stream; 
1040
32
    mf::SurfaceId const surface_id{43};
33
    mf::SurfaceId const surface_id{43};
1041
33
    mf::BufferStreamId const stream_id{43};
34
    mf::BufferStreamId const stream_id{43};
1042
@@ -39,14 +40,14 @@
1043
39
    auto surface_called = false;
40
    auto surface_called = false;
1044
40
    auto stream_called = false;
41
    auto stream_called = false;
1045
41
    mcl::ConnectionSurfaceMap map;
42
    mcl::ConnectionSurfaceMap map;
1047
42
    map.insert(surface_id, &surface);
43
    map.insert(surface_id, surface);
1048
43
    map.with_surface_do(surface_id, [&](MirSurface* surf) {
44
    map.with_surface_do(surface_id, [&](MirSurface* surf) {
1050
44
        EXPECT_THAT(surf, Eq(&surface));
45
        EXPECT_THAT(surf, Eq(surface.get()));
1051
45
        surface_called = true;
46
        surface_called = true;
1052
46
    });
47
    });
1053
47
48
1054
48
    map.with_stream_do(stream_id, [&](mcl::ClientBufferStream* stream) {
49
    map.with_stream_do(stream_id, [&](mcl::ClientBufferStream* stream) {
1056
49
        EXPECT_THAT(stream, Eq(surface.get_buffer_stream()));
50
        EXPECT_THAT(stream, Eq(surface->get_buffer_stream()));
1057
50
        stream_called = true;
51
        stream_called = true;
1058
51
    });
52
    });
1059
52
53
1060
@@ -59,9 +60,9 @@
1061
59
    using namespace testing;
60
    using namespace testing;
1062
60
    auto stream_called = false;
61
    auto stream_called = false;
1063
61
    mcl::ConnectionSurfaceMap map;
62
    mcl::ConnectionSurfaceMap map;
1065
62
    map.insert(surface_id, &surface);
63
    map.insert(surface_id, surface);
1066
63
    map.with_stream_do(stream_id, [&](mcl::ClientBufferStream* stream) {
64
    map.with_stream_do(stream_id, [&](mcl::ClientBufferStream* stream) {
1068
64
        EXPECT_THAT(stream, Eq(surface.get_buffer_stream()));
65
        EXPECT_THAT(stream, Eq(surface->get_buffer_stream()));
1069
65
        stream_called = true;
66
        stream_called = true;
1070
66
    });
67
    });
1071
67
    EXPECT_TRUE(stream_called);
68
    EXPECT_TRUE(stream_called);
1072
68
69
1073
=== modified file 'tests/unit-tests/client/test_mir_connection.cpp'
1074
--- tests/unit-tests/client/test_mir_connection.cpp	2015-07-29 01:39:52 +0000
1075
+++ tests/unit-tests/client/test_mir_connection.cpp	2016-01-13 19:10:37 +0000
1076
@@ -63,7 +63,7 @@
1077
63
        ON_CALL(*this, watch_fd()).WillByDefault(testing::Return(pollable_fd));
63
        ON_CALL(*this, watch_fd()).WillByDefault(testing::Return(pollable_fd));
1078
64
    }
64
    }
1079
65
65
1081
66
    void call_method(std::string const& name,
66
    virtual void call_method(std::string const& name,
1082
67
                    google::protobuf::MessageLite const* parameters,
67
                    google::protobuf::MessageLite const* parameters,
1083
68
                    google::protobuf::MessageLite* response,
68
                    google::protobuf::MessageLite* response,
1084
69
                    google::protobuf::Closure* complete)
69
                    google::protobuf::Closure* complete)
1085
@@ -83,6 +83,13 @@
1086
83
            platform_operation(static_cast<mp::PlatformOperationMessage const*>(parameters),
83
            platform_operation(static_cast<mp::PlatformOperationMessage const*>(parameters),
1087
84
                               static_cast<mp::PlatformOperationMessage*>(response));
84
                               static_cast<mp::PlatformOperationMessage*>(response));
1088
85
        }
85
        }
1089
86
        else if (name == "create_surface")
1090
87
        {
1091
88
            auto response_message = static_cast<mp::Surface*>(response);
1092
89
            response_message->mutable_id()->set_value(33);
1093
90
            response_message->mutable_buffer_stream()->mutable_id()->set_value(33);
1094
91
        }
1095
92
1096
86
93
1097
87
        complete->Run();
94
        complete->Run();
1098
88
    }
95
    }
1099
@@ -638,3 +645,30 @@
1100
638
    EXPECT_THAT(mir_platform_message_get_opcode(returned_response), Eq(opcode));
645
    EXPECT_THAT(mir_platform_message_get_opcode(returned_response), Eq(opcode));
1101
639
    mir_platform_message_release(returned_response);
646
    mir_platform_message_release(returned_response);
1102
640
}
647
}
1103
648
1104
649
TEST_F(MirConnectionTest, create_wait_handle_really_blocks)
1105
650
{
1106
651
    using namespace testing;
1107
652
1108
653
    std::chrono::milliseconds const pause_time{10};
1109
654
    struct FakeRpcChannel : public MockRpcChannel
1110
655
    {
1111
656
        void call_method(
1112
657
            std::string const&,
1113
658
            google::protobuf::MessageLite const*,
1114
659
            google::protobuf::MessageLite*,
1115
660
            google::protobuf::Closure* closure) override
1116
661
        {
1117
662
            delete closure;
1118
663
        }
1119
664
    };
1120
665
    TestConnectionConfiguration conf{mock_platform, std::make_shared<NiceMock<FakeRpcChannel>>()};
1121
666
    MirConnection connection(conf);
1122
667
    MirSurfaceSpec const spec{&connection, 33, 45, mir_pixel_format_abgr_8888};
1123
668
1124
669
    auto wait_handle = connection.create_surface(spec, nullptr, nullptr);
1125
670
    auto expected_end = std::chrono::steady_clock::now() + pause_time;
1126
671
    wait_handle->wait_for_pending(pause_time);
1127
672
1128
673
    EXPECT_GE(std::chrono::steady_clock::now(), expected_end);
1129
674
}
Status:	Merged
Approved by:	Chris Halse Rogers on 2016-01-14
Approved revision:	no longer in the source branch.
Merged at revision:	3240
Proposed branch:	lp:~kdub/mir/sort-out-surface-ownership
Merge into:	lp:mir
Diff against target:	1129 lines (+331/-299) 11 files modified src/client/connection_surface_map.h (+2/-2) src/client/mir_connection.cpp (+186/-18) src/client/mir_connection.h (+27/-4) src/client/mir_surface.cpp (+31/-179) src/client/mir_surface.h (+16/-14) src/client/mir_surface_api.cpp (+2/-4) src/client/surface_map.cpp (+4/-10) src/client/surface_map.h (+1/-0) tests/unit-tests/client/test_client_mir_surface.cpp (+20/-61) tests/unit-tests/client/test_connection_resource_map.cpp (+7/-6) tests/unit-tests/client/test_mir_connection.cpp (+35/-1)
To merge this branch:	bzr merge lp:~kdub/mir/sort-out-surface-ownership
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Chris Halse Rogers			Approve on 2016-01-14
Alberto Aguirre (community)			Approve on 2016-01-13
PS Jenkins bot (community)	continuous-integration		Approve on 2016-01-13
Mir CI Bot	continuous-integration		Approve on 2016-01-13
Alan Griffiths		2015-12-14	Approve on 2016-01-05
Review via email: mp+280481@code.launchpad.net