1
=== modified file 'src/client/buffer_stream.cpp'
2
--- src/client/buffer_stream.cpp	2016-06-02 05:33:50 +0000
3
+++ src/client/buffer_stream.cpp	2016-06-02 13:02:31 +0000
4
@@ -181,6 +181,14 @@
5
181
        }
181
        }
6
182
        if (next_buffer_wait_handle.is_pending())
182
        if (next_buffer_wait_handle.is_pending())
7
183
            next_buffer_wait_handle.result_received();
183
            next_buffer_wait_handle.result_received();
8
184
9
185
        while (!incoming_buffers.empty())
10
186
        {
11
187
            auto b = incoming_buffers.front();
12
188
            for (auto i = 0; i < b.fd_size(); i++)
13
189
                close(b.fd(i));
14
190
            incoming_buffers.pop();
15
191
        }
16
184
    }
192
    }
17
185
193
18
186
    void set_size(geom::Size) override
194
    void set_size(geom::Size) override
19
@@ -299,6 +307,8 @@
20
299
        geom::Size size, MirPixelFormat format, int usage,
307
        geom::Size size, MirPixelFormat format, int usage,
21
300
        unsigned int initial_nbuffers) :
308
        unsigned int initial_nbuffers) :
22
301
        vault(factory, mirbuffer_factory, requests, surface_map, size, format, usage, initial_nbuffers),
309
        vault(factory, mirbuffer_factory, requests, surface_map, size, format, usage, initial_nbuffers),
23
310
        current(nullptr),
24
311
        future(vault.withdraw()),
25
302
        size_(size)
312
        size_(size)
26
303
    {
313
    {
27
304
    }
314
    }
28
@@ -310,9 +320,9 @@
29
310
    void advance_current_buffer(std::unique_lock<std::mutex>& lk)
320
    void advance_current_buffer(std::unique_lock<std::mutex>& lk)
30
311
    {
321
    {
31
312
        lk.unlock();
322
        lk.unlock();
33
313
        auto buffer = vault.withdraw().get();
323
        auto c = future.get();
34
314
        lk.lock();
324
        lk.lock();
36
315
        current = buffer;
325
        current = c;
37
316
    }
326
    }
38
317
327
39
318
    std::shared_ptr<mir::client::ClientBuffer> current_buffer() override
328
    std::shared_ptr<mir::client::ClientBuffer> current_buffer() override
40
@@ -336,18 +346,16 @@
41
336
        std::unique_lock<std::mutex> lk(mutex);
346
        std::unique_lock<std::mutex> lk(mutex);
42
337
        if (!current)
347
        if (!current)
43
338
            advance_current_buffer(lk);
348
            advance_current_buffer(lk);
44
349
        auto c = current;
45
350
        current = nullptr;
46
339
        lk.unlock();
351
        lk.unlock();
47
340
352
54
341
        vault.deposit(current);
353
        vault.deposit(c);
55
342
354
        auto wh = vault.wire_transfer_outbound(c, done);
56
343
        next_buffer_wait_handle.expect_result();
355
        auto f = vault.withdraw();
51
344
        vault.wire_transfer_outbound(current);
52
345
        next_buffer_wait_handle.result_received();
53
346
57
347
        lk.lock();
356
        lk.lock();
61
348
        advance_current_buffer(lk);
357
        future = std::move(f);
62
349
        done();
358
        return wh;
60
350
        return &next_buffer_wait_handle;
63
351
    }
359
    }
64
352
360
65
353
    void set_size(geom::Size size) override
361
    void set_size(geom::Size size) override
66
@@ -398,7 +406,7 @@
67
398
    mcl::BufferVault vault;
406
    mcl::BufferVault vault;
68
399
    std::mutex mutable mutex;
407
    std::mutex mutable mutex;
69
400
    std::shared_ptr<mcl::Buffer> current{nullptr};
408
    std::shared_ptr<mcl::Buffer> current{nullptr};
71
401
    MirWaitHandle next_buffer_wait_handle;
409
    mir::client::NoTLSFuture<std::shared_ptr<mcl::Buffer>> future;
72
402
    MirWaitHandle scale_wait_handle;
410
    MirWaitHandle scale_wait_handle;
73
403
    int current_swap_interval = 1;
411
    int current_swap_interval = 1;
74
404
    geom::Size size_;
412
    geom::Size size_;
75
405
413
76
=== modified file 'src/client/buffer_vault.cpp'
77
--- src/client/buffer_vault.cpp	2016-06-02 05:33:50 +0000
78
+++ src/client/buffer_vault.cpp	2016-06-02 13:02:31 +0000
79
@@ -120,12 +120,9 @@
80
120
        BOOST_THROW_EXCEPTION(std::logic_error("no buffer in map"));
120
        BOOST_THROW_EXCEPTION(std::logic_error("no buffer in map"));
81
121
}
121
}
82
122
122
84
123
mcl::NoTLSFuture<std::shared_ptr<mcl::Buffer>> mcl::BufferVault::withdraw()
123
85
124
mcl::BufferVault::BufferMap::iterator mcl::BufferVault::available_buffer()
86
124
{
125
{
87
125
    std::unique_lock<std::mutex> lk(mutex);
88
126
    if (disconnected_)
89
127
        BOOST_THROW_EXCEPTION(std::logic_error("server_disconnected"));
90
128
    mcl::NoTLSPromise<std::shared_ptr<mcl::Buffer>> promise;
91
129
    auto it = std::find_if(buffers.begin(), buffers.end(),
126
    auto it = std::find_if(buffers.begin(), buffers.end(),
92
130
        [this](std::pair<int, Owner> const& entry) {
127
        [this](std::pair<int, Owner> const& entry) {
93
131
            return ((entry.second == Owner::Self) &&
128
            return ((entry.second == Owner::Self) &&
94
@@ -136,7 +133,16 @@
95
136
        [this](std::pair<int, Owner> const& entry) {
133
        [this](std::pair<int, Owner> const& entry) {
96
137
            return ((entry.second == Owner::Self) &&
134
            return ((entry.second == Owner::Self) &&
97
138
                    (checked_buffer_from_map(entry.first)->size() == size)); });
135
                    (checked_buffer_from_map(entry.first)->size() == size)); });
98
136
    return it;
99
137
}
100
139
138
101
139
mcl::NoTLSFuture<std::shared_ptr<mcl::Buffer>> mcl::BufferVault::withdraw()
102
140
{
103
141
    std::unique_lock<std::mutex> lk(mutex);
104
142
    if (disconnected_)
105
143
        BOOST_THROW_EXCEPTION(std::logic_error("server_disconnected"));
106
144
    mcl::NoTLSPromise<std::shared_ptr<mcl::Buffer>> promise;
107
145
    auto it = available_buffer();
108
140
    auto future = promise.get_future();
146
    auto future = promise.get_future();
109
141
    if (it != buffers.end())
147
    if (it != buffers.end())
110
142
    {
148
    {
111
@@ -170,7 +176,8 @@
112
170
    checked_buffer_from_map(it->first)->increment_age();
176
    checked_buffer_from_map(it->first)->increment_age();
113
171
}
177
}
114
172
178
116
173
void mcl::BufferVault::wire_transfer_outbound(std::shared_ptr<mcl::Buffer> const& buffer)
179
MirWaitHandle* mcl::BufferVault::wire_transfer_outbound(
117
180
    std::shared_ptr<mcl::Buffer> const& buffer, std::function<void()> const& done)
118
174
{
181
{
119
175
    std::unique_lock<std::mutex> lk(mutex);
182
    std::unique_lock<std::mutex> lk(mutex);
120
176
    auto it = buffers.find(buffer->rpc_id());
183
    auto it = buffers.find(buffer->rpc_id());
121
@@ -181,6 +188,20 @@
122
181
188
123
182
    buffer->submitted();
189
    buffer->submitted();
124
183
    server_requests->submit_buffer(*buffer);
190
    server_requests->submit_buffer(*buffer);
125
191
126
192
    lk.lock();
127
193
    if (disconnected_)
128
194
        BOOST_THROW_EXCEPTION(std::logic_error("server_disconnected"));
129
195
    if (buffers.end() != available_buffer())
130
196
    {
131
197
        done();
132
198
    }
133
199
    else
134
200
    {
135
201
        next_buffer_wait_handle.expect_result();
136
202
        deferred_cb = done;
137
203
    }
138
204
    return &next_buffer_wait_handle;
139
184
}
205
}
140
185
206
141
186
void mcl::BufferVault::wire_transfer_inbound(int buffer_id)
207
void mcl::BufferVault::wire_transfer_inbound(int buffer_id)
142
@@ -228,13 +249,27 @@
143
228
        promises.front().set_value(buffer);
249
        promises.front().set_value(buffer);
144
229
        promises.pop_front();
250
        promises.pop_front();
145
230
    }
251
    }
146
252
147
253
    trigger_callback(std::move(lk));
148
231
}
254
}
149
232
255
150
233
void mcl::BufferVault::disconnected()
256
void mcl::BufferVault::disconnected()
151
234
{
257
{
153
235
    std::lock_guard<std::mutex> lk(mutex);
258
    std::unique_lock<std::mutex> lk(mutex);
154
236
    disconnected_ = true;
259
    disconnected_ = true;
155
237
    promises.clear();
260
    promises.clear();
156
261
    trigger_callback(std::move(lk));
157
262
}
158
263
159
264
void mcl::BufferVault::trigger_callback(std::unique_lock<std::mutex> lk)
160
265
{
161
266
    if (auto cb = deferred_cb)
162
267
    {
163
268
        deferred_cb = {};
164
269
        lk.unlock();
165
270
        cb();
166
271
        next_buffer_wait_handle.result_received();
167
272
    }
168
238
}
273
}
169
239
274
170
240
void mcl::BufferVault::set_scale(float scale)
275
void mcl::BufferVault::set_scale(float scale)
171
241
276
172
=== modified file 'src/client/buffer_vault.h'
173
--- src/client/buffer_vault.h	2016-06-02 05:33:50 +0000
174
+++ src/client/buffer_vault.h	2016-06-02 13:02:31 +0000
175
@@ -22,6 +22,7 @@
176
22
#include "mir/geometry/size.h"
22
#include "mir/geometry/size.h"
177
23
#include "mir_toolkit/common.h"
23
#include "mir_toolkit/common.h"
178
24
#include "mir_toolkit/mir_native_buffer.h"
24
#include "mir_toolkit/mir_native_buffer.h"
179
25
#include "mir_wait_handle.h"
180
25
#include <memory>
26
#include <memory>
181
26
#include "no_tls_future-inl.h"
27
#include "no_tls_future-inl.h"
182
27
#include <deque>
28
#include <deque>
183
@@ -67,7 +68,8 @@
184
67
    NoTLSFuture<std::shared_ptr<Buffer>> withdraw();
68
    NoTLSFuture<std::shared_ptr<Buffer>> withdraw();
185
68
    void deposit(std::shared_ptr<Buffer> const& buffer);
69
    void deposit(std::shared_ptr<Buffer> const& buffer);
186
69
    void wire_transfer_inbound(int buffer_id);
70
    void wire_transfer_inbound(int buffer_id);
188
70
    void wire_transfer_outbound(std::shared_ptr<Buffer> const& buffer);
71
    MirWaitHandle* wire_transfer_outbound(
189
72
        std::shared_ptr<Buffer> const& buffer, std::function<void()> const&);
190
71
    void set_size(geometry::Size);
73
    void set_size(geometry::Size);
191
72
    void disconnected();
74
    void disconnected();
192
73
    void set_scale(float scale);
75
    void set_scale(float scale);
193
@@ -75,6 +77,11 @@
194
75
    void decrease_buffer_count();
77
    void decrease_buffer_count();
195
76
78
196
77
private:
79
private:
197
80
    enum class Owner;
198
81
    typedef std::map<int, Owner> BufferMap;
199
82
    BufferMap::iterator available_buffer();
200
83
    void trigger_callback(std::unique_lock<std::mutex> lk);
201
84
202
78
    void alloc_buffer(geometry::Size size, MirPixelFormat format, int usage);
85
    void alloc_buffer(geometry::Size size, MirPixelFormat format, int usage);
203
79
    void free_buffer(int free_id);
86
    void free_buffer(int free_id);
204
80
    void realloc_buffer(int free_id, geometry::Size size, MirPixelFormat format, int usage);
87
    void realloc_buffer(int free_id, geometry::Size size, MirPixelFormat format, int usage);
205
@@ -89,9 +96,8 @@
206
89
    MirPixelFormat const format;
96
    MirPixelFormat const format;
207
90
    int const usage;
97
    int const usage;
208
91
98
209
92
    enum class Owner;
210
93
    std::mutex mutex;
99
    std::mutex mutex;
212
94
    std::map<int, Owner> buffers;
100
    BufferMap buffers;
213
95
    std::deque<NoTLSPromise<std::shared_ptr<Buffer>>> promises;
101
    std::deque<NoTLSPromise<std::shared_ptr<Buffer>>> promises;
214
96
    geometry::Size size;
102
    geometry::Size size;
215
97
    bool disconnected_;
103
    bool disconnected_;
216
@@ -99,6 +105,8 @@
217
99
    size_t needed_buffer_count;
105
    size_t needed_buffer_count;
218
100
    size_t const initial_buffer_count;
106
    size_t const initial_buffer_count;
219
101
    int last_received_id = 0;
107
    int last_received_id = 0;
220
108
    MirWaitHandle next_buffer_wait_handle;
221
109
    std::function<void()> deferred_cb;
222
102
};
110
};
223
103
}
111
}
224
104
}
112
}
225
105
113
226
=== modified file 'src/client/mir_connection.h'
227
--- src/client/mir_connection.h	2016-06-02 05:33:50 +0000
228
+++ src/client/mir_connection.h	2016-06-02 13:02:31 +0000
229
@@ -260,6 +260,7 @@
230
260
260
231
261
    mutable std::mutex mutex; // Protects all members of *this (except release_wait_handles)
261
    mutable std::mutex mutex; // Protects all members of *this (except release_wait_handles)
232
262
262
233
263
    std::shared_ptr<mir::client::ClientPlatform> platform;
234
263
    std::shared_ptr<mir::client::ConnectionSurfaceMap> surface_map;
264
    std::shared_ptr<mir::client::ConnectionSurfaceMap> surface_map;
235
264
    std::shared_ptr<mir::client::AsyncBufferFactory> buffer_factory;
265
    std::shared_ptr<mir::client::AsyncBufferFactory> buffer_factory;
236
265
    std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> const channel;
266
    std::shared_ptr<mir::client::rpc::MirBasicRpcChannel> const channel;
237
@@ -280,7 +281,6 @@
238
280
    int surface_error_id{-1};
281
    int surface_error_id{-1};
239
281
282
240
282
    std::shared_ptr<mir::client::ClientPlatformFactory> const client_platform_factory;
283
    std::shared_ptr<mir::client::ClientPlatformFactory> const client_platform_factory;
241
283
    std::shared_ptr<mir::client::ClientPlatform> platform;
242
284
    std::shared_ptr<mir::client::ClientBufferFactory> client_buffer_factory;
284
    std::shared_ptr<mir::client::ClientBufferFactory> client_buffer_factory;
243
285
    std::shared_ptr<EGLNativeDisplayType> native_display;
285
    std::shared_ptr<EGLNativeDisplayType> native_display;
244
286
286
245
287
287
246
=== modified file 'tests/acceptance-tests/test_client_surface_swap_buffers.cpp'
247
--- tests/acceptance-tests/test_client_surface_swap_buffers.cpp	2016-01-29 08:18:22 +0000
248
+++ tests/acceptance-tests/test_client_surface_swap_buffers.cpp	2016-06-02 13:02:31 +0000
249
@@ -21,13 +21,17 @@
250
21
#include "mir_test_framework/connected_client_with_a_surface.h"
21
#include "mir_test_framework/connected_client_with_a_surface.h"
251
22
#include "mir/test/doubles/null_display_buffer_compositor_factory.h"
22
#include "mir/test/doubles/null_display_buffer_compositor_factory.h"
252
23
#include "mir/test/signal.h"
23
#include "mir/test/signal.h"
253
24
#include "mir/compositor/scene_element.h"
254
25
#include "mir/graphics/renderable.h"
255
26
#include "mir/graphics/cursor.h"
256
24
27
257
25
#include <gtest/gtest.h>
28
#include <gtest/gtest.h>
258
26
29
259
27
namespace mtf = mir_test_framework;
30
namespace mtf = mir_test_framework;
260
28
namespace mt = mir::test;
31
namespace mt = mir::test;
261
29
namespace mtd = mir::test::doubles;
32
namespace mtd = mir::test::doubles;
263
30
33
namespace mc = mir::compositor;
264
34
namespace mg = mir::graphics;
265
31
using namespace testing;
35
using namespace testing;
266
32
36
267
33
namespace
37
namespace
268
@@ -50,6 +54,7 @@
269
50
        ConnectedClientWithASurface::SetUp();
54
        ConnectedClientWithASurface::SetUp();
270
51
    }
55
    }
271
52
};
56
};
272
57
273
53
}
58
}
274
54
59
275
55
TEST_F(SurfaceSwapBuffers, does_not_block_when_surface_is_not_composited)
60
TEST_F(SurfaceSwapBuffers, does_not_block_when_surface_is_not_composited)
276
@@ -67,3 +72,70 @@
277
67
        ASSERT_TRUE(buffers_swapped.wait_for(std::chrono::seconds{20}));
72
        ASSERT_TRUE(buffers_swapped.wait_for(std::chrono::seconds{20}));
278
68
    }
73
    }
279
69
}
74
}
280
75
281
76
namespace
282
77
{
283
78
struct BufferCollectingCompositorFactory : mc::DisplayBufferCompositorFactory
284
79
{
285
80
public:
286
81
    auto create_compositor_for(mg::DisplayBuffer&)
287
82
        -> std::unique_ptr<mc::DisplayBufferCompositor> override
288
83
    {
289
84
        struct CollectingDisplayBufferCompositor : mc::DisplayBufferCompositor
290
85
        {
291
86
            void composite(mc::SceneElementSequence&& seq)
292
87
            {
293
88
                for (auto& s : seq)
294
89
                    buffers.insert(s->renderable()->buffer());
295
90
            }
296
91
            std::set<std::shared_ptr<mg::Buffer>> buffers;
297
92
        };
298
93
299
94
        return std::make_unique<CollectingDisplayBufferCompositor>();
300
95
    }
301
96
};
302
97
303
98
struct SwapBuffersDoesntBlockOnSubmission : mtf::ConnectedClientWithASurface
304
99
{
305
100
    unsigned int figure_out_nbuffers()
306
101
    {
307
102
        auto default_nbuffers = 3u;
308
103
        if (auto server_nbuffers_switch = getenv("MIR_SERVER_NBUFFERS"))
309
104
        {
310
105
            if (server_nbuffers_switch && atoi(server_nbuffers_switch) > 0)
311
106
                return atoi(server_nbuffers_switch);
312
107
            else
313
108
            {
314
109
                auto client_nbuffers_switch = getenv("MIR_CLIENT_NBUFFERS");
315
110
                if (client_nbuffers_switch)
316
111
                    return atoi(client_nbuffers_switch);
317
112
            }
318
113
        }
319
114
        return default_nbuffers;
320
115
    }
321
116
    void SetUp() override
322
117
    {
323
118
        server.override_the_display_buffer_compositor_factory([]
324
119
        {
325
120
            return std::make_shared<BufferCollectingCompositorFactory>();
326
121
        });
327
122
328
123
        ConnectedClientWithASurface::SetUp();
329
124
        server.the_cursor()->hide();
330
125
    }
331
126
332
127
    void TearDown() override
333
128
    {
334
129
        ConnectedClientWithASurface::TearDown();
335
130
    }
336
131
337
132
    unsigned int nbuffers = figure_out_nbuffers();
338
133
};
339
134
}
340
135
341
136
//LP: #1584784
342
137
TEST_F(SwapBuffersDoesntBlockOnSubmission, can_swap_nbuffers_times_without_blocking)
343
138
{
344
139
    for (auto i = 0u; i != nbuffers; ++i)
345
140
        mir_buffer_stream_swap_buffers(mir_surface_get_buffer_stream(surface), nullptr, nullptr);
346
141
}
347
70
142
348
=== modified file 'tests/integration-tests/test_buffer_scheduling.cpp'
349
--- tests/integration-tests/test_buffer_scheduling.cpp	2016-06-02 05:33:50 +0000
350
+++ tests/integration-tests/test_buffer_scheduling.cpp	2016-06-02 13:02:31 +0000
351
@@ -465,7 +465,7 @@
352
465
        {
465
        {
353
466
            auto buffer = vault.withdraw().get();
466
            auto buffer = vault.withdraw().get();
354
467
            vault.deposit(buffer);
467
            vault.deposit(buffer);
356
468
            vault.wire_transfer_outbound(buffer);
468
            vault.wire_transfer_outbound(buffer, []{});
357
469
            last_size_ = buffer->size();
469
            last_size_ = buffer->size();
358
470
            entries.emplace_back(BufferEntry{mg::BufferID{(unsigned int)ipc->last_transferred_to_server()}, age, Access::unblocked});
470
            entries.emplace_back(BufferEntry{mg::BufferID{(unsigned int)ipc->last_transferred_to_server()}, age, Access::unblocked});
359
471
            available--;
471
            available--;
360
472
472
361
=== modified file 'tests/unit-tests/client/test_buffer_vault.cpp'
362
--- tests/unit-tests/client/test_buffer_vault.cpp	2016-06-02 05:33:50 +0000
363
+++ tests/unit-tests/client/test_buffer_vault.cpp	2016-06-02 13:02:31 +0000
364
@@ -208,14 +208,14 @@
365
208
    auto buffer = vault.withdraw().get();
208
    auto buffer = vault.withdraw().get();
366
209
    EXPECT_CALL(mock_requests, submit_buffer(Ref(*buffer)));
209
    EXPECT_CALL(mock_requests, submit_buffer(Ref(*buffer)));
367
210
    vault.deposit(buffer);
210
    vault.deposit(buffer);
369
211
    vault.wire_transfer_outbound(buffer);
211
    vault.wire_transfer_outbound(buffer, []{});
370
212
}
212
}
371
213
213
372
214
TEST_F(StartedBufferVault, cant_transfer_if_not_in_acct)
214
TEST_F(StartedBufferVault, cant_transfer_if_not_in_acct)
373
215
{
215
{
374
216
    auto buffer = vault.withdraw().get();
216
    auto buffer = vault.withdraw().get();
375
217
    EXPECT_THROW({ 
217
    EXPECT_THROW({ 
377
218
        vault.wire_transfer_outbound(buffer);
218
        vault.wire_transfer_outbound(buffer, []{});
378
219
    }, std::logic_error);
219
    }, std::logic_error);
379
220
}
220
}
380
221
221
381
@@ -235,7 +235,7 @@
382
235
{
235
{
383
236
    auto buffer = vault.withdraw().get();
236
    auto buffer = vault.withdraw().get();
384
237
    vault.deposit(buffer);
237
    vault.deposit(buffer);
386
238
    vault.wire_transfer_outbound(buffer);
238
    vault.wire_transfer_outbound(buffer, []{});
387
239
    EXPECT_THROW({
239
    EXPECT_THROW({
388
240
        vault.deposit(buffer);
240
        vault.deposit(buffer);
389
241
    }, std::logic_error);
241
    }, std::logic_error);
390
@@ -247,7 +247,7 @@
391
247
    vault->wire_transfer_inbound(package.buffer_id());
247
    vault->wire_transfer_inbound(package.buffer_id());
392
248
    auto buffer = vault->withdraw().get();
248
    auto buffer = vault->withdraw().get();
393
249
    vault->deposit(buffer);
249
    vault->deposit(buffer);
395
250
    vault->wire_transfer_outbound(buffer);
250
    vault->wire_transfer_outbound(buffer, []{});
396
251
251
397
252
    vault->wire_transfer_inbound(package.buffer_id());
252
    vault->wire_transfer_inbound(package.buffer_id());
398
253
    auto buffer2 = vault->withdraw().get();
253
    auto buffer2 = vault->withdraw().get();
399
@@ -321,7 +321,7 @@
400
321
321
401
322
    auto buffer = vault->withdraw().get();
322
    auto buffer = vault->withdraw().get();
402
323
    vault->deposit(buffer);
323
    vault->deposit(buffer);
404
324
    vault->wire_transfer_outbound(buffer);
324
    vault->wire_transfer_outbound(buffer, []{});
405
325
}
325
}
406
326
326
407
327
TEST_F(StartedBufferVault, reallocates_incoming_buffers_of_incorrect_size_with_immediate_response)
327
TEST_F(StartedBufferVault, reallocates_incoming_buffers_of_incorrect_size_with_immediate_response)
408
@@ -530,19 +530,19 @@
409
530
    vault.wire_transfer_inbound(requested_buffer.buffer_id());
530
    vault.wire_transfer_inbound(requested_buffer.buffer_id());
410
531
    auto b = vault.withdraw().get();
531
    auto b = vault.withdraw().get();
411
532
    vault.deposit(b);
532
    vault.deposit(b);
425
533
    vault.wire_transfer_outbound(b);
533
    vault.wire_transfer_outbound(b, []{});
426
534
534
427
535
    b = vault.withdraw().get();
535
    b = vault.withdraw().get();
428
536
    vault.deposit(b);
536
    vault.deposit(b);
429
537
    vault.wire_transfer_outbound(b);
537
    vault.wire_transfer_outbound(b, []{});
430
538
538
431
539
    b = vault.withdraw().get();
539
    b = vault.withdraw().get();
432
540
    vault.deposit(b);
540
    vault.deposit(b);
433
541
    vault.wire_transfer_outbound(b);
541
    vault.wire_transfer_outbound(b, []{});
434
542
542
435
543
    b = vault.withdraw().get();
543
    b = vault.withdraw().get();
436
544
    vault.deposit(b);
544
    vault.deposit(b);
437
545
    vault.wire_transfer_outbound(b);
545
    vault.wire_transfer_outbound(b, []{});
438
546
546
439
547
    vault.decrease_buffer_count();
547
    vault.decrease_buffer_count();
440
548
    vault.wire_transfer_inbound(package.buffer_id());
548
    vault.wire_transfer_inbound(package.buffer_id());
441
@@ -555,12 +555,12 @@
442
555
{
555
{
443
556
    auto buffer = vault.withdraw().get();
556
    auto buffer = vault.withdraw().get();
444
557
    vault.deposit(buffer);
557
    vault.deposit(buffer);
446
558
    vault.wire_transfer_outbound(buffer);
558
    vault.wire_transfer_outbound(buffer, []{});
447
559
    auto first_id = buffer->rpc_id();
559
    auto first_id = buffer->rpc_id();
448
560
560
449
561
    buffer = vault.withdraw().get();
561
    buffer = vault.withdraw().get();
450
562
    vault.deposit(buffer);
562
    vault.deposit(buffer);
452
563
    vault.wire_transfer_outbound(buffer);
563
    vault.wire_transfer_outbound(buffer, []{});
453
564
    auto second_id = buffer->rpc_id();
564
    auto second_id = buffer->rpc_id();
454
565
565
455
566
    vault.wire_transfer_inbound(second_id);
566
    vault.wire_transfer_inbound(second_id);
456
@@ -593,7 +593,7 @@
457
593
    Mock::VerifyAndClearExpectations(&mock_requests);
593
    Mock::VerifyAndClearExpectations(&mock_requests);
458
594
594
459
595
    vault.deposit(buffer);
595
    vault.deposit(buffer);
461
596
    vault.wire_transfer_outbound(buffer);
596
    vault.wire_transfer_outbound(buffer, []{});
462
597
597
463
598
    EXPECT_CALL(mock_requests, free_buffer(_))
598
    EXPECT_CALL(mock_requests, free_buffer(_))
464
599
        .Times(1);
599
        .Times(1);
465
@@ -610,7 +610,7 @@
466
610
    vault.set_size(new_size);
610
    vault.set_size(new_size);
467
611
    Mock::VerifyAndClearExpectations(&mock_requests);
611
    Mock::VerifyAndClearExpectations(&mock_requests);
468
612
612
470
613
    vault.wire_transfer_outbound(buffer);
613
    vault.wire_transfer_outbound(buffer, []{});
471
614
    EXPECT_CALL(mock_requests, free_buffer(_))
614
    EXPECT_CALL(mock_requests, free_buffer(_))
472
615
        .Times(1);
615
        .Times(1);
473
616
    vault.wire_transfer_inbound(buffer->rpc_id());
616
    vault.wire_transfer_inbound(buffer->rpc_id());
474
@@ -642,7 +642,7 @@
475
642
        auto buffer = vault.withdraw().get();
642
        auto buffer = vault.withdraw().get();
476
643
        vault.deposit(buffer);
643
        vault.deposit(buffer);
477
644
        buffer->received();
644
        buffer->received();
479
645
        vault.wire_transfer_outbound(buffer);
645
        vault.wire_transfer_outbound(buffer, []{});
480
646
        vault.wire_transfer_inbound(buffer->rpc_id());
646
        vault.wire_transfer_inbound(buffer->rpc_id());
481
647
    }
647
    }
482
648
}
648
}
483
649
649
484
=== modified file 'tests/unit-tests/client/test_client_buffer_stream.cpp'
485
--- tests/unit-tests/client/test_client_buffer_stream.cpp	2016-06-02 05:33:50 +0000
486
+++ tests/unit-tests/client/test_client_buffer_stream.cpp	2016-06-02 13:02:31 +0000
487
@@ -789,4 +789,24 @@
488
789
    EXPECT_THAT(stream.get_current_buffer_id(), Eq(10));
789
    EXPECT_THAT(stream.get_current_buffer_id(), Eq(10));
489
790
}
790
}
490
791
791
491
792
//LP: #1584784
492
793
TEST_P(ClientBufferStream, can_cycle_through_available_buffers_without_waiting)
493
794
{
494
795
    ON_CALL(mock_protobuf_server, submit_buffer(_,_,_))
495
796
        .WillByDefault(mtd::RunProtobufClosure());
496
797
    mcl::BufferStream bs{
497
798
        nullptr, wait_handle, mock_protobuf_server,
498
799
        std::make_shared<StubClientPlatform>(mt::fake_shared(stub_factory)),
499
800
        map, factory,
500
801
        response, perf_report, "", size, nbuffers};
501
802
    service_requests_for(bs, mock_protobuf_server.alloc_count);
502
803
503
804
    auto count = 0;
504
805
    for(auto i = 0u; i < mock_protobuf_server.alloc_count; i++)
505
806
    {
506
807
        bs.get_current_buffer();
507
808
        bs.next_buffer([&count]{ count++;});
508
809
    }
509
810
}
510
811
511
792
INSTANTIATE_TEST_CASE_P(BufferSemanticsMode, ClientBufferStream, Bool());
812
INSTANTIATE_TEST_CASE_P(BufferSemanticsMode, ClientBufferStream, Bool());
Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Approve on 2016-06-04
Cemil Azizoglu (community)			Approve on 2016-06-02
Chris Halse Rogers		2016-05-31	Approve on 2016-06-01
Review via email: mp+296106@code.launchpad.net