1
=== modified file 'src/server/compositor/buffer_queue.cpp'
2
--- src/server/compositor/buffer_queue.cpp	2014-05-15 03:53:45 +0000
3
+++ src/server/compositor/buffer_queue.cpp	2014-05-19 07:45:18 +0000
4
@@ -239,13 +239,29 @@
5
239
    if (contains(buffer.get(), buffers_sent_to_compositor))
239
    if (contains(buffer.get(), buffers_sent_to_compositor))
6
240
        return;
240
        return;
7
241
241
8
242
    if (nbuffers <= 1)
9
243
        return;
10
244
11
242
    /*
245
    /*
16
243
     * This buffer is not owned by compositor anymore. If the queue is supposed
246
     * We can't release the current_compositor_buffer because we need to keep
17
244
     * to only own a single buffer (nbuffers == 1), then this is a buffer that
247
     * a compositor buffer always-available. But there might be a new
18
245
     * is no longer used (i.e. replaced by a new resized buffer), so just
248
     * compositor buffer available to take its place immediately. Moving to
19
246
     * discard it.
249
     * that one immediately will free up the old compositor buffer, allowing
20
250
     * us to call back the client with a buffer where otherwise we couldn't.
21
247
     */
251
     */
23
248
    if (current_compositor_buffer != buffer.get() && nbuffers > 1)
252
    if (current_compositor_buffer == buffer.get() &&
24
253
        !ready_to_composite_queue.empty())
25
254
    {
26
255
        current_compositor_buffer = pop(ready_to_composite_queue);
27
256
28
257
        // Ensure current_compositor_buffer gets reused by the next
29
258
        // compositor_acquire:
30
259
        current_buffer_users.clear();
31
260
        void const* const impossible_user_id = this;
32
261
        current_buffer_users.push_back(impossible_user_id);
33
262
    }
34
263
35
264
    if (current_compositor_buffer != buffer.get())
36
249
        release(buffer.get(), std::move(lock));
265
        release(buffer.get(), std::move(lock));
37
250
}
266
}
38
251
267
39
252
268
40
=== modified file 'tests/unit-tests/compositor/test_buffer_queue.cpp'
41
--- tests/unit-tests/compositor/test_buffer_queue.cpp	2014-05-15 03:20:25 +0000
42
+++ tests/unit-tests/compositor/test_buffer_queue.cpp	2014-05-19 07:45:18 +0000
43
@@ -1068,6 +1068,68 @@
44
1068
    q.compositor_release(buf);
1068
    q.compositor_release(buf);
45
1069
}
1069
}
46
1070
1070
47
1071
TEST_F(BufferQueueTest, double_buffered_client_is_not_blocked_prematurely)
48
1072
{  // Regression test for LP: #1319765
49
1073
    using namespace testing;
50
1074
51
1075
    mc::BufferQueue q{2, allocator, basic_properties};
52
1076
53
1077
    q.client_release(client_acquire_sync(q));
54
1078
    auto a = q.compositor_acquire(this);
55
1079
    q.client_release(client_acquire_sync(q));
56
1080
    auto b = q.compositor_acquire(this);
57
1081
58
1082
    ASSERT_NE(a.get(), b.get());
59
1083
60
1084
    q.compositor_release(a);
61
1085
    q.client_release(client_acquire_sync(q));
62
1086
63
1087
    q.compositor_release(b);
64
1088
    auto handle = client_acquire_async(q);
65
1089
    // With the fix, a buffer will be available instantaneously:
66
1090
    ASSERT_TRUE(handle->has_acquired_buffer());
67
1091
    handle->release_buffer();
68
1092
}
69
1093
70
1094
TEST_F(BufferQueueTest, composite_on_demand_never_deadlocks_with_2_buffers)
71
1095
{  // Extended regression test for LP: #1319765
72
1096
    using namespace testing;
73
1097
74
1098
    mc::BufferQueue q{2, allocator, basic_properties};
75
1099
76
1100
    for (int i = 0; i < 100; ++i)
77
1101
    {
78
1102
        auto x = client_acquire_async(q);
79
1103
        ASSERT_TRUE(x->has_acquired_buffer());
80
1104
        x->release_buffer();
81
1105
82
1106
        auto a = q.compositor_acquire(this);
83
1107
84
1108
        auto y = client_acquire_async(q);
85
1109
        ASSERT_TRUE(y->has_acquired_buffer());
86
1110
        y->release_buffer();
87
1111
88
1112
        auto b = q.compositor_acquire(this);
89
1113
    
90
1114
        ASSERT_NE(a.get(), b.get());
91
1115
    
92
1116
        q.compositor_release(a);
93
1117
94
1118
        auto w = client_acquire_async(q);
95
1119
        ASSERT_TRUE(w->has_acquired_buffer());
96
1120
        w->release_buffer();
97
1121
    
98
1122
        q.compositor_release(b);
99
1123
100
1124
        auto z = client_acquire_async(q);
101
1125
        ASSERT_TRUE(z->has_acquired_buffer());
102
1126
        z->release_buffer();
103
1127
104
1128
        q.compositor_release(q.compositor_acquire(this));
105
1129
        q.compositor_release(q.compositor_acquire(this));
106
1130
    }
107
1131
}
108
1132
109
1071
/* Regression test for LP: #1306464 */
1133
/* Regression test for LP: #1306464 */
110
1072
TEST_F(BufferQueueTest, framedropping_client_acquire_does_not_block_when_no_available_buffers)
1134
TEST_F(BufferQueueTest, framedropping_client_acquire_does_not_block_when_no_available_buffers)
111
1073
{
1135
{
Reviewer	Review Type	Date Requested	Status
Kevin DuBois (community)			Approve on 2014-05-19
Alberto Aguirre (community)		2014-05-16	Approve on 2014-05-19
PS Jenkins bot (community)	continuous-integration		Approve on 2014-05-19
Review via email: mp+219806@code.launchpad.net