1
=== modified file 'src/server/compositor/CMakeLists.txt'
2
--- src/server/compositor/CMakeLists.txt	2017-05-22 23:26:24 +0000
3
+++ src/server/compositor/CMakeLists.txt	2017-08-08 04:14:04 +0000
4
@@ -9,7 +9,6 @@
5
9
9
6
10
  default_display_buffer_compositor.cpp
10
  default_display_buffer_compositor.cpp
7
11
  default_display_buffer_compositor_factory.cpp
11
  default_display_buffer_compositor_factory.cpp
8
12
  temporary_buffers.cpp
9
13
  buffer_stream_factory.cpp
12
  buffer_stream_factory.cpp
10
14
  multi_threaded_compositor.cpp
13
  multi_threaded_compositor.cpp
11
15
  occlusion.cpp
14
  occlusion.cpp
12
16
15
13
=== modified file 'src/server/compositor/buffer_acquisition.h'
14
--- src/server/compositor/buffer_acquisition.h	2017-07-28 17:00:43 +0000
15
+++ src/server/compositor/buffer_acquisition.h	2017-08-08 04:14:04 +0000
16
@@ -36,6 +36,11 @@
17
36
    /**
36
    /**
18
37
     * Acquire the next buffer that's ready to display/composite.
37
     * Acquire the next buffer that's ready to display/composite.
19
38
     *
38
     *
20
39
     * \note    The returned buffer is considered in-use until the its
21
40
     *          use-count reaches 0. In-use buffers will not be returned
22
41
     *          to the client, so for best performance it is important to
23
42
     *          release the returned buffer as soon as possible.
24
43
     *
25
39
     * \param [in] user_id A unique identifier of who is going to use the
44
     * \param [in] user_id A unique identifier of who is going to use the
26
40
     *                     buffer, to ensure that separate users representing
45
     *                     buffer, to ensure that separate users representing
27
41
     *                     separate monitors who need the same frame will get
46
     *                     separate monitors who need the same frame will get
28
@@ -46,9 +51,19 @@
29
46
     */
51
     */
30
47
    virtual std::shared_ptr<graphics::Buffer>
52
    virtual std::shared_ptr<graphics::Buffer>
31
48
        compositor_acquire(void const* user_id) = 0;
53
        compositor_acquire(void const* user_id) = 0;
33
49
    virtual void compositor_release(std::shared_ptr<graphics::Buffer> const&) = 0;
54
34
55
    /**
35
56
     * Acquire the most recently displayed buffer.
36
57
     *
37
58
     * In contrast with compositor_acquire() this does not consume a client
38
59
     * buffer.
39
60
     *
40
61
     * Like compositor_acquire(), you should release your reference to the
41
62
     * returned buffer as soon as possible.
42
63
     *
43
64
     * \return A shared reference to the most recent visible client buffer.
44
65
     */
45
50
    virtual std::shared_ptr<graphics::Buffer> snapshot_acquire() = 0;
66
    virtual std::shared_ptr<graphics::Buffer> snapshot_acquire() = 0;
46
51
    virtual void snapshot_release(std::shared_ptr<graphics::Buffer> const&) = 0;
47
52
    virtual ~BufferAcquisition() = default;
67
    virtual ~BufferAcquisition() = default;
48
53
68
49
54
protected:
69
protected:
50
55
70
51
=== modified file 'src/server/compositor/multi_monitor_arbiter.cpp'
52
--- src/server/compositor/multi_monitor_arbiter.cpp	2017-07-28 17:00:43 +0000
53
+++ src/server/compositor/multi_monitor_arbiter.cpp	2017-08-08 04:14:04 +0000
54
@@ -36,95 +36,40 @@
55
36
36
56
37
mc::MultiMonitorArbiter::~MultiMonitorArbiter()
37
mc::MultiMonitorArbiter::~MultiMonitorArbiter()
57
38
{
38
{
58
39
    std::lock_guard<decltype(mutex)> lk(mutex);
59
40
    for(auto it = onscreen_buffers.begin(); it != onscreen_buffers.end(); it++)
60
41
    {
61
42
        if (it->use_count == 0)
62
43
            it->buffer.reset();
63
44
    }
64
45
65
46
}
39
}
66
47
40
67
48
std::shared_ptr<mg::Buffer> mc::MultiMonitorArbiter::compositor_acquire(compositor::CompositorID id)
41
std::shared_ptr<mg::Buffer> mc::MultiMonitorArbiter::compositor_acquire(compositor::CompositorID id)
68
49
{
42
{
69
50
    std::lock_guard<decltype(mutex)> lk(mutex);
43
    std::lock_guard<decltype(mutex)> lk(mutex);
70
51
44
72
52
    if (onscreen_buffers.empty() && !schedule->num_scheduled())
45
    if (!current_buffer && !schedule->num_scheduled())
73
53
        BOOST_THROW_EXCEPTION(std::logic_error("no buffer to give to compositor"));
46
        BOOST_THROW_EXCEPTION(std::logic_error("no buffer to give to compositor"));
74
54
47
76
55
    if (current_buffer_users.find(id) != current_buffer_users.end() || onscreen_buffers.empty())
48
    if (current_buffer_users.find(id) != current_buffer_users.end() || !current_buffer)
77
56
    {
49
    {
78
57
        if (schedule->num_scheduled())
50
        if (schedule->num_scheduled())
80
58
            onscreen_buffers.emplace_front(schedule->next_buffer(), 0);
51
            current_buffer = schedule->next_buffer();
81
59
        current_buffer_users.clear();
52
        current_buffer_users.clear();
82
60
    }
53
    }
83
61
    current_buffer_users.insert(id);
54
    current_buffer_users.insert(id);
84
62
55
125
63
    auto& last_entry = onscreen_buffers.front();
56
    return current_buffer;
86
64
    last_entry.use_count++;
87
65
    auto last_entry_buffer = last_entry.buffer;
88
66
    clean_onscreen_buffers(lk);
89
67
    return last_entry_buffer;
90
68
}
91
69
92
70
void mc::MultiMonitorArbiter::compositor_release(std::shared_ptr<mg::Buffer> const& buffer)
93
71
{
94
72
    std::lock_guard<decltype(mutex)> lk(mutex);
95
73
96
74
    decrease_refcount_for(buffer->id(), lk);
97
75
98
76
    if (onscreen_buffers.begin()->buffer != buffer)
99
77
        clean_onscreen_buffers(lk);
100
78
}
101
79
102
80
void mc::MultiMonitorArbiter::decrease_refcount_for(mg::BufferID id, std::lock_guard<std::mutex> const&)
103
81
{
104
82
    auto it = std::find_if(onscreen_buffers.begin(), onscreen_buffers.end(),
105
83
        [&id](ScheduleEntry const& s) { return s.buffer->id() == id; });
106
84
    if (it == onscreen_buffers.end())
107
85
        BOOST_THROW_EXCEPTION(std::logic_error("buffer not scheduled"));
108
86
    it->use_count--;
109
87
}
110
88
111
89
void mc::MultiMonitorArbiter::clean_onscreen_buffers(std::lock_guard<std::mutex> const&)
112
90
{
113
91
    for(auto it = onscreen_buffers.begin(); it != onscreen_buffers.end();)
114
92
    {
115
93
        if ((it->use_count == 0) &&
116
94
            (it != onscreen_buffers.begin() || schedule->num_scheduled())) //ensure monitors always have a buffer
117
95
        {
118
96
            it = onscreen_buffers.erase(it);
119
97
        }
120
98
        else
121
99
        {
122
100
            it++;
123
101
        } 
124
102
    }
126
103
}
57
}
127
104
58
128
105
std::shared_ptr<mg::Buffer> mc::MultiMonitorArbiter::snapshot_acquire()
59
std::shared_ptr<mg::Buffer> mc::MultiMonitorArbiter::snapshot_acquire()
129
106
{
60
{
130
107
    std::lock_guard<decltype(mutex)> lk(mutex);
61
    std::lock_guard<decltype(mutex)> lk(mutex);
131
108
62
133
109
    if (onscreen_buffers.empty() && !schedule->num_scheduled())
63
    if (!current_buffer && !schedule->num_scheduled())
134
110
        BOOST_THROW_EXCEPTION(std::logic_error("no buffer to give to snapshotter"));
64
        BOOST_THROW_EXCEPTION(std::logic_error("no buffer to give to snapshotter"));
135
111
65
137
112
    if (onscreen_buffers.empty())
66
    if (!current_buffer)
138
113
    {
67
    {
139
114
        if (schedule->num_scheduled())
68
        if (schedule->num_scheduled())
141
115
            onscreen_buffers.emplace_front(schedule->next_buffer(), 0);
69
            current_buffer = schedule->next_buffer();
142
116
    }
70
    }
143
117
71
154
118
    auto& last_entry = onscreen_buffers.front();
72
    return current_buffer;
145
119
    last_entry.use_count++;
146
120
    return last_entry.buffer;
147
121
}
148
122
149
123
void mc::MultiMonitorArbiter::snapshot_release(std::shared_ptr<mg::Buffer> const& buffer)
150
124
{
151
125
    std::lock_guard<decltype(mutex)> lk(mutex);
152
126
    decrease_refcount_for(buffer->id(), lk);
153
127
    clean_onscreen_buffers(lk);
155
128
}
73
}
156
129
74
157
130
void mc::MultiMonitorArbiter::set_schedule(std::shared_ptr<Schedule> const& new_schedule)
75
void mc::MultiMonitorArbiter::set_schedule(std::shared_ptr<Schedule> const& new_schedule)
158
@@ -137,13 +82,13 @@
159
137
{
82
{
160
138
    std::lock_guard<decltype(mutex)> lk(mutex);
83
    std::lock_guard<decltype(mutex)> lk(mutex);
161
139
    return schedule->num_scheduled() ||
84
    return schedule->num_scheduled() ||
163
140
       ((current_buffer_users.find(id) == current_buffer_users.end()) && !onscreen_buffers.empty());
85
       ((current_buffer_users.find(id) == current_buffer_users.end()) && current_buffer);
164
141
}
86
}
165
142
87
166
143
bool mc::MultiMonitorArbiter::has_buffer()
88
bool mc::MultiMonitorArbiter::has_buffer()
167
144
{
89
{
168
145
    std::lock_guard<decltype(mutex)> lk(mutex);
90
    std::lock_guard<decltype(mutex)> lk(mutex);
170
146
    return !onscreen_buffers.empty();
91
    return static_cast<bool>(current_buffer);
171
147
}
92
}
172
148
93
173
149
void mc::MultiMonitorArbiter::advance_schedule()
94
void mc::MultiMonitorArbiter::advance_schedule()
174
@@ -151,7 +96,7 @@
175
151
    std::lock_guard<decltype(mutex)> lk(mutex);
96
    std::lock_guard<decltype(mutex)> lk(mutex);
176
152
    if (schedule->num_scheduled())
97
    if (schedule->num_scheduled())
177
153
    {
98
    {
179
154
        onscreen_buffers.emplace_front(schedule->next_buffer(), 0);
99
        current_buffer = schedule->next_buffer();
180
155
        current_buffer_users.clear();
100
        current_buffer_users.clear();
181
156
    } 
101
    } 
182
157
}
102
}
183
158
103
184
=== modified file 'src/server/compositor/multi_monitor_arbiter.h'
185
--- src/server/compositor/multi_monitor_arbiter.h	2017-07-28 17:00:43 +0000
186
+++ src/server/compositor/multi_monitor_arbiter.h	2017-08-08 04:14:04 +0000
187
@@ -42,30 +42,15 @@
188
42
    ~MultiMonitorArbiter();
42
    ~MultiMonitorArbiter();
189
43
43
190
44
    std::shared_ptr<graphics::Buffer> compositor_acquire(compositor::CompositorID id) override;
44
    std::shared_ptr<graphics::Buffer> compositor_acquire(compositor::CompositorID id) override;
191
45
    void compositor_release(std::shared_ptr<graphics::Buffer> const&) override;
192
46
    std::shared_ptr<graphics::Buffer> snapshot_acquire() override;
45
    std::shared_ptr<graphics::Buffer> snapshot_acquire() override;
193
47
    void snapshot_release(std::shared_ptr<graphics::Buffer> const&) override;
194
48
    void set_schedule(std::shared_ptr<Schedule> const& schedule);
46
    void set_schedule(std::shared_ptr<Schedule> const& schedule);
195
49
    bool buffer_ready_for(compositor::CompositorID id);
47
    bool buffer_ready_for(compositor::CompositorID id);
196
50
    bool has_buffer();
48
    bool has_buffer();
197
51
    void advance_schedule();
49
    void advance_schedule();
198
52
50
199
53
private:
51
private:
200
54
    void decrease_refcount_for(graphics::BufferID id, std::lock_guard<std::mutex> const&);
201
55
    void clean_onscreen_buffers(std::lock_guard<std::mutex> const&);
202
56
203
57
    std::mutex mutable mutex;
52
    std::mutex mutable mutex;
215
58
    struct ScheduleEntry
53
    std::shared_ptr<graphics::Buffer> current_buffer;
205
59
    {
206
60
        ScheduleEntry(std::shared_ptr<graphics::Buffer> const& buffer, unsigned int use_count) :
207
61
            buffer(buffer),
208
62
            use_count(use_count)
209
63
        {
210
64
        }
211
65
        std::shared_ptr<graphics::Buffer> buffer;
212
66
        unsigned int use_count;
213
67
    };
214
68
    std::deque<ScheduleEntry> onscreen_buffers;
216
69
    std::set<compositor::CompositorID> current_buffer_users;
54
    std::set<compositor::CompositorID> current_buffer_users;
217
70
    std::shared_ptr<Schedule> schedule;
55
    std::shared_ptr<Schedule> schedule;
218
71
};
56
};
219
72
57
220
=== modified file 'src/server/compositor/stream.cpp'
221
--- src/server/compositor/stream.cpp	2017-08-08 04:14:03 +0000
222
+++ src/server/compositor/stream.cpp	2017-08-08 04:14:04 +0000
223
@@ -20,7 +20,6 @@
224
20
#include "stream.h"
20
#include "stream.h"
225
21
#include "queueing_schedule.h"
21
#include "queueing_schedule.h"
226
22
#include "dropping_schedule.h"
22
#include "dropping_schedule.h"
227
23
#include "temporary_buffers.h"
228
24
#include "mir/graphics/buffer.h"
23
#include "mir/graphics/buffer.h"
229
25
#include <boost/throw_exception.hpp>
24
#include <boost/throw_exception.hpp>
230
26
25
231
@@ -73,8 +72,7 @@
232
73
void mc::Stream::with_most_recent_buffer_do(std::function<void(mg::Buffer&)> const& fn)
72
void mc::Stream::with_most_recent_buffer_do(std::function<void(mg::Buffer&)> const& fn)
233
74
{
73
{
234
75
    std::lock_guard<decltype(mutex)> lk(mutex); 
74
    std::lock_guard<decltype(mutex)> lk(mutex); 
237
76
    TemporarySnapshotBuffer buffer(arbiter);
75
    fn(*arbiter->snapshot_acquire());
236
77
    fn(buffer);
238
78
}
76
}
239
79
77
240
80
MirPixelFormat mc::Stream::pixel_format() const
78
MirPixelFormat mc::Stream::pixel_format() const
241
@@ -96,7 +94,7 @@
242
96
94
243
97
std::shared_ptr<mg::Buffer> mc::Stream::lock_compositor_buffer(void const* id)
95
std::shared_ptr<mg::Buffer> mc::Stream::lock_compositor_buffer(void const* id)
244
98
{
96
{
246
99
    return std::make_shared<mc::TemporaryCompositorBuffer>(arbiter, id);
97
    return arbiter->compositor_acquire(id);
247
100
}
98
}
248
101
99
249
102
geom::Size mc::Stream::stream_size()
100
geom::Size mc::Stream::stream_size()
250
103
101
251
=== removed file 'src/server/compositor/temporary_buffers.cpp'
252
--- src/server/compositor/temporary_buffers.cpp	2017-07-28 17:00:43 +0000
253
+++ src/server/compositor/temporary_buffers.cpp	1970-01-01 00:00:00 +0000
254
@@ -1,81 +0,0 @@
255
1
/*
256
2
 * Copyright © 2012 Canonical Ltd.
257
3
 *
258
4
 * This program is free software: you can redistribute it and/or modify it
259
5
 * under the terms of the GNU General Public License version 2 or 3,
260
6
 * as published by the Free Software Foundation.
261
7
 *
262
8
 * This program is distributed in the hope that it will be useful,
263
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
264
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
265
11
 * GNU General Public License for more details.
266
12
 *
267
13
 * You should have received a copy of the GNU General Public License
268
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
269
15
 *
270
16
 * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
271
17
 */
272
18
273
19
#include "buffer_acquisition.h"
274
20
#include "temporary_buffers.h"
275
21
276
22
#include <boost/throw_exception.hpp>
277
23
#include <stdexcept>
278
24
279
25
namespace mc=mir::compositor;
280
26
namespace mg=mir::graphics;
281
27
namespace geom=mir::geometry;
282
28
283
29
mc::TemporaryBuffer::TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer)
284
30
    : buffer(real_buffer)
285
31
{
286
32
}
287
33
288
34
mc::TemporaryCompositorBuffer::TemporaryCompositorBuffer(
289
35
    std::shared_ptr<BufferAcquisition> const& acquisition, void const* user_id)
290
36
    : TemporaryBuffer(acquisition->compositor_acquire(user_id)),
291
37
      acquisition(acquisition)
292
38
{
293
39
}
294
40
295
41
mc::TemporaryCompositorBuffer::~TemporaryCompositorBuffer()
296
42
{
297
43
    acquisition->compositor_release(buffer);
298
44
}
299
45
300
46
mc::TemporarySnapshotBuffer::TemporarySnapshotBuffer(
301
47
    std::shared_ptr<BufferAcquisition> const& acquisition)
302
48
    : TemporaryBuffer(acquisition->snapshot_acquire()),
303
49
      acquisition(acquisition)
304
50
{
305
51
}
306
52
307
53
mc::TemporarySnapshotBuffer::~TemporarySnapshotBuffer()
308
54
{
309
55
    acquisition->snapshot_release(buffer);
310
56
}
311
57
312
58
geom::Size mc::TemporaryBuffer::size() const
313
59
{
314
60
    return buffer->size();
315
61
}
316
62
317
63
MirPixelFormat mc::TemporaryBuffer::pixel_format() const
318
64
{
319
65
    return buffer->pixel_format();
320
66
}
321
67
322
68
mg::BufferID mc::TemporaryBuffer::id() const
323
69
{
324
70
    return buffer->id();
325
71
}
326
72
327
73
std::shared_ptr<mg::NativeBuffer> mc::TemporaryBuffer::native_buffer_handle() const
328
74
{
329
75
    return buffer->native_buffer_handle();
330
76
}
331
77
332
78
mg::NativeBufferBase* mc::TemporaryBuffer::native_buffer_base()
333
79
{
334
80
    return buffer->native_buffer_base();
335
81
}
336
82
0
337
=== removed file 'src/server/compositor/temporary_buffers.h'
338
--- src/server/compositor/temporary_buffers.h	2017-07-28 17:00:43 +0000
339
+++ src/server/compositor/temporary_buffers.h	1970-01-01 00:00:00 +0000
340
@@ -1,74 +0,0 @@
341
1
/*
342
2
 * Copyright © 2012 Canonical Ltd.
343
3
 *
344
4
 * This program is free software: you can redistribute it and/or modify it
345
5
 * under the terms of the GNU General Public License version 2 or 3,
346
6
 * as published by the Free Software Foundation.
347
7
 *
348
8
 * This program is distributed in the hope that it will be useful,
349
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
350
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
351
11
 * GNU General Public License for more details.
352
12
 *
353
13
 * You should have received a copy of the GNU General Public License
354
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
355
15
 *
356
16
 * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
357
17
 */
358
18
359
19
#ifndef MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_
360
20
#define MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_
361
21
362
22
#include "mir/graphics/buffer.h"
363
23
#include "mir/graphics/buffer_id.h"
364
24
365
25
namespace mg = mir::graphics;
366
26
367
27
namespace mir
368
28
{
369
29
namespace compositor
370
30
{
371
31
372
32
class BufferAcquisition;
373
33
class BackBufferStrategy;
374
34
375
35
class TemporaryBuffer : public mg::Buffer
376
36
{
377
37
public:
378
38
    geometry::Size size() const override;
379
39
    MirPixelFormat pixel_format() const override;
380
40
    mg::BufferID id() const override;
381
41
    std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const override;
382
42
    graphics::NativeBufferBase* native_buffer_base() override;
383
43
384
44
protected:
385
45
    explicit TemporaryBuffer(std::shared_ptr<mg::Buffer> const& real_buffer);
386
46
    std::shared_ptr<mg::Buffer> const buffer;
387
47
};
388
48
389
49
class TemporaryCompositorBuffer : public TemporaryBuffer
390
50
{
391
51
public:
392
52
    explicit TemporaryCompositorBuffer(
393
53
        std::shared_ptr<BufferAcquisition> const& acquisition, void const* user_id);
394
54
    ~TemporaryCompositorBuffer();
395
55
396
56
private:
397
57
    std::shared_ptr<BufferAcquisition> const acquisition;
398
58
};
399
59
400
60
class TemporarySnapshotBuffer : public TemporaryBuffer
401
61
{
402
62
public:
403
63
    explicit TemporarySnapshotBuffer(
404
64
        std::shared_ptr<BufferAcquisition> const& acquisition);
405
65
    ~TemporarySnapshotBuffer();
406
66
407
67
private:
408
68
    std::shared_ptr<BufferAcquisition> const acquisition;
409
69
};
410
70
411
71
}
412
72
}
413
73
414
74
#endif /* MIR_COMPOSITOR_TEMPORARY_BUFFERS_H_ */
415
75
0
416
=== modified file 'tests/integration-tests/test_buffer_scheduling.cpp'
417
--- tests/integration-tests/test_buffer_scheduling.cpp	2017-07-28 17:00:43 +0000
418
+++ tests/integration-tests/test_buffer_scheduling.cpp	2017-08-08 04:14:04 +0000
419
@@ -24,7 +24,6 @@
420
24
#include "src/client/protobuf_to_native_buffer.h"
24
#include "src/client/protobuf_to_native_buffer.h"
421
25
#include "src/client/connection_surface_map.h"
25
#include "src/client/connection_surface_map.h"
422
26
#include "src/server/compositor/stream.h"
26
#include "src/server/compositor/stream.h"
423
27
#include "src/server/compositor/temporary_buffers.h"
424
28
#include "mir/test/doubles/stub_client_buffer_factory.h"
27
#include "mir/test/doubles/stub_client_buffer_factory.h"
425
29
#include "mir/test/doubles/mock_client_buffer_factory.h"
28
#include "mir/test/doubles/mock_client_buffer_factory.h"
426
30
#include "mir/test/doubles/stub_buffer_allocator.h"
29
#include "mir/test/doubles/stub_buffer_allocator.h"
427
@@ -454,22 +453,49 @@
428
454
    return never_blocks; 
453
    return never_blocks; 
429
455
}
454
}
430
456
455
432
457
class AutoSendBuffer : public mc::TemporaryBuffer
456
class AutoSendBuffer : public mg::Buffer
433
458
{
457
{
434
459
public:
458
public:
435
460
    AutoSendBuffer(
459
    AutoSendBuffer(
436
461
        std::shared_ptr<mg::Buffer> const& wrapped,
460
        std::shared_ptr<mg::Buffer> const& wrapped,
437
462
        std::shared_ptr<mf::BufferSink> const& sink)
461
        std::shared_ptr<mf::BufferSink> const& sink)
439
463
        : TemporaryBuffer(wrapped),
462
        : wrapped{wrapped},
440
464
          sink{sink}
463
          sink{sink}
441
465
    {
464
    {
442
466
    }
465
    }
443
467
466
444
468
    ~AutoSendBuffer()
467
    ~AutoSendBuffer()
445
469
    {
468
    {
448
470
        sink->update_buffer(*buffer);
469
        sink->update_buffer(*wrapped);
449
471
    }
470
    }
450
471
451
472
    std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const override
452
473
    {
453
474
        return wrapped->native_buffer_handle();
454
475
    }
455
476
456
477
    mg::BufferID id() const override
457
478
    {
458
479
        return wrapped->id();
459
480
    }
460
481
461
482
    geom::Size size() const override
462
483
    {
463
484
        return wrapped->size();
464
485
    }
465
486
466
487
    MirPixelFormat pixel_format() const override
467
488
    {
468
489
        return wrapped->pixel_format();
469
490
    }
470
491
471
492
    mg::NativeBufferBase *native_buffer_base() override
472
493
    {
473
494
        return wrapped->native_buffer_base();
474
495
    }
475
496
476
472
private:
497
private:
477
498
    std::shared_ptr<mg::Buffer> const wrapped;
478
473
    std::shared_ptr<mf::BufferSink> const sink;
499
    std::shared_ptr<mf::BufferSink> const sink;
479
474
};
500
};
480
475
501
481
@@ -1175,7 +1201,6 @@
482
1175
        producer->produce();
1201
        producer->produce();
483
1176
        a = consumer->consume_resource();
1202
        a = consumer->consume_resource();
484
1177
        b = consumer->consume_resource();
1203
        b = consumer->consume_resource();
485
1178
        EXPECT_THAT(a, Ne(b));
486
1179
    }
1204
    }
487
1180
    a.reset();
1205
    a.reset();
488
1181
    b.reset();
1206
    b.reset();
489
@@ -1214,7 +1239,6 @@
490
1214
    {
1239
    {
491
1215
        first = consumer->consume_resource();
1240
        first = consumer->consume_resource();
492
1216
        second = consumer->consume_resource();
1241
        second = consumer->consume_resource();
493
1217
        EXPECT_THAT(first, Ne(second)); 
494
1218
        producer->produce();
1242
        producer->produce();
495
1219
    }
1243
    }
496
1220
1244
497
1221
1245
498
=== modified file 'tests/unit-tests/compositor/CMakeLists.txt'
499
--- tests/unit-tests/compositor/CMakeLists.txt	2017-07-04 04:06:59 +0000
500
+++ tests/unit-tests/compositor/CMakeLists.txt	2017-08-08 04:14:04 +0000
501
@@ -1,7 +1,6 @@
502
1
list(APPEND UNIT_TEST_SOURCES
1
list(APPEND UNIT_TEST_SOURCES
503
2
  ${CMAKE_CURRENT_SOURCE_DIR}/test_default_display_buffer_compositor.cpp
2
  ${CMAKE_CURRENT_SOURCE_DIR}/test_default_display_buffer_compositor.cpp
504
3
  ${CMAKE_CURRENT_SOURCE_DIR}/test_stream.cpp
3
  ${CMAKE_CURRENT_SOURCE_DIR}/test_stream.cpp
505
4
  ${CMAKE_CURRENT_SOURCE_DIR}/test_temporary_buffers.cpp
506
5
  ${CMAKE_CURRENT_SOURCE_DIR}/test_multi_threaded_compositor.cpp
4
  ${CMAKE_CURRENT_SOURCE_DIR}/test_multi_threaded_compositor.cpp
507
6
  ${CMAKE_CURRENT_SOURCE_DIR}/test_occlusion.cpp
5
  ${CMAKE_CURRENT_SOURCE_DIR}/test_occlusion.cpp
508
7
  ${CMAKE_CURRENT_SOURCE_DIR}/test_screencast_display_buffer.cpp
6
  ${CMAKE_CURRENT_SOURCE_DIR}/test_screencast_display_buffer.cpp
509
8
7
510
=== modified file 'tests/unit-tests/compositor/test_multi_monitor_arbiter.cpp'
511
--- tests/unit-tests/compositor/test_multi_monitor_arbiter.cpp	2017-08-08 04:14:03 +0000
512
+++ tests/unit-tests/compositor/test_multi_monitor_arbiter.cpp	2017-08-08 04:14:04 +0000
513
@@ -21,7 +21,6 @@
514
21
#include "mir/test/doubles/stub_buffer_allocator.h"
21
#include "mir/test/doubles/stub_buffer_allocator.h"
515
22
#include "src/server/compositor/multi_monitor_arbiter.h"
22
#include "src/server/compositor/multi_monitor_arbiter.h"
516
23
#include "src/server/compositor/schedule.h"
23
#include "src/server/compositor/schedule.h"
517
24
#include "src/server/compositor/temporary_buffers.h"
518
25
24
519
26
#include <gtest/gtest.h>
25
#include <gtest/gtest.h>
520
27
using namespace testing;
26
using namespace testing;
521
@@ -83,13 +82,13 @@
522
83
    std::shared_ptr<mg::Buffer> const& buffer,
82
    std::shared_ptr<mg::Buffer> const& buffer,
523
84
    std::shared_ptr<bool> const& destroyed)
83
    std::shared_ptr<bool> const& destroyed)
524
85
{
84
{
526
86
    class DestructionNotifyingBuffer : public mc::TemporaryBuffer
85
    class DestructionNotifyingBuffer : public mg::Buffer
527
87
    {
86
    {
528
88
    public:
87
    public:
529
89
        DestructionNotifyingBuffer(
88
        DestructionNotifyingBuffer(
530
90
            std::shared_ptr<mg::Buffer> const& buffer,
89
            std::shared_ptr<mg::Buffer> const& buffer,
531
91
            std::shared_ptr<bool> const& destroyed)
90
            std::shared_ptr<bool> const& destroyed)
533
92
            : TemporaryBuffer(buffer),
91
            : wrapped{buffer},
534
93
              destroyed{destroyed}
92
              destroyed{destroyed}
535
94
        {
93
        {
536
95
        }
94
        }
537
@@ -98,7 +97,34 @@
538
98
        {
97
        {
539
99
            *destroyed = true;
98
            *destroyed = true;
540
100
        }
99
        }
541
100
542
101
        std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const override
543
102
        {
544
103
            return wrapped->native_buffer_handle();
545
104
        }
546
105
547
106
        mg::BufferID id() const override
548
107
        {
549
108
            return wrapped->id();
550
109
        }
551
110
552
111
        mir::geometry::Size size() const override
553
112
        {
554
113
            return wrapped->size();
555
114
        }
556
115
557
116
        MirPixelFormat pixel_format() const override
558
117
        {
559
118
            return wrapped->pixel_format();
560
119
        }
561
120
562
121
        mg::NativeBufferBase *native_buffer_base() override
563
122
        {
564
123
            return wrapped->native_buffer_base();
565
124
        }
566
125
567
101
    private:
126
    private:
568
127
        std::shared_ptr<mg::Buffer> const wrapped;
569
102
        std::shared_ptr<bool> const destroyed;
128
        std::shared_ptr<bool> const destroyed;
570
103
    };
129
    };
571
104
130
572
@@ -133,7 +159,6 @@
573
133
159
574
134
    auto cbuffer = arbiter.compositor_acquire(this);
160
    auto cbuffer = arbiter.compositor_acquire(this);
575
135
    schedule.set_schedule({buffers[1]});
161
    schedule.set_schedule({buffers[1]});
576
136
    arbiter.compositor_release(cbuffer);
577
137
    cbuffer.reset();
162
    cbuffer.reset();
578
138
    // We need to acquire a new buffer - the current one is on-screen, so can't be sent back.
163
    // We need to acquire a new buffer - the current one is on-screen, so can't be sent back.
579
139
    arbiter.compositor_acquire(this);
164
    arbiter.compositor_acquire(this);
580
@@ -182,22 +207,17 @@
581
182
{
207
{
582
183
    schedule.set_schedule({buffers[0],buffers[1],buffers[2],buffers[3],buffers[4]});
208
    schedule.set_schedule({buffers[0],buffers[1],buffers[2],buffers[3],buffers[4]});
583
184
209
594
185
    auto cbuffer1 = arbiter.compositor_acquire(this);
210
    auto id1 = arbiter.compositor_acquire(this)->id();
595
186
    arbiter.compositor_release(cbuffer1);
211
    auto id2 = arbiter.compositor_acquire(this)->id();
596
187
    auto cbuffer2 = arbiter.compositor_acquire(this);
212
    auto id3 = arbiter.compositor_acquire(this)->id();
597
188
    arbiter.compositor_release(cbuffer2);
213
    auto id4 = arbiter.compositor_acquire(this)->id();
598
189
    auto cbuffer3 = arbiter.compositor_acquire(this);
214
    auto iddqd = arbiter.compositor_acquire(this)->id();
589
190
    arbiter.compositor_release(cbuffer3);
590
191
    auto cbuffer4 = arbiter.compositor_acquire(this);
591
192
    arbiter.compositor_release(cbuffer4);
592
193
    auto cbuffer5 = arbiter.compositor_acquire(this);
593
194
    arbiter.compositor_release(cbuffer5);
599
195
215
605
196
    EXPECT_THAT(cbuffer1, IsSameBufferAs(buffers[0]));
216
    EXPECT_THAT(id1, Eq(buffers[0]->id()));
606
197
    EXPECT_THAT(cbuffer2, IsSameBufferAs(buffers[1]));
217
    EXPECT_THAT(id2, Eq(buffers[1]->id()));
607
198
    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[2]));
218
    EXPECT_THAT(id3, Eq(buffers[2]->id()));
608
199
    EXPECT_THAT(cbuffer4, IsSameBufferAs(buffers[3]));
219
    EXPECT_THAT(id4, Eq(buffers[3]->id()));
609
200
    EXPECT_THAT(cbuffer5, IsSameBufferAs(buffers[4]));
220
    EXPECT_THAT(iddqd, Eq(buffers[4]->id()));
610
201
}
221
}
611
202
222
612
203
TEST_F(MultiMonitorArbiter, compositor_consumes_all_buffers_when_operating_as_a_bypassed_buffer_would)
223
TEST_F(MultiMonitorArbiter, compositor_consumes_all_buffers_when_operating_as_a_bypassed_buffer_would)
613
@@ -206,20 +226,28 @@
614
206
226
615
207
    auto cbuffer1 = arbiter.compositor_acquire(this);
227
    auto cbuffer1 = arbiter.compositor_acquire(this);
616
208
    auto cbuffer2 = arbiter.compositor_acquire(this);
228
    auto cbuffer2 = arbiter.compositor_acquire(this);
618
209
    arbiter.compositor_release(cbuffer1);
229
    auto id1 = cbuffer1->id();
619
230
    cbuffer1.reset();
620
231
621
210
    auto cbuffer3 = arbiter.compositor_acquire(this);
232
    auto cbuffer3 = arbiter.compositor_acquire(this);
623
211
    arbiter.compositor_release(cbuffer2);
233
    auto id2 = cbuffer2->id();
624
234
    cbuffer2.reset();
625
235
626
212
    auto cbuffer4 = arbiter.compositor_acquire(this);
236
    auto cbuffer4 = arbiter.compositor_acquire(this);
628
213
    arbiter.compositor_release(cbuffer3);
237
    auto id3 = cbuffer3->id();
629
238
    cbuffer3.reset();
630
239
631
214
    auto cbuffer5 = arbiter.compositor_acquire(this);
240
    auto cbuffer5 = arbiter.compositor_acquire(this);
634
215
    arbiter.compositor_release(cbuffer4);
241
    auto id4 = cbuffer4->id();
635
216
    arbiter.compositor_release(cbuffer5);
242
    cbuffer4.reset();
636
243
    auto id5 = cbuffer5->id();
637
244
    cbuffer5.reset();
638
217
245
644
218
    EXPECT_THAT(cbuffer1, IsSameBufferAs(buffers[0]));
246
    EXPECT_THAT(id1, Eq(buffers[0]->id()));
645
219
    EXPECT_THAT(cbuffer2, IsSameBufferAs(buffers[1]));
247
    EXPECT_THAT(id2, Eq(buffers[1]->id()));
646
220
    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[2]));
248
    EXPECT_THAT(id3, Eq(buffers[2]->id()));
647
221
    EXPECT_THAT(cbuffer4, IsSameBufferAs(buffers[3]));
249
    EXPECT_THAT(id4, Eq(buffers[3]->id()));
648
222
    EXPECT_THAT(cbuffer5, IsSameBufferAs(buffers[4]));
250
    EXPECT_THAT(id5, Eq(buffers[4]->id()));
649
223
}
251
}
650
224
252
651
225
TEST_F(MultiMonitorArbiter, multimonitor_compositor_buffer_syncs_to_fastest_with_more_queueing)
253
TEST_F(MultiMonitorArbiter, multimonitor_compositor_buffer_syncs_to_fastest_with_more_queueing)
652
@@ -287,8 +315,7 @@
653
287
    auto cbuffer1 = arbiter.compositor_acquire(this);
315
    auto cbuffer1 = arbiter.compositor_acquire(this);
654
288
    auto cbuffer2 = arbiter.compositor_acquire(&that);
316
    auto cbuffer2 = arbiter.compositor_acquire(&that);
655
289
    auto sbuffer1 = arbiter.snapshot_acquire();
317
    auto sbuffer1 = arbiter.snapshot_acquire();
658
290
    arbiter.snapshot_release(sbuffer1);
318
    cbuffer2.reset();
657
291
    arbiter.compositor_release(cbuffer2);
659
292
    cbuffer2 = arbiter.compositor_acquire(&that);
319
    cbuffer2 = arbiter.compositor_acquire(&that);
660
293
320
661
294
    auto sbuffer2 = arbiter.snapshot_acquire();
321
    auto sbuffer2 = arbiter.snapshot_acquire();
662
@@ -302,17 +329,15 @@
663
302
    auto that = 4;
329
    auto that = 4;
664
303
    auto a_few_times = 5u;
330
    auto a_few_times = 5u;
665
304
    auto cbuffer1 = arbiter.compositor_acquire(this);
331
    auto cbuffer1 = arbiter.compositor_acquire(this);
667
305
    std::vector<std::shared_ptr<mg::Buffer>> snapshot_buffers(a_few_times);
332
    std::vector<mg::BufferID> snapshot_buffers(a_few_times);
668
306
    for(auto i = 0u; i < a_few_times; i++)
333
    for(auto i = 0u; i < a_few_times; i++)
669
307
    {
334
    {
673
308
        auto b = arbiter.snapshot_acquire();
335
        snapshot_buffers[i] = arbiter.snapshot_acquire()->id();
671
309
        arbiter.snapshot_release(b);
672
310
        snapshot_buffers[i] = b;
674
311
    }
336
    }
675
312
    auto cbuffer2 = arbiter.compositor_acquire(&that);
337
    auto cbuffer2 = arbiter.compositor_acquire(&that);
676
313
338
677
314
    EXPECT_THAT(cbuffer1, IsSameBufferAs(cbuffer2));
339
    EXPECT_THAT(cbuffer1, IsSameBufferAs(cbuffer2));
679
315
    EXPECT_THAT(snapshot_buffers, Each(IsSameBufferAs(cbuffer1)));
340
    EXPECT_THAT(snapshot_buffers, Each(Eq(cbuffer1->id())));
680
316
}
341
}
681
317
342
682
318
TEST_F(MultiMonitorArbiter, no_buffers_available_throws_on_snapshot)
343
TEST_F(MultiMonitorArbiter, no_buffers_available_throws_on_snapshot)
683
@@ -333,14 +358,12 @@
684
333
        });
358
        });
685
334
    auto cbuffer1 = arbiter.compositor_acquire(this);
359
    auto cbuffer1 = arbiter.compositor_acquire(this);
686
335
    auto sbuffer1 = arbiter.snapshot_acquire();
360
    auto sbuffer1 = arbiter.snapshot_acquire();
687
336
    arbiter.compositor_release(cbuffer1);
688
337
    cbuffer1.reset();
361
    cbuffer1.reset();
689
338
362
690
339
    // Acquire a new buffer so first one is no longer onscreen.
363
    // Acquire a new buffer so first one is no longer onscreen.
691
340
    arbiter.compositor_acquire(this);
364
    arbiter.compositor_acquire(this);
692
341
365
693
342
    EXPECT_FALSE(*buffer_released);
366
    EXPECT_FALSE(*buffer_released);
694
343
    arbiter.snapshot_release(sbuffer1);
695
344
    sbuffer1.reset();
367
    sbuffer1.reset();
696
345
    EXPECT_TRUE(*buffer_released);
368
    EXPECT_TRUE(*buffer_released);
697
346
}
369
}
698
@@ -361,9 +384,7 @@
699
361
    EXPECT_THAT(cbuffer1, IsSameBufferAs(cbuffer2));
384
    EXPECT_THAT(cbuffer1, IsSameBufferAs(cbuffer2));
700
362
385
701
363
    auto cbuffer3 = arbiter.compositor_acquire(&comp_id1);
386
    auto cbuffer3 = arbiter.compositor_acquire(&comp_id1);
702
364
    arbiter.compositor_release(cbuffer2);
703
365
    EXPECT_FALSE(*buffer_released);
387
    EXPECT_FALSE(*buffer_released);
704
366
    arbiter.compositor_release(cbuffer1);
705
367
    cbuffer1.reset();
388
    cbuffer1.reset();
706
368
    cbuffer2.reset();
389
    cbuffer2.reset();
707
369
    EXPECT_TRUE(*buffer_released);
390
    EXPECT_TRUE(*buffer_released);
708
@@ -375,15 +396,13 @@
709
375
    int comp_id2{0};
396
    int comp_id2{0};
710
376
    schedule.set_schedule({buffers[0],buffers[1]});
397
    schedule.set_schedule({buffers[0],buffers[1]});
711
377
398
716
378
    auto cbuffer1 = arbiter.compositor_acquire(&comp_id1); //buffer[0]
399
    auto id1 = arbiter.compositor_acquire(&comp_id1)->id(); //buffer[0]
717
379
    arbiter.compositor_release(cbuffer1);
400
    auto id2 = arbiter.compositor_acquire(&comp_id2)->id(); //buffer[0]
714
380
    auto cbuffer2 = arbiter.compositor_acquire(&comp_id2); //buffer[0]
715
381
    arbiter.compositor_release(cbuffer2);
718
382
401
719
383
    auto cbuffer3 = arbiter.compositor_acquire(&comp_id1); //buffer[1]
402
    auto cbuffer3 = arbiter.compositor_acquire(&comp_id1); //buffer[1]
720
384
 
403
 
723
385
    EXPECT_THAT(cbuffer1, IsSameBufferAs(cbuffer2));
404
    EXPECT_THAT(id1, Eq(id2));
724
386
    EXPECT_THAT(cbuffer1, IsSameBufferAs(buffers[0]));
405
    EXPECT_THAT(id1, Eq(buffers[0]->id()));
725
387
    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[1]));
406
    EXPECT_THAT(cbuffer3, IsSameBufferAs(buffers[1]));
726
388
}
407
}
727
389
408
728
@@ -407,23 +426,16 @@
729
407
        });
426
        });
730
408
427
731
409
    auto b1 = arbiter.compositor_acquire(&comp_id1);
428
    auto b1 = arbiter.compositor_acquire(&comp_id1);
733
410
    arbiter.compositor_release(b1);
429
    b1.reset();
734
411
    auto b2 = arbiter.compositor_acquire(&comp_id1);
430
    auto b2 = arbiter.compositor_acquire(&comp_id1);
736
412
    arbiter.compositor_release(b2);
431
    b2.reset();
737
413
    auto b3 = arbiter.compositor_acquire(&comp_id1);
432
    auto b3 = arbiter.compositor_acquire(&comp_id1);
738
414
    auto b5 = arbiter.compositor_acquire(&comp_id2);
433
    auto b5 = arbiter.compositor_acquire(&comp_id2);
740
415
    arbiter.compositor_release(b3);
434
    b3.reset();
741
416
    auto b4 = arbiter.compositor_acquire(&comp_id1);
435
    auto b4 = arbiter.compositor_acquire(&comp_id1);
744
417
    arbiter.compositor_release(b5);
436
    b5.reset();
745
418
    arbiter.compositor_release(b4);
437
    b4.reset();
746
419
    auto b6 = arbiter.compositor_acquire(&comp_id1);
438
    auto b6 = arbiter.compositor_acquire(&comp_id1);
747
420
    arbiter.compositor_release(b6);
748
421
749
422
    b1.reset();
750
423
    b2.reset();
751
424
    b3.reset();
752
425
    b4.reset();
753
426
    b5.reset();
754
427
    b6.reset();
439
    b6.reset();
755
428
440
756
429
    EXPECT_THAT(buffer_released, Each(Pointee(true)));
441
    EXPECT_THAT(buffer_released, Each(Pointee(true)));
757
@@ -441,13 +453,12 @@
758
441
    auto b1 = arbiter.compositor_acquire(&comp_id1);
453
    auto b1 = arbiter.compositor_acquire(&comp_id1);
759
442
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
454
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
760
443
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
455
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
762
444
    arbiter.compositor_release(b1);
456
    b1.reset();
763
445
457
764
446
    auto b2 = arbiter.compositor_acquire(&comp_id2);
458
    auto b2 = arbiter.compositor_acquire(&comp_id2);
765
447
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
459
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
766
448
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id2));
460
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id2));
769
449
    arbiter.compositor_release(b2);
461
}
768
450
} 
770
451
462
771
452
TEST_F(MultiMonitorArbiter, other_compositor_ready_status_advances_with_fastest_compositor)
463
TEST_F(MultiMonitorArbiter, other_compositor_ready_status_advances_with_fastest_compositor)
772
453
{
464
{
773
@@ -458,23 +469,19 @@
774
458
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
469
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
775
459
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
470
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
776
460
471
789
461
    auto b1 = arbiter.compositor_acquire(&comp_id1);
472
    arbiter.compositor_acquire(&comp_id1);
790
462
    arbiter.compositor_release(b1);
473
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
791
463
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
474
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
792
464
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
475
793
465
476
    arbiter.compositor_acquire(&comp_id1);
794
466
    b1 = arbiter.compositor_acquire(&comp_id1);
477
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
795
467
    arbiter.compositor_release(b1);
478
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
796
468
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id1));
479
797
469
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
480
    arbiter.compositor_acquire(&comp_id1);
786
470
787
471
    b1 = arbiter.compositor_acquire(&comp_id1);
788
472
    arbiter.compositor_release(b1);
798
473
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
481
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
799
474
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
482
    EXPECT_TRUE(arbiter.buffer_ready_for(&comp_id2));
800
475
483
803
476
    b1 = arbiter.compositor_acquire(&comp_id2);
484
    arbiter.compositor_acquire(&comp_id2);
802
477
    arbiter.compositor_release(b1);
804
478
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
485
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id1));
805
479
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id2));
486
    EXPECT_FALSE(arbiter.buffer_ready_for(&comp_id2));
806
480
}
487
}
807
@@ -497,8 +504,6 @@
808
497
    auto b2 = arbiter.compositor_acquire(&comp_id1);
504
    auto b2 = arbiter.compositor_acquire(&comp_id1);
809
498
    EXPECT_THAT(b1, IsSameBufferAs(buffers[0]));
505
    EXPECT_THAT(b1, IsSameBufferAs(buffers[0]));
810
499
    EXPECT_THAT(b2, IsSameBufferAs(buffers[1]));
506
    EXPECT_THAT(b2, IsSameBufferAs(buffers[1]));
811
500
    arbiter.compositor_release(b1);
812
501
    arbiter.compositor_release(b2);
813
502
    b1.reset();
507
    b1.reset();
814
503
    b2.reset();
508
    b2.reset();
815
504
509
816
@@ -512,20 +517,26 @@
817
512
    schedule.set_schedule({buffers[0], buffers[1], buffers[0], buffers[1]});
517
    schedule.set_schedule({buffers[0], buffers[1], buffers[0], buffers[1]});
818
513
518
819
514
    auto b1 = arbiter.compositor_acquire(&comp_id1);
519
    auto b1 = arbiter.compositor_acquire(&comp_id1);
820
520
    auto id1 = b1->id();
821
515
    auto b2 = arbiter.compositor_acquire(&comp_id1);
521
    auto b2 = arbiter.compositor_acquire(&comp_id1);
823
516
    arbiter.compositor_release(b1);
522
    auto id2 = b2->id();
824
523
825
524
    b1.reset();
826
517
525
827
518
    auto b3 = arbiter.compositor_acquire(&comp_id2);
526
    auto b3 = arbiter.compositor_acquire(&comp_id2);
828
527
    auto id3 = b3->id();
829
519
    auto b4 = arbiter.compositor_acquire(&comp_id2);
528
    auto b4 = arbiter.compositor_acquire(&comp_id2);
839
520
    arbiter.compositor_release(b3);
529
    auto id4 = b4->id();
840
521
530
841
522
    arbiter.compositor_release(b2);
531
    b3.reset();
842
523
    arbiter.compositor_release(b4);
532
843
524
533
    b2.reset();
844
525
    EXPECT_THAT(b1, IsSameBufferAs(buffers[0]));
534
    b4.reset();
845
526
    EXPECT_THAT(b2, IsSameBufferAs(buffers[1]));
535
846
527
    EXPECT_THAT(b3, IsSameBufferAs(buffers[1]));
536
    EXPECT_THAT(id1, Eq(buffers[0]->id()));
847
528
    EXPECT_THAT(b4, IsSameBufferAs(buffers[0]));
537
    EXPECT_THAT(id2, Eq(buffers[1]->id()));
848
538
    EXPECT_THAT(id3, Eq(buffers[1]->id()));
849
539
    EXPECT_THAT(id4, Eq(buffers[0]->id()));
850
529
540
851
530
} 
541
} 
852
531
542
853
@@ -540,22 +551,25 @@
854
540
        buffers[0], buffers[1], buffers[2]});
551
        buffers[0], buffers[1], buffers[2]});
855
541
552
856
542
    auto b1 = arbiter.compositor_acquire(&comp_id1);
553
    auto b1 = arbiter.compositor_acquire(&comp_id1);
857
554
    auto id1 = b1->id();
858
543
    auto b2 = arbiter.compositor_acquire(&comp_id2);
555
    auto b2 = arbiter.compositor_acquire(&comp_id2);
860
544
    arbiter.compositor_release(b1); //send nothing
556
    auto id2 = b2->id();
861
557
    b1.reset();     // Send nothing
862
545
558
863
546
    auto b3 = arbiter.compositor_acquire(&comp_id1);
559
    auto b3 = arbiter.compositor_acquire(&comp_id1);
865
547
    arbiter.compositor_release(b3); //send nothing
560
    auto id3 = b3->id();
866
561
    b3.reset();     // Send nothing
867
548
562
868
549
    auto b4 = arbiter.compositor_acquire(&comp_id2);
563
    auto b4 = arbiter.compositor_acquire(&comp_id2);
870
550
    arbiter.compositor_release(b2); //send 0
564
    auto id4 = b4->id();
871
565
    b2.reset();     // Send 0
872
551
566
873
552
    auto b5 = arbiter.compositor_acquire(&comp_id1);
567
    auto b5 = arbiter.compositor_acquire(&comp_id1);
874
553
    arbiter.compositor_release(b5); //send nothing
875
554
568
880
555
    EXPECT_THAT(b1, IsSameBufferAs(buffers[0]));
569
    EXPECT_THAT(id1, Eq(buffers[0]->id()));
881
556
    EXPECT_THAT(b2, IsSameBufferAs(buffers[0]));
570
    EXPECT_THAT(id2, Eq(buffers[0]->id()));
882
557
    EXPECT_THAT(b3, IsSameBufferAs(buffers[1]));
571
    EXPECT_THAT(id3, Eq(buffers[1]->id()));
883
558
    EXPECT_THAT(b4, IsSameBufferAs(buffers[1]));
572
    EXPECT_THAT(id4, Eq(buffers[1]->id()));
884
559
    EXPECT_THAT(b5, IsSameBufferAs(buffers[2]));
573
    EXPECT_THAT(b5, IsSameBufferAs(buffers[2]));
885
560
}
574
}
886
561
575
887
562
576
888
=== removed file 'tests/unit-tests/compositor/test_temporary_buffers.cpp'
889
--- tests/unit-tests/compositor/test_temporary_buffers.cpp	2017-07-28 17:00:43 +0000
890
+++ tests/unit-tests/compositor/test_temporary_buffers.cpp	1970-01-01 00:00:00 +0000
891
@@ -1,143 +0,0 @@
892
1
/*
893
2
 * Copyright © 2012 Canonical Ltd.
894
3
 *
895
4
 * This program is free software: you can redistribute it and/or modify
896
5
 * it under the terms of the GNU General Public License version 2 or 3 as
897
6
 * published by the Free Software Foundation.
898
7
 *
899
8
 * This program is distributed in the hope that it will be useful,
900
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
901
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
902
11
 * GNU General Public License for more details.
903
12
 *
904
13
 * You should have received a copy of the GNU General Public License
905
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
906
15
 *
907
16
 * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
908
17
 */
909
18
910
19
#include "src/server/compositor/temporary_buffers.h"
911
20
#include "src/server/compositor/buffer_acquisition.h"
912
21
#include "mir/test/doubles/mock_buffer.h"
913
22
#include "mir/test/doubles/stub_buffer.h"
914
23
#include <gtest/gtest.h>
915
24
#include <stdexcept>
916
25
917
26
namespace mtd=mir::test::doubles;
918
27
namespace mg = mir::graphics;
919
28
namespace mc=mir::compositor;
920
29
namespace geom=mir::geometry;
921
30
922
31
namespace
923
32
{
924
33
class TemporaryTestBuffer : public mc::TemporaryBuffer
925
34
{
926
35
public:
927
36
    TemporaryTestBuffer(const std::shared_ptr<mg::Buffer>& buf)
928
37
        : TemporaryBuffer(buf)
929
38
    {
930
39
    }
931
40
};
932
41
933
42
struct MockBufferAcquisition : mc::BufferAcquisition
934
43
{
935
44
    MOCK_METHOD1(compositor_acquire, std::shared_ptr<mg::Buffer>(void const*));
936
45
    MOCK_METHOD1(compositor_release, void(std::shared_ptr<mg::Buffer> const&));
937
46
    MOCK_METHOD0(snapshot_acquire, std::shared_ptr<mg::Buffer>());
938
47
    MOCK_METHOD1(snapshot_release, void(std::shared_ptr<mg::Buffer> const&));
939
48
};
940
49
941
50
class TemporaryBuffersTest : public ::testing::Test
942
51
{
943
52
public:
944
53
    TemporaryBuffersTest()
945
54
        : buffer_size{1024, 768},
946
55
          buffer_stride{1024},
947
56
          buffer_pixel_format{mir_pixel_format_abgr_8888},
948
57
          mock_buffer{std::make_shared<testing::NiceMock<mtd::MockBuffer>>(
949
58
                          buffer_size, buffer_stride, buffer_pixel_format)},
950
59
          mock_acquisition{std::make_shared<testing::NiceMock<MockBufferAcquisition>>()}
951
60
    {
952
61
        using namespace testing;
953
62
        ON_CALL(*mock_acquisition, compositor_acquire(_))
954
63
            .WillByDefault(Return(mock_buffer));
955
64
    }
956
65
957
66
    geom::Size const buffer_size;
958
67
    geom::Stride const buffer_stride;
959
68
    MirPixelFormat const buffer_pixel_format;
960
69
    std::shared_ptr<mtd::MockBuffer> const mock_buffer;
961
70
    std::shared_ptr<MockBufferAcquisition> mock_acquisition;
962
71
};
963
72
}
964
73
965
74
TEST_F(TemporaryBuffersTest, compositor_buffer_acquires_and_releases)
966
75
{
967
76
    using namespace testing;
968
77
    EXPECT_CALL(*mock_acquisition, compositor_acquire(_))
969
78
        .WillOnce(Return(mock_buffer));
970
79
    EXPECT_CALL(*mock_acquisition, compositor_release(_))
971
80
        .Times(1);
972
81
973
82
    mc::TemporaryCompositorBuffer proxy_buffer(mock_acquisition, 0);
974
83
}
975
84
976
85
TEST_F(TemporaryBuffersTest, snapshot_buffer_acquires_and_releases)
977
86
{
978
87
    using namespace testing;
979
88
    EXPECT_CALL(*mock_acquisition, snapshot_acquire())
980
89
        .WillOnce(Return(mock_buffer));
981
90
    EXPECT_CALL(*mock_acquisition, snapshot_release(_))
982
91
        .Times(1);
983
92
984
93
    mc::TemporarySnapshotBuffer proxy_buffer(mock_acquisition);
985
94
}
986
95
987
96
TEST_F(TemporaryBuffersTest, base_test_size)
988
97
{
989
98
    TemporaryTestBuffer proxy_buffer(mock_buffer);
990
99
    EXPECT_CALL(*mock_buffer, size())
991
100
        .Times(1);
992
101
993
102
    geom::Size size;
994
103
    size = proxy_buffer.size();
995
104
    EXPECT_EQ(buffer_size, size);
996
105
}
997
106
998
107
TEST_F(TemporaryBuffersTest, base_test_pixel_format)
999
108
{
1000
109
    TemporaryTestBuffer proxy_buffer(mock_buffer);
1001
110
    EXPECT_CALL(*mock_buffer, pixel_format())
1002
111
        .Times(1);
1003
112
1004
113
    MirPixelFormat pixel_format;
1005
114
    pixel_format = proxy_buffer.pixel_format();
1006
115
    EXPECT_EQ(buffer_pixel_format, pixel_format);
1007
116
}
1008
117
1009
118
TEST_F(TemporaryBuffersTest, base_test_id)
1010
119
{
1011
120
    TemporaryTestBuffer proxy_buffer(mock_buffer);
1012
121
    EXPECT_CALL(*mock_buffer, id())
1013
122
        .Times(1);
1014
123
1015
124
    proxy_buffer.id();
1016
125
}
1017
126
1018
127
TEST_F(TemporaryBuffersTest, base_test_native_buffer_handle)
1019
128
{
1020
129
    TemporaryTestBuffer proxy_buffer(mock_buffer);
1021
130
    EXPECT_CALL(*mock_buffer, native_buffer_handle())
1022
131
        .Times(1);
1023
132
1024
133
    proxy_buffer.native_buffer_handle();
1025
134
}
1026
135
1027
136
TEST_F(TemporaryBuffersTest, forwards_native_buffer_base_to_wrapped_buffer)
1028
137
{
1029
138
    TemporaryTestBuffer proxy_buffer(mock_buffer);
1030
139
    EXPECT_CALL(*mock_buffer, native_buffer_base())
1031
140
        .Times(1);
1032
141
1033
142
    proxy_buffer.native_buffer_base();
1034
143
}
Status:	Merged
Approved by:	Alan Griffiths on 2017-08-16
Approved revision:	no longer in the source branch.
Merged at revision:	4229
Proposed branch:	lp:~raof/mir/further-buffer-plumbing-cleanup
Merge into:	lp:mir
Prerequisite:	lp:~raof/mir/no-ipc-on-compositor-threads
Diff against target:	1034 lines (+171/-490) 11 files modified src/server/compositor/CMakeLists.txt (+0/-1) src/server/compositor/buffer_acquisition.h (+17/-2) src/server/compositor/multi_monitor_arbiter.cpp (+11/-66) src/server/compositor/multi_monitor_arbiter.h (+1/-16) src/server/compositor/stream.cpp (+2/-4) src/server/compositor/temporary_buffers.cpp (+0/-81) src/server/compositor/temporary_buffers.h (+0/-74) tests/integration-tests/test_buffer_scheduling.cpp (+31/-7) tests/unit-tests/compositor/CMakeLists.txt (+0/-1) tests/unit-tests/compositor/test_multi_monitor_arbiter.cpp (+109/-95) tests/unit-tests/compositor/test_temporary_buffers.cpp (+0/-143)
To merge this branch:	bzr merge lp:~raof/mir/further-buffer-plumbing-cleanup
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Approve on 2017-08-16
Alan Griffiths			Approve on 2017-07-21
Brandon Schaefer (community)		2017-07-07	Approve on 2017-07-20
Review via email: mp+326987@code.launchpad.net