1
=== modified file 'include/server/mir/time/timer.h'
2
--- include/server/mir/time/timer.h	2015-01-21 07:34:50 +0000
3
+++ include/server/mir/time/timer.h	2015-02-20 17:57:50 +0000
4
@@ -1,5 +1,5 @@
5
1
/*
1
/*
7
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
8
3
 *
3
 *
9
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
10
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
11
@@ -14,6 +14,7 @@
12
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
13
15
 *
15
 *
14
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
15
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
16
17
 */
18
 */
17
18
19
18
19
20
19
@@ -47,7 +48,7 @@
20
47
     * \return A handle to an Alarm that will fire after delay ms.
48
     * \return A handle to an Alarm that will fire after delay ms.
21
48
     */
49
     */
22
49
    virtual std::unique_ptr<Alarm> notify_in(std::chrono::milliseconds delay,
50
    virtual std::unique_ptr<Alarm> notify_in(std::chrono::milliseconds delay,
24
50
                                             std::function<void()> callback) = 0;
51
                                             std::function<void()> const& callback) = 0;
25
51
    /**
52
    /**
26
52
     * \brief Create an Alarm that calls the callback at the specified time
53
     * \brief Create an Alarm that calls the callback at the specified time
27
53
     *
54
     *
28
@@ -57,7 +58,7 @@
29
57
     * \return A handle to an Alarm that will fire after delay ms.
58
     * \return A handle to an Alarm that will fire after delay ms.
30
58
     */
59
     */
31
59
    virtual std::unique_ptr<Alarm> notify_at(Timestamp time_point,
60
    virtual std::unique_ptr<Alarm> notify_at(Timestamp time_point,
33
60
                                             std::function<void()> callback) = 0;
61
                                             std::function<void()> const& callback) = 0;
34
61
    /**
62
    /**
35
62
     * \brief Create an Alarm that will not fire until scheduled
63
     * \brief Create an Alarm that will not fire until scheduled
36
63
     *
64
     *
37
@@ -65,7 +66,30 @@
38
65
     *
66
     *
39
66
     * \return A handle to an Alarm that can later be scheduled
67
     * \return A handle to an Alarm that can later be scheduled
40
67
     */
68
     */
42
68
    virtual std::unique_ptr<Alarm> create_alarm(std::function<void()> callback) = 0;
69
    virtual std::unique_ptr<Alarm> create_alarm(std::function<void()> const& callback) = 0;
43
70
44
71
    /**
45
72
     * \brief Create an Alarm that will not fire until scheduled
46
73
     *
47
74
     * The lock/unlock functions allow the user to preserve lock ordering
48
75
     * in situations where Alarm methods need to be called under external lock
49
76
     * and the callback implementation needs to run code protected by the same
50
77
     * lock. An alarm implementation may have internal locks of its own, which
51
78
     * maybe acquired during callback dispatching; to preserve lock ordering
52
79
     * the given lock function will be invoked during callback dispatch before
53
80
     * any internal locks are acquired.
54
81
     *
55
82
     * \param callback Function to call when the Alarm signals
56
83
     * \param lock     Function called within callback dispatching context
57
84
     *                 before the alarm implementation acquires any internal
58
85
     *                 lock
59
86
     * \param unlock   Function called within callback dispatching context after
60
87
     *                 the alarm implementation releases any internal lock
61
88
     *
62
89
     * \return A handle to an Alarm that can later be scheduled
63
90
     */
64
91
    virtual std::unique_ptr<Alarm> create_alarm(std::function<void()> const& callback,
65
92
        std::function<void()> const& lock, std::function<void()> const& unlock) = 0;
66
69
93
67
70
    Timer(Timer const&) = delete;
94
    Timer(Timer const&) = delete;
68
71
    Timer& operator=(Timer const&) = delete;
95
    Timer& operator=(Timer const&) = delete;
69
72
96
70
=== modified file 'src/include/server/mir/compositor/frame_dropping_policy_factory.h'
71
--- src/include/server/mir/compositor/frame_dropping_policy_factory.h	2015-01-21 07:34:50 +0000
72
+++ src/include/server/mir/compositor/frame_dropping_policy_factory.h	2015-02-20 17:57:50 +0000
73
@@ -1,5 +1,5 @@
74
1
/*
1
/*
76
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
77
3
 *
3
 *
78
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
79
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
80
@@ -14,6 +14,7 @@
81
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
82
15
 *
15
 *
83
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
84
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
85
17
 */
18
 */
86
18
19
87
19
#ifndef MIR_COMPOSITOR_FRAME_DROPPING_POLICY_FACTORY_H_
20
#ifndef MIR_COMPOSITOR_FRAME_DROPPING_POLICY_FACTORY_H_
88
@@ -44,11 +45,27 @@
89
44
    FrameDroppingPolicyFactory& operator=(FrameDroppingPolicyFactory const&) = delete;
45
    FrameDroppingPolicyFactory& operator=(FrameDroppingPolicyFactory const&) = delete;
90
45
46
91
46
    /**
47
    /**
95
47
     * \brief Create a FrameDroppingPolicy that will call \a drop_frame when it decides to drop a frame
48
     * \brief Create a FrameDroppingPolicy that will call \a drop_frame when it
96
48
     * \param drop_frame    Function to call when a frame needs to be dropped
49
     *       decides to drop a frame
97
49
     * \return              The policy object.
50
     *
98
51
     * The lock/unlock functions allow the user to preserve lock ordering
99
52
     * in situations where FrameDroppingPolicy methods need to be called under
100
53
     * external lock and the callback implementation needs to run code protected
101
54
     * by the same lock. A FrameDroppingPolicy implementation may have internal
102
55
     * locks of its own, which maybe acquired during callback dispatching;
103
56
     * to preserve lock ordering the given lock function will be invoked during
104
57
     * callback dispatch before any internal locks are acquired.
105
58
     *
106
59
     * \param drop_frame Function to call when a frame needs to be dropped
107
60
     * \param lock       Function called within the callback dispatcher context
108
61
     *                   before any internal locks are acquired.
109
62
     * \param unlock     Function called within the callback dispatcher context
110
63
     *                   after any internal locks are released.
111
50
     */
64
     */
113
51
    virtual std::unique_ptr<FrameDroppingPolicy> create_policy(std::function<void(void)> drop_frame) const = 0;
65
    virtual std::unique_ptr<FrameDroppingPolicy> create_policy(
114
66
        std::function<void()> const& drop_frame,
115
67
        std::function<void()> const& lock,
116
68
        std::function<void()> const& unlock) const = 0;
117
52
};
69
};
118
53
70
119
54
}
71
}
120
55
72
121
=== modified file 'src/include/server/mir/glib_main_loop.h'
122
--- src/include/server/mir/glib_main_loop.h	2015-01-21 07:34:50 +0000
123
+++ src/include/server/mir/glib_main_loop.h	2015-02-20 17:57:50 +0000
124
@@ -1,5 +1,5 @@
125
1
/*
1
/*
127
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
128
3
 *
3
 *
129
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
130
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
131
@@ -72,14 +72,19 @@
132
72
72
133
73
    std::unique_ptr<mir::time::Alarm> notify_in(
73
    std::unique_ptr<mir::time::Alarm> notify_in(
134
74
        std::chrono::milliseconds delay,
74
        std::chrono::milliseconds delay,
136
75
        std::function<void()> callback) override;
75
        std::function<void()> const& callback) override;
137
76
76
138
77
    std::unique_ptr<mir::time::Alarm> notify_at(
77
    std::unique_ptr<mir::time::Alarm> notify_at(
139
78
        mir::time::Timestamp t,
78
        mir::time::Timestamp t,
144
79
        std::function<void()> callback) override;
79
        std::function<void()> const& callback) override;
145
80
80
146
81
    std::unique_ptr<mir::time::Alarm> create_alarm(
81
    std::unique_ptr<mir::time::Alarm> create_alarm(
147
82
        std::function<void()> callback) override;
82
        std::function<void()> const& callback) override;
148
83
149
84
    std::unique_ptr<mir::time::Alarm> create_alarm(
150
85
        std::function<void()> const& callback,
151
86
        std::function<void()> const& lock,
152
87
        std::function<void()> const& unlock) override;
153
83
88
154
84
    void reprocess_all_sources();
89
    void reprocess_all_sources();
155
85
90
156
86
91
157
=== modified file 'src/include/server/mir/glib_main_loop_sources.h'
158
--- src/include/server/mir/glib_main_loop_sources.h	2015-02-13 06:12:34 +0000
159
+++ src/include/server/mir/glib_main_loop_sources.h	2015-02-20 17:57:50 +0000
160
@@ -1,5 +1,5 @@
161
1
/*
1
/*
163
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
164
3
 *
3
 *
165
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
166
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
167
@@ -74,6 +74,8 @@
168
74
    GMainContext* main_context,
74
    GMainContext* main_context,
169
75
    std::shared_ptr<time::Clock> const& clock,
75
    std::shared_ptr<time::Clock> const& clock,
170
76
    std::function<void()> const& handler,
76
    std::function<void()> const& handler,
171
77
    std::function<void()> const& lock,
172
78
    std::function<void()> const& unlock,
173
77
    time::Timestamp target_time);
79
    time::Timestamp target_time);
174
78
80
175
79
class FdSources
81
class FdSources
176
80
82
177
=== modified file 'src/server/compositor/buffer_queue.cpp'
178
--- src/server/compositor/buffer_queue.cpp	2015-02-17 06:38:35 +0000
179
+++ src/server/compositor/buffer_queue.cpp	2015-02-20 17:57:50 +0000
180
@@ -1,5 +1,5 @@
181
1
/*
1
/*
183
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
184
3
 *
3
 *
185
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
186
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
187
@@ -132,11 +132,18 @@
188
132
    if (nbuffers == 1)
132
    if (nbuffers == 1)
189
133
        free_buffers.push_back(current_compositor_buffer);
133
        free_buffers.push_back(current_compositor_buffer);
190
134
134
191
135
    // A lock_guard will be created by the policy dispatcher invoking the given "lock" lambda
192
136
    // before it acquires any internal locks of its own.
193
135
    framedrop_policy = policy_provider.create_policy([this]
137
    framedrop_policy = policy_provider.create_policy([this]
194
136
    {
138
    {
198
137
       std::unique_lock<decltype(guard)> lock{guard};
139
        // We ignore any ongoing snapshotting as it could lead to deadlock.
199
138
       drop_frame(std::move(lock));
140
        // In order to wait the guard_lock needs to be released; a BufferQueue::release
200
139
    });
141
        // call can sneak in at that time from a different thread which
201
142
        // can invoke framedrop_policy methods
202
143
        drop_frame(guard_lock, ignore_snapshot);
203
144
    },
204
145
    [this] { guard_lock = std::move(std::unique_lock<decltype(guard)>{guard}); },
205
146
    [this] { if (guard_lock.owns_lock()) guard_lock.unlock(); });
206
140
}
147
}
207
141
148
208
142
void mc::BufferQueue::client_acquire(mc::BufferQueue::Callback complete)
149
void mc::BufferQueue::client_acquire(mc::BufferQueue::Callback complete)
209
@@ -149,7 +156,7 @@
210
149
    {
156
    {
211
150
        auto const buffer = free_buffers.back();
157
        auto const buffer = free_buffers.back();
212
151
        free_buffers.pop_back();
158
        free_buffers.pop_back();
214
152
        give_buffer_to_client(buffer, std::move(lock));
159
        give_buffer_to_client(buffer, lock);
215
153
        return;
160
        return;
216
154
    }
161
    }
217
155
162
218
@@ -162,14 +169,14 @@
219
162
    {
169
    {
220
163
        auto const& buffer = gralloc->alloc_buffer(the_properties);
170
        auto const& buffer = gralloc->alloc_buffer(the_properties);
221
164
        buffers.push_back(buffer);
171
        buffers.push_back(buffer);
223
165
        give_buffer_to_client(buffer.get(), std::move(lock));
172
        give_buffer_to_client(buffer.get(), lock);
224
166
        return;
173
        return;
225
167
    }
174
    }
226
168
175
227
169
    /* Last resort, drop oldest buffer from the ready queue */
176
    /* Last resort, drop oldest buffer from the ready queue */
228
170
    if (frame_dropping_enabled)
177
    if (frame_dropping_enabled)
229
171
    {
178
    {
231
172
        drop_frame(std::move(lock));
179
        drop_frame(lock, wait_for_snapshot);
232
173
        return;
180
        return;
233
174
    }
181
    }
234
175
182
235
@@ -323,7 +330,7 @@
236
323
        {
330
        {
237
324
            free_buffers.push_back(pop(ready_to_composite_queue));
331
            free_buffers.push_back(pop(ready_to_composite_queue));
238
325
        }
332
        }
240
326
        give_buffer_to_client(buffer, std::move(lock));
333
        give_buffer_to_client(buffer, lock, ignore_snapshot);
241
327
    }
334
    }
242
328
}
335
}
243
329
336
244
@@ -363,7 +370,15 @@
245
363
370
246
364
void mc::BufferQueue::give_buffer_to_client(
371
void mc::BufferQueue::give_buffer_to_client(
247
365
    mg::Buffer* buffer,
372
    mg::Buffer* buffer,
249
366
    std::unique_lock<std::mutex> lock)
373
    std::unique_lock<std::mutex>& lock)
250
374
{
251
375
    give_buffer_to_client(buffer, lock, wait_for_snapshot);
252
376
}
253
377
254
378
void mc::BufferQueue::give_buffer_to_client(
255
379
    mg::Buffer* buffer,
256
380
    std::unique_lock<std::mutex>& lock,
257
381
    SnapshotWait wait_type)
258
367
{
382
{
259
368
    /* Clears callback */
383
    /* Clears callback */
260
369
    auto give_to_client_cb = std::move(pending_client_notifications.front());
384
    auto give_to_client_cb = std::move(pending_client_notifications.front());
261
@@ -383,7 +398,7 @@
262
383
    }
398
    }
263
384
399
264
385
    /* Don't give to the client just yet if there's a pending snapshot */
400
    /* Don't give to the client just yet if there's a pending snapshot */
266
386
    if (!resize_buffer && contains(buffer, pending_snapshots))
401
    if (wait_type == wait_for_snapshot && !resize_buffer && contains(buffer, pending_snapshots))
267
387
    {
402
    {
268
388
        snapshot_released.wait(lock,
403
        snapshot_released.wait(lock,
269
389
            [&]{ return !contains(buffer, pending_snapshots); });
404
            [&]{ return !contains(buffer, pending_snapshots); });
270
@@ -420,7 +435,7 @@
271
420
    if (!pending_client_notifications.empty())
435
    if (!pending_client_notifications.empty())
272
421
    {
436
    {
273
422
        framedrop_policy->swap_unblocked();
437
        framedrop_policy->swap_unblocked();
275
423
        give_buffer_to_client(buffer, std::move(lock));
438
        give_buffer_to_client(buffer, lock);
276
424
    }
439
    }
277
425
    else if (!frame_dropping_enabled && buffers.size() > size_t(nbuffers))
440
    else if (!frame_dropping_enabled && buffers.size() > size_t(nbuffers))
278
426
    {
441
    {
279
@@ -446,7 +461,7 @@
280
446
        free_buffers.push_back(buffer);
461
        free_buffers.push_back(buffer);
281
447
}
462
}
282
448
463
284
449
void mc::BufferQueue::drop_frame(std::unique_lock<std::mutex> lock)
464
void mc::BufferQueue::drop_frame(std::unique_lock<std::mutex>& lock, SnapshotWait wait_type)
285
450
{
465
{
286
451
    // Make sure there is a client waiting for the frame before we drop it.
466
    // Make sure there is a client waiting for the frame before we drop it.
287
452
    // If not, then there's nothing to do.
467
    // If not, then there's nothing to do.
288
@@ -498,7 +513,7 @@
289
498
        buffer_to_give = buffer.get();
513
        buffer_to_give = buffer.get();
290
499
    }
514
    }
291
500
        
515
        
293
501
    give_buffer_to_client(buffer_to_give, std::move(lock));
516
    give_buffer_to_client(buffer_to_give, lock, wait_type);
294
502
}
517
}
295
503
518
296
504
void mc::BufferQueue::drop_old_buffers()
519
void mc::BufferQueue::drop_old_buffers()
297
505
520
298
=== modified file 'src/server/compositor/buffer_queue.h'
299
--- src/server/compositor/buffer_queue.h	2015-01-21 08:53:28 +0000
300
+++ src/server/compositor/buffer_queue.h	2015-02-20 17:57:50 +0000
301
@@ -1,5 +1,5 @@
302
1
/*
1
/*
304
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
305
3
 *
3
 *
306
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
307
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
308
@@ -66,13 +66,21 @@
309
66
    void drop_client_requests() override;
66
    void drop_client_requests() override;
310
67
67
311
68
private:
68
private:
314
69
    void give_buffer_to_client(graphics::Buffer* buffer,
69
    enum SnapshotWait
315
70
        std::unique_lock<std::mutex> lock);
70
    {
316
71
        wait_for_snapshot,
317
72
        ignore_snapshot
318
73
    };
319
74
    void give_buffer_to_client(graphics::Buffer* buffer,
320
75
        std::unique_lock<std::mutex>& lock);
321
76
    void give_buffer_to_client(graphics::Buffer* buffer,
322
77
        std::unique_lock<std::mutex>& lock, SnapshotWait wait_type);
323
71
    void release(graphics::Buffer* buffer,
78
    void release(graphics::Buffer* buffer,
324
72
        std::unique_lock<std::mutex> lock);
79
        std::unique_lock<std::mutex> lock);
326
73
    void drop_frame(std::unique_lock<std::mutex> lock);
80
    void drop_frame(std::unique_lock<std::mutex>& lock, SnapshotWait wait_type);
327
74
81
328
75
    mutable std::mutex guard;
82
    mutable std::mutex guard;
329
83
    std::unique_lock<decltype(guard)> guard_lock;
330
76
84
331
77
    std::vector<std::shared_ptr<graphics::Buffer>> buffers;
85
    std::vector<std::shared_ptr<graphics::Buffer>> buffers;
332
78
    std::deque<graphics::Buffer*> ready_to_composite_queue;
86
    std::deque<graphics::Buffer*> ready_to_composite_queue;
333
79
87
334
=== modified file 'src/server/compositor/timeout_frame_dropping_policy_factory.cpp'
335
--- src/server/compositor/timeout_frame_dropping_policy_factory.cpp	2015-02-17 11:58:56 +0000
336
+++ src/server/compositor/timeout_frame_dropping_policy_factory.cpp	2015-02-20 17:57:50 +0000
337
@@ -1,5 +1,5 @@
338
1
/*
1
/*
340
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
341
3
 *
3
 *
342
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
343
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
344
@@ -14,6 +14,7 @@
345
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
346
15
 *
15
 *
347
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
348
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
349
17
 */
18
 */
350
18
19
351
19
#include "mir/compositor/frame_dropping_policy.h"
20
#include "mir/compositor/frame_dropping_policy.h"
352
@@ -34,7 +35,9 @@
353
34
public:
35
public:
354
35
    TimeoutFrameDroppingPolicy(std::shared_ptr<mir::time::Timer> const& timer,
36
    TimeoutFrameDroppingPolicy(std::shared_ptr<mir::time::Timer> const& timer,
355
36
                               std::chrono::milliseconds timeout,
37
                               std::chrono::milliseconds timeout,
357
37
                               std::function<void(void)> drop_frame);
38
                               std::function<void()> const& drop_frame,
358
39
                               std::function<void()> const& lock,
359
40
                               std::function<void()> const& unlock);
360
38
41
361
39
    void swap_now_blocking() override;
42
    void swap_now_blocking() override;
362
40
    void swap_unblocked() override;
43
    void swap_unblocked() override;
363
@@ -50,7 +53,9 @@
364
50
53
365
51
TimeoutFrameDroppingPolicy::TimeoutFrameDroppingPolicy(std::shared_ptr<mir::time::Timer> const& timer,
54
TimeoutFrameDroppingPolicy::TimeoutFrameDroppingPolicy(std::shared_ptr<mir::time::Timer> const& timer,
366
52
                                                       std::chrono::milliseconds timeout,
55
                                                       std::chrono::milliseconds timeout,
368
53
                                                       std::function<void(void)> drop_frame)
56
                                                       std::function<void()> const& drop_frame,
369
57
                                                       std::function<void()> const& lock,
370
58
                                                       std::function<void()> const& unlock)
371
54
    : timeout{timeout},
59
    : timeout{timeout},
372
55
      pending_swaps{0},
60
      pending_swaps{0},
373
56
      alarm{timer->create_alarm([this, drop_frame]
61
      alarm{timer->create_alarm([this, drop_frame]
374
@@ -59,7 +64,7 @@
375
59
            drop_frame();
64
            drop_frame();
376
60
            if (--pending_swaps > 0)
65
            if (--pending_swaps > 0)
377
61
                alarm->reschedule_in(this->timeout);
66
                alarm->reschedule_in(this->timeout);
379
62
        })}
67
        }, lock, unlock)}
380
63
{
68
{
381
64
}
69
}
382
65
70
383
@@ -81,15 +86,18 @@
384
81
}
86
}
385
82
}
87
}
386
83
88
389
84
mc::TimeoutFrameDroppingPolicyFactory::TimeoutFrameDroppingPolicyFactory(std::shared_ptr<mir::time::Timer> const& timer,
89
mc::TimeoutFrameDroppingPolicyFactory::TimeoutFrameDroppingPolicyFactory(
390
85
                                                                         std::chrono::milliseconds timeout)
90
    std::shared_ptr<mir::time::Timer> const& timer,
391
91
    std::chrono::milliseconds timeout)
392
86
    : timer{timer},
92
    : timer{timer},
393
87
      timeout{timeout}
93
      timeout{timeout}
394
88
{
94
{
395
89
}
95
}
396
90
96
399
91
97
std::unique_ptr<mc::FrameDroppingPolicy>
400
92
std::unique_ptr<mc::FrameDroppingPolicy> mc::TimeoutFrameDroppingPolicyFactory::create_policy(std::function<void ()> drop_frame) const
98
mc::TimeoutFrameDroppingPolicyFactory::create_policy(std::function<void()> const& drop_frame,
401
99
    std::function<void()> const& lock,
402
100
    std::function<void()> const& unlock) const
403
93
{
101
{
405
94
    return std::make_unique<TimeoutFrameDroppingPolicy>(timer, timeout, drop_frame);
102
    return std::make_unique<TimeoutFrameDroppingPolicy>(timer, timeout, drop_frame, lock, unlock);
406
95
}
103
}
407
96
104
408
=== modified file 'src/server/compositor/timeout_frame_dropping_policy_factory.h'
409
--- src/server/compositor/timeout_frame_dropping_policy_factory.h	2014-05-22 20:48:20 +0000
410
+++ src/server/compositor/timeout_frame_dropping_policy_factory.h	2015-02-20 17:57:50 +0000
411
@@ -1,5 +1,5 @@
412
1
/*
1
/*
414
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
415
3
 *
3
 *
416
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
417
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
418
@@ -14,6 +14,7 @@
419
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
420
15
 *
15
 *
421
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
422
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
423
17
 */
18
 */
424
18
19
425
19
20
426
@@ -44,7 +45,10 @@
427
44
    TimeoutFrameDroppingPolicyFactory(std::shared_ptr<mir::time::Timer> const& timer,
45
    TimeoutFrameDroppingPolicyFactory(std::shared_ptr<mir::time::Timer> const& timer,
428
45
                                      std::chrono::milliseconds timeout);
46
                                      std::chrono::milliseconds timeout);
429
46
47
431
47
    std::unique_ptr<FrameDroppingPolicy> create_policy(std::function<void(void)> drop_frame) const override;
48
    std::unique_ptr<FrameDroppingPolicy> create_policy(
432
49
        std::function<void()> const& drop_frame,
433
50
        std::function<void()> const& lock,
434
51
        std::function<void()> const& unlock) const override;
435
48
private:
52
private:
436
49
    std::shared_ptr<mir::time::Timer> const timer;
53
    std::shared_ptr<mir::time::Timer> const timer;
437
50
    std::chrono::milliseconds timeout;
54
    std::chrono::milliseconds timeout;
438
51
55
439
=== modified file 'src/server/glib_main_loop.cpp'
440
--- src/server/glib_main_loop.cpp	2015-02-17 11:58:56 +0000
441
+++ src/server/glib_main_loop.cpp	2015-02-20 17:57:50 +0000
442
@@ -1,5 +1,5 @@
443
1
/*
1
/*
445
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
446
3
 *
3
 *
447
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
448
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
449
@@ -14,6 +14,7 @@
450
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
451
15
 *
15
 *
452
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
453
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
454
17
 */
18
 */
455
18
19
456
19
#include "mir/glib_main_loop.h"
20
#include "mir/glib_main_loop.h"
457
@@ -33,10 +34,14 @@
458
33
    AlarmImpl(
34
    AlarmImpl(
459
34
        GMainContext* main_context,
35
        GMainContext* main_context,
460
35
        std::shared_ptr<mir::time::Clock> const& clock,
36
        std::shared_ptr<mir::time::Clock> const& clock,
462
36
        std::function<void()> const& callback)
37
        std::function<void()> const& callback,
463
38
        std::function<void()> const& lock,
464
39
        std::function<void()> const& unlock)
465
37
        : main_context{main_context},
40
        : main_context{main_context},
466
38
          clock{clock},
41
          clock{clock},
467
39
          callback{callback},
42
          callback{callback},
468
43
          ext_lock{lock},
469
44
          ext_unlock{unlock},
470
40
          state_{State::cancelled}
45
          state_{State::cancelled}
471
41
    {
46
    {
472
42
    }
47
    }
473
@@ -70,6 +75,8 @@
474
70
            main_context,
75
            main_context,
475
71
            clock,
76
            clock,
476
72
            [&] { state_ = State::triggered; callback(); },
77
            [&] { state_ = State::triggered; callback(); },
477
78
            ext_lock,
478
79
            ext_unlock,
479
73
            time_point);
80
            time_point);
480
74
81
481
75
        return true;
82
        return true;
482
@@ -80,6 +87,8 @@
483
80
    GMainContext* main_context;
87
    GMainContext* main_context;
484
81
    std::shared_ptr<mir::time::Clock> const clock;
88
    std::shared_ptr<mir::time::Clock> const clock;
485
82
    std::function<void()> const callback;
89
    std::function<void()> const callback;
486
90
    std::function<void()> const ext_lock;
487
91
    std::function<void()> const ext_unlock;
488
83
    State state_;
92
    State state_;
489
84
    mir::detail::GSourceHandle gsource;
93
    mir::detail::GSourceHandle gsource;
490
85
};
94
};
491
@@ -223,7 +232,7 @@
492
223
232
493
224
std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::notify_in(
233
std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::notify_in(
494
225
    std::chrono::milliseconds delay,
234
    std::chrono::milliseconds delay,
496
226
    std::function<void()> callback)
235
    std::function<void()> const& callback)
497
227
{
236
{
498
228
    auto alarm = create_alarm(callback);
237
    auto alarm = create_alarm(callback);
499
229
238
500
@@ -234,7 +243,7 @@
501
234
243
502
235
std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::notify_at(
244
std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::notify_at(
503
236
    mir::time::Timestamp t,
245
    mir::time::Timestamp t,
505
237
    std::function<void()> callback)
246
    std::function<void()> const& callback)
506
238
{
247
{
507
239
    auto alarm = create_alarm(callback);
248
    auto alarm = create_alarm(callback);
508
240
249
509
@@ -244,7 +253,15 @@
510
244
}
253
}
511
245
254
512
246
std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::create_alarm(
255
std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::create_alarm(
514
247
    std::function<void()> callback)
256
    std::function<void()> const& callback)
515
257
{
516
258
    return create_alarm(callback, []{}, []{});
517
259
}
518
260
519
261
std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::create_alarm(
520
262
    std::function<void()> const& callback,
521
263
    std::function<void()> const& lock,
522
264
    std::function<void()> const& unlock)
523
248
{
265
{
524
249
    auto const callback_with_exception_handling =
266
    auto const callback_with_exception_handling =
525
250
        [this, callback]
267
        [this, callback]
526
@@ -254,7 +271,7 @@
527
254
        };
271
        };
528
255
272
529
256
    return std::make_unique<AlarmImpl>(
273
    return std::make_unique<AlarmImpl>(
531
257
        main_context, clock, callback_with_exception_handling);
274
        main_context, clock, callback_with_exception_handling, lock, unlock);
532
258
}
275
}
533
259
276
534
260
void mir::GLibMainLoop::reprocess_all_sources()
277
void mir::GLibMainLoop::reprocess_all_sources()
535
261
278
536
=== modified file 'src/server/glib_main_loop_sources.cpp'
537
--- src/server/glib_main_loop_sources.cpp	2015-02-13 06:12:34 +0000
538
+++ src/server/glib_main_loop_sources.cpp	2015-02-20 17:57:50 +0000
539
@@ -1,5 +1,5 @@
540
1
/*
1
/*
542
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
543
3
 *
3
 *
544
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
545
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
546
@@ -14,11 +14,13 @@
547
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
548
15
 *
15
 *
549
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
550
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
551
17
 */
18
 */
552
18
19
553
19
#include "mir/glib_main_loop_sources.h"
20
#include "mir/glib_main_loop_sources.h"
554
20
#include "mir/recursive_read_write_mutex.h"
21
#include "mir/recursive_read_write_mutex.h"
555
21
#include "mir/thread_safe_list.h"
22
#include "mir/thread_safe_list.h"
556
23
#include "mir/raii.h"
557
22
24
558
23
#include <algorithm>
25
#include <algorithm>
559
24
#include <atomic>
26
#include <atomic>
560
@@ -233,18 +235,25 @@
561
233
    GMainContext* main_context,
235
    GMainContext* main_context,
562
234
    std::shared_ptr<time::Clock> const& clock,
236
    std::shared_ptr<time::Clock> const& clock,
563
235
    std::function<void()> const& handler,
237
    std::function<void()> const& handler,
564
238
    std::function<void()> const& lock,
565
239
    std::function<void()> const& unlock,
566
236
    time::Timestamp target_time)
240
    time::Timestamp target_time)
567
237
{
241
{
568
238
    struct TimerContext
242
    struct TimerContext
569
239
    {
243
    {
570
240
        TimerContext(std::shared_ptr<time::Clock> const& clock,
244
        TimerContext(std::shared_ptr<time::Clock> const& clock,
571
241
                     std::function<void()> const& handler,
245
                     std::function<void()> const& handler,
572
246
                     std::function<void()> const& lock,
573
247
                     std::function<void()> const& unlock,
574
242
                     time::Timestamp target_time)
248
                     time::Timestamp target_time)
576
243
            : clock{clock}, handler{handler}, target_time{target_time}, enabled{true}
249
            : clock{clock}, handler{handler}, lock{lock}, unlock{unlock},
577
250
              target_time{target_time}, enabled{true}
578
244
        {
251
        {
579
245
        }
252
        }
580
246
        std::shared_ptr<time::Clock> clock;
253
        std::shared_ptr<time::Clock> clock;
581
247
        std::function<void()> handler;
254
        std::function<void()> handler;
582
255
        std::function<void()> lock;
583
256
        std::function<void()> unlock;
584
248
        time::Timestamp target_time;
257
        time::Timestamp target_time;
585
249
        bool enabled;
258
        bool enabled;
586
250
        mir::RecursiveReadWriteMutex mutex;
259
        mir::RecursiveReadWriteMutex mutex;
587
@@ -284,6 +293,9 @@
588
284
        {
293
        {
589
285
            auto& ctx = reinterpret_cast<TimerGSource*>(source)->ctx;
294
            auto& ctx = reinterpret_cast<TimerGSource*>(source)->ctx;
590
286
295
591
296
            // Caller may pass std::function objects to preserve locking
592
297
            // order during callback dispatching, so aquire them first.
593
298
            auto caller_lock = mir::raii::paired_calls(std::ref(ctx.lock), std::ref(ctx.unlock));
594
287
            RecursiveReadLock lock{ctx.mutex};
299
            RecursiveReadLock lock{ctx.mutex};
595
288
            if (ctx.enabled)
300
            if (ctx.enabled)
596
289
                ctx.handler();
301
                ctx.handler();
597
@@ -321,7 +333,7 @@
598
321
    auto const timer_gsource = reinterpret_cast<TimerGSource*>(static_cast<GSource*>(gsource));
333
    auto const timer_gsource = reinterpret_cast<TimerGSource*>(static_cast<GSource*>(gsource));
599
322
334
600
323
    timer_gsource->ctx_constructed = false;
335
    timer_gsource->ctx_constructed = false;
602
324
    new (&timer_gsource->ctx) TimerContext{clock, handler, target_time};
336
    new (&timer_gsource->ctx) TimerContext{clock, handler, lock, unlock, target_time};
603
325
    timer_gsource->ctx_constructed = true;
337
    timer_gsource->ctx_constructed = true;
604
326
338
605
327
    g_source_attach(gsource, main_context);
339
    g_source_attach(gsource, main_context);
606
328
340
607
=== modified file 'tests/include/mir_test_doubles/mock_frame_dropping_policy_factory.h'
608
--- tests/include/mir_test_doubles/mock_frame_dropping_policy_factory.h	2014-05-22 20:48:20 +0000
609
+++ tests/include/mir_test_doubles/mock_frame_dropping_policy_factory.h	2015-02-20 17:57:50 +0000
610
@@ -1,5 +1,5 @@
611
1
/*
1
/*
613
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
614
3
 *
3
 *
615
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
616
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
617
@@ -14,6 +14,7 @@
618
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
619
15
 *
15
 *
620
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
621
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
622
17
 */
18
 */
623
18
19
624
19
20
625
@@ -23,6 +24,8 @@
626
23
#include "mir/compositor/frame_dropping_policy_factory.h"
24
#include "mir/compositor/frame_dropping_policy_factory.h"
627
24
#include "mir/compositor/frame_dropping_policy.h"
25
#include "mir/compositor/frame_dropping_policy.h"
628
25
26
629
27
#include "mir_test/gmock_fixes.h"
630
28
631
26
#include <unordered_set>
29
#include <unordered_set>
632
27
#include <functional>
30
#include <functional>
633
28
31
634
@@ -42,7 +45,9 @@
635
42
class MockFrameDroppingPolicy : public mc::FrameDroppingPolicy
45
class MockFrameDroppingPolicy : public mc::FrameDroppingPolicy
636
43
{
46
{
637
44
public:
47
public:
639
45
    MockFrameDroppingPolicy(std::function<void(void)> callback,
48
    MockFrameDroppingPolicy(std::function<void()> const& callback,
640
49
                            std::function<void()> const& lock,
641
50
                            std::function<void()> const& unlock,
642
46
                            MockFrameDroppingPolicyFactory const* parent);
51
                            MockFrameDroppingPolicyFactory const* parent);
643
47
    ~MockFrameDroppingPolicy();
52
    ~MockFrameDroppingPolicy();
644
48
53
645
@@ -55,14 +60,19 @@
646
55
    friend class MockFrameDroppingPolicyFactory;
60
    friend class MockFrameDroppingPolicyFactory;
647
56
    void parent_destroyed();
61
    void parent_destroyed();
648
57
62
650
58
    std::function<void(void)> callback;
63
    std::function<void()> callback;
651
64
    std::function<void()> lock;
652
65
    std::function<void()> unlock;
653
59
    MockFrameDroppingPolicyFactory const* parent;
66
    MockFrameDroppingPolicyFactory const* parent;
654
60
};
67
};
655
61
68
656
62
class MockFrameDroppingPolicyFactory : public mc::FrameDroppingPolicyFactory
69
class MockFrameDroppingPolicyFactory : public mc::FrameDroppingPolicyFactory
657
63
{
70
{
658
64
public:
71
public:
660
65
    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(std::function<void(void)> drop_frame) const override;
72
    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(
661
73
        std::function<void()> const& drop_frame,
662
74
        std::function<void()> const& lock,
663
75
        std::function<void()> const& unlock) const override;
664
66
76
665
67
    ~MockFrameDroppingPolicyFactory();
77
    ~MockFrameDroppingPolicyFactory();
666
68
78
667
@@ -75,6 +85,15 @@
668
75
    mutable std::unordered_set<MockFrameDroppingPolicy*> policies;
85
    mutable std::unordered_set<MockFrameDroppingPolicy*> policies;
669
76
};
86
};
670
77
87
671
88
class FrameDroppingPolicyFactoryMock : public mc::FrameDroppingPolicyFactory
672
89
{
673
90
public:
674
91
    MOCK_CONST_METHOD3(create_policy, std::unique_ptr<mc::FrameDroppingPolicy>(
675
92
                     std::function<void()> const&,
676
93
                     std::function<void()> const&,
677
94
                     std::function<void()> const&));
678
95
};
679
96
680
78
}
97
}
681
79
}
98
}
682
80
}
99
}
683
81
100
684
=== modified file 'tests/include/mir_test_doubles/mock_main_loop.h'
685
--- tests/include/mir_test_doubles/mock_main_loop.h	2014-06-24 14:12:25 +0000
686
+++ tests/include/mir_test_doubles/mock_main_loop.h	2015-02-20 17:57:50 +0000
687
@@ -1,5 +1,5 @@
688
1
/*
1
/*
690
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
691
3
 *
3
 *
692
4
 * This program is free software: you can redistribute it and/or modify
4
 * This program is free software: you can redistribute it and/or modify
693
5
 * it under the terms of the GNU General Public License version 3 as
5
 * it under the terms of the GNU General Public License version 3 as
694
@@ -52,11 +52,19 @@
695
52
    MOCK_METHOD1(pause_processing_for,void (void const*));
52
    MOCK_METHOD1(pause_processing_for,void (void const*));
696
53
    MOCK_METHOD1(resume_processing_for,void (void const*));
53
    MOCK_METHOD1(resume_processing_for,void (void const*));
697
54
54
703
55
    MOCK_METHOD2(notify_in, std::unique_ptr<time::Alarm>(std::chrono::milliseconds delay,
55
    MOCK_METHOD2(notify_in,
704
56
                                           std::function<void(void)> callback));
56
                 std::unique_ptr<time::Alarm>(std::chrono::milliseconds delay,
705
57
    MOCK_METHOD2(notify_at, std::unique_ptr<time::Alarm>(time::Timestamp time_point,
57
                                              std::function<void()> const& callback));
706
58
                                           std::function<void(void)> callback));
58
    MOCK_METHOD2(notify_at,
707
59
    MOCK_METHOD1(create_alarm, std::unique_ptr<time::Alarm>(std::function<void ()> callback));
59
                 std::unique_ptr<time::Alarm>(time::Timestamp time_point,
708
60
                                              std::function<void()> const& callback));
709
61
    MOCK_METHOD1(create_alarm, std::unique_ptr<time::Alarm>(std::function<void()> const& callback));
710
62
    MOCK_METHOD3(create_alarm,
711
63
                 std::unique_ptr<time::Alarm>(
712
64
                     std::function<void()> const& callback,
713
65
                     std::function<void()> const& lock,
714
66
                     std::function<void()> const& unlock));
715
67
716
60
};
68
};
717
61
69
718
62
}
70
}
719
63
71
720
=== modified file 'tests/include/mir_test_doubles/mock_timer.h'
721
--- tests/include/mir_test_doubles/mock_timer.h	2014-05-22 20:48:20 +0000
722
+++ tests/include/mir_test_doubles/mock_timer.h	2015-02-20 17:57:50 +0000
723
@@ -1,5 +1,5 @@
724
1
/*
1
/*
726
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
727
3
 *
3
 *
728
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
729
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
730
@@ -14,6 +14,7 @@
731
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
732
15
 *
15
 *
733
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
734
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
735
17
 */
18
 */
736
18
19
737
19
#ifndef MIR_TEST_DOUBLES_MOCK_TIMER_H_
20
#ifndef MIR_TEST_DOUBLES_MOCK_TIMER_H_
738
@@ -36,11 +37,12 @@
739
36
    FakeTimer(std::shared_ptr<FakeClock> const& clock);
37
    FakeTimer(std::shared_ptr<FakeClock> const& clock);
740
37
38
741
38
    std::unique_ptr<time::Alarm> notify_in(std::chrono::milliseconds delay,
39
    std::unique_ptr<time::Alarm> notify_in(std::chrono::milliseconds delay,
743
39
                                           std::function<void(void)> callback) override;
40
                                           std::function<void()> const& callback) override;
744
40
    std::unique_ptr<time::Alarm> notify_at(time::Timestamp time_point,
41
    std::unique_ptr<time::Alarm> notify_at(time::Timestamp time_point,
748
41
                                           std::function<void(void)> callback) override;
42
                                           std::function<void()> const& callback) override;
749
42
    std::unique_ptr<time::Alarm> create_alarm(std::function<void ()> callback) override;
43
    std::unique_ptr<time::Alarm> create_alarm(std::function<void()> const& callback) override;
750
43
44
    std::unique_ptr<time::Alarm> create_alarm(std::function<void()> const& callback,
751
45
        std::function<void()> const& lock, std::function<void()> const& unlock) override;
752
44
private:
46
private:
753
45
    std::shared_ptr<FakeClock> const clock;
47
    std::shared_ptr<FakeClock> const clock;
754
46
};
48
};
755
47
49
756
=== modified file 'tests/include/mir_test_doubles/stub_frame_dropping_policy_factory.h'
757
--- tests/include/mir_test_doubles/stub_frame_dropping_policy_factory.h	2014-05-22 20:48:20 +0000
758
+++ tests/include/mir_test_doubles/stub_frame_dropping_policy_factory.h	2015-02-20 17:57:50 +0000
759
@@ -1,5 +1,5 @@
760
1
/*
1
/*
762
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
763
3
 *
3
 *
764
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
765
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
766
@@ -14,6 +14,7 @@
767
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
768
15
 *
15
 *
769
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
770
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
771
17
 */
18
 */
772
18
19
773
19
20
774
@@ -46,9 +47,12 @@
775
46
class StubFrameDroppingPolicyFactory : public mc::FrameDroppingPolicyFactory
47
class StubFrameDroppingPolicyFactory : public mc::FrameDroppingPolicyFactory
776
47
{
48
{
777
48
public:
49
public:
779
49
    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(std::function<void(void)>) const override
50
    std::unique_ptr<mc::FrameDroppingPolicy> create_policy(
780
51
        std::function<void()> const&,
781
52
        std::function<void()> const&,
782
53
        std::function<void()> const& ) const override
783
50
    {
54
    {
785
51
        return std::unique_ptr<mc::FrameDroppingPolicy>{new StubFrameDroppingPolicy};
55
       return std::unique_ptr<mc::FrameDroppingPolicy>{new StubFrameDroppingPolicy};
786
52
    }
56
    }
787
53
};
57
};
788
54
58
789
55
59
790
=== modified file 'tests/include/mir_test_doubles/stub_timer.h'
791
--- tests/include/mir_test_doubles/stub_timer.h	2015-01-21 07:34:50 +0000
792
+++ tests/include/mir_test_doubles/stub_timer.h	2015-02-20 17:57:50 +0000
793
@@ -1,5 +1,5 @@
794
1
/*
1
/*
796
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
797
3
 *
3
 *
798
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
799
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
800
@@ -51,12 +51,12 @@
801
51
51
802
52
class StubTimer : public mir::time::Timer
52
class StubTimer : public mir::time::Timer
803
53
{
53
{
805
54
    std::unique_ptr<mir::time::Alarm> notify_in(std::chrono::milliseconds, std::function<void(void)>) override
54
    std::unique_ptr<mir::time::Alarm> notify_in(std::chrono::milliseconds, std::function<void()> const&) override
806
55
    {
55
    {
807
56
        return std::unique_ptr<mir::time::Alarm>{new StubAlarm};
56
        return std::unique_ptr<mir::time::Alarm>{new StubAlarm};
808
57
    }
57
    }
809
58
58
811
59
    std::unique_ptr<mir::time::Alarm> notify_at(mir::time::Timestamp, std::function<void(void)>) override
59
    std::unique_ptr<mir::time::Alarm> notify_at(mir::time::Timestamp, std::function<void()> const&) override
812
60
    {
60
    {
813
61
        return std::unique_ptr<mir::time::Alarm>{new StubAlarm};
61
        return std::unique_ptr<mir::time::Alarm>{new StubAlarm};
814
62
    }
62
    }
815
63
63
816
=== modified file 'tests/include/mir_test_doubles/triggered_main_loop.h'
817
--- tests/include/mir_test_doubles/triggered_main_loop.h	2015-01-27 11:47:52 +0000
818
+++ tests/include/mir_test_doubles/triggered_main_loop.h	2015-02-20 17:57:50 +0000
819
@@ -39,7 +39,7 @@
820
39
39
821
40
    void register_fd_handler(std::initializer_list<int> fds, void const* owner, fd_callback const& handler) override;
40
    void register_fd_handler(std::initializer_list<int> fds, void const* owner, fd_callback const& handler) override;
822
41
    void unregister_fd_handler(void const* owner) override;
41
    void unregister_fd_handler(void const* owner) override;
824
42
    std::unique_ptr<mir::time::Alarm> notify_in(std::chrono::milliseconds delay, callback call) override;
42
    std::unique_ptr<mir::time::Alarm> notify_in(std::chrono::milliseconds delay, callback const& call) override;
825
43
    void enqueue(void const* owner, ServerAction const& action) override;
43
    void enqueue(void const* owner, ServerAction const& action) override;
826
44
44
827
45
    void trigger_pending_fds();
45
    void trigger_pending_fds();
828
46
46
829
=== modified file 'tests/mir_test_doubles/mock_frame_dropping_policy_factory.cpp'
830
--- tests/mir_test_doubles/mock_frame_dropping_policy_factory.cpp	2014-05-22 20:48:20 +0000
831
+++ tests/mir_test_doubles/mock_frame_dropping_policy_factory.cpp	2015-02-20 17:57:50 +0000
832
@@ -1,5 +1,5 @@
833
1
/*
1
/*
835
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
836
3
 *
3
 *
837
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
838
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
839
@@ -14,6 +14,7 @@
840
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
841
15
 *
15
 *
842
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
843
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
844
17
 */
18
 */
845
18
19
846
19
#include "mir_test_doubles/mock_frame_dropping_policy_factory.h"
20
#include "mir_test_doubles/mock_frame_dropping_policy_factory.h"
847
@@ -21,9 +22,13 @@
848
21
namespace mc = mir::compositor;
22
namespace mc = mir::compositor;
849
22
namespace mtd = mir::test::doubles;
23
namespace mtd = mir::test::doubles;
850
23
24
852
24
mtd::MockFrameDroppingPolicy::MockFrameDroppingPolicy(std::function<void(void)> callback,
25
mtd::MockFrameDroppingPolicy::MockFrameDroppingPolicy(std::function<void()> const& callback,
853
26
                                                      std::function<void()> const& lock,
854
27
                                                      std::function<void()> const& unlock,
855
25
                                                      MockFrameDroppingPolicyFactory const* parent)
28
                                                      MockFrameDroppingPolicyFactory const* parent)
856
26
        : callback{callback},
29
        : callback{callback},
857
30
          lock{lock},
858
31
          unlock{unlock},
859
27
          parent{parent}
32
          parent{parent}
860
28
{
33
{
861
29
}
34
}
862
@@ -36,7 +41,9 @@
863
36
41
864
37
void mtd::MockFrameDroppingPolicy::trigger()
42
void mtd::MockFrameDroppingPolicy::trigger()
865
38
{
43
{
866
44
    lock();
867
39
    callback();
45
    callback();
868
46
    unlock();
869
40
}
47
}
870
41
48
871
42
void mtd::MockFrameDroppingPolicy::parent_destroyed()
49
void mtd::MockFrameDroppingPolicy::parent_destroyed()
872
@@ -45,9 +52,10 @@
873
45
}
52
}
874
46
53
875
47
std::unique_ptr<mc::FrameDroppingPolicy>
54
std::unique_ptr<mc::FrameDroppingPolicy>
877
48
mtd::MockFrameDroppingPolicyFactory::create_policy(std::function<void(void)> drop_frame) const
55
mtd::MockFrameDroppingPolicyFactory::create_policy(std::function<void()> const& drop_frame,
878
56
    std::function<void()> const& lock, std::function<void()> const& unlock) const
879
49
{
57
{
881
50
    auto policy = new ::testing::NiceMock<MockFrameDroppingPolicy>{drop_frame, this};
58
    auto policy = new ::testing::NiceMock<MockFrameDroppingPolicy>{drop_frame, lock, unlock, this};
882
51
    policies.insert(policy);
59
    policies.insert(policy);
883
52
    return std::unique_ptr<mc::FrameDroppingPolicy>{policy};
60
    return std::unique_ptr<mc::FrameDroppingPolicy>{policy};
884
53
}
61
}
885
54
62
886
=== modified file 'tests/mir_test_doubles/mock_timer.cpp'
887
--- tests/mir_test_doubles/mock_timer.cpp	2015-01-21 07:34:50 +0000
888
+++ tests/mir_test_doubles/mock_timer.cpp	2015-02-20 17:57:50 +0000
889
@@ -1,5 +1,5 @@
890
1
/*
1
/*
892
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
893
3
 *
3
 *
894
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
895
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
896
@@ -14,6 +14,7 @@
897
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
898
15
 *
15
 *
899
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
900
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
901
17
 */
18
 */
902
18
19
903
19
#include "mir_test_doubles/mock_timer.h"
20
#include "mir_test_doubles/mock_timer.h"
904
@@ -27,7 +28,10 @@
905
27
class FakeAlarm : public mir::time::Alarm
28
class FakeAlarm : public mir::time::Alarm
906
28
{
29
{
907
29
public:
30
public:
909
30
    FakeAlarm(std::function<void(void)> callback, std::shared_ptr<mt::FakeClock> const& clock);
31
    FakeAlarm(std::function<void()> const& callback,
910
32
              std::function<void()> const& lock,
911
33
              std::function<void()> const& unlock,
912
34
              std::shared_ptr<mt::FakeClock> const& clock);
913
31
    ~FakeAlarm() override;
35
    ~FakeAlarm() override;
914
32
36
915
33
37
916
@@ -39,9 +43,13 @@
917
39
private:    
43
private:    
918
40
    struct InternalState
44
    struct InternalState
919
41
    {
45
    {
921
42
        explicit InternalState(std::function<void(void)> callback);
46
        explicit InternalState(std::function<void()> const& callback,
922
47
                               std::function<void()> const& lock,
923
48
                               std::function<void()> const& unlock);
924
43
        State state;
49
        State state;
926
44
        std::function<void(void)> const callback;
50
        std::function<void()> const callback;
927
51
        std::function<void()> const lock;
928
52
        std::function<void()> const unlock;
929
45
        mt::FakeClock::time_point threshold;
53
        mt::FakeClock::time_point threshold;
930
46
    };
54
    };
931
47
55
932
@@ -51,13 +59,20 @@
933
51
    std::shared_ptr<mt::FakeClock> const clock;
59
    std::shared_ptr<mt::FakeClock> const clock;
934
52
};
60
};
935
53
61
938
54
FakeAlarm::InternalState::InternalState(std::function<void(void)> callback)
62
FakeAlarm::InternalState::InternalState(
939
55
    : state{mir::time::Alarm::pending}, callback{callback}
63
    std::function<void()> const& callback,
940
64
    std::function<void()> const& lock,
941
65
    std::function<void()> const& unlock)
942
66
    : state{mir::time::Alarm::pending}, callback{callback}, lock{lock}, unlock{unlock}
943
56
{
67
{
944
57
}
68
}
945
58
69
948
59
FakeAlarm::FakeAlarm(std::function<void(void)> callback, std::shared_ptr<mt::FakeClock> const& clock)
70
FakeAlarm::FakeAlarm(
949
60
    : internal_state{std::make_shared<InternalState>(callback)}, clock{clock}
71
    std::function<void()> const& callback,
950
72
    std::function<void()> const& lock,
951
73
    std::function<void()> const& unlock,
952
74
    std::shared_ptr<mt::FakeClock> const& clock)
953
75
    : internal_state{std::make_shared<InternalState>(callback, lock, unlock)}, clock{clock}
954
61
{
76
{
955
62
}
77
}
956
63
78
957
@@ -88,7 +103,9 @@
958
88
        if (now > state.threshold)
103
        if (now > state.threshold)
959
89
        {
104
        {
960
90
            state.state = triggered;
105
            state.state = triggered;
961
106
            state.lock();
962
91
            state.callback();
107
            state.callback();
963
108
            state.unlock();
964
92
            return false;
109
            return false;
965
93
        }
110
        }
966
94
        return true;
111
        return true;
967
@@ -128,22 +145,28 @@
968
128
}
145
}
969
129
146
970
130
std::unique_ptr<mir::time::Alarm> mtd::FakeTimer::notify_in(std::chrono::milliseconds delay,
147
std::unique_ptr<mir::time::Alarm> mtd::FakeTimer::notify_in(std::chrono::milliseconds delay,
972
131
                                                            std::function<void(void)> callback)
148
                                                            std::function<void()> const& callback)
973
132
{
149
{
975
133
    auto alarm = std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, clock}};
150
    auto alarm = std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, []{}, []{}, clock}};
976
134
    alarm->reschedule_in(delay);
151
    alarm->reschedule_in(delay);
977
135
    return std::move(alarm);
152
    return std::move(alarm);
978
136
}
153
}
979
137
154
980
138
std::unique_ptr<mir::time::Alarm> mtd::FakeTimer::notify_at(time::Timestamp time_point,
155
std::unique_ptr<mir::time::Alarm> mtd::FakeTimer::notify_at(time::Timestamp time_point,
982
139
                                                            std::function<void(void)> callback)
156
                                                            std::function<void()> const& callback)
983
140
{
157
{
985
141
    auto alarm = std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, clock}};
158
    auto alarm = std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, []{}, []{}, clock}};
986
142
    alarm->reschedule_for(time_point);
159
    alarm->reschedule_for(time_point);
987
143
    return std::move(alarm);
160
    return std::move(alarm);
988
144
}
161
}
989
145
162
993
146
std::unique_ptr<mir::time::Alarm> mir::test::doubles::FakeTimer::create_alarm(std::function<void(void)> callback)
163
std::unique_ptr<mir::time::Alarm> mir::test::doubles::FakeTimer::create_alarm(std::function<void()> const& callback)
994
147
{
164
{
995
148
    return std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, clock}};
165
    return std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, []{}, []{}, clock}};
996
166
}
997
167
998
168
std::unique_ptr<mir::time::Alarm> mir::test::doubles::FakeTimer::create_alarm(std::function<void()> const& callback,
999
169
    std::function<void()> const& lock, std::function<void()> const& unlock)
1000
170
{
1001
171
    return std::unique_ptr<mir::time::Alarm>{new FakeAlarm{callback, lock, unlock, clock}};
1002
149
}
172
}
1003
150
173
1004
=== modified file 'tests/mir_test_doubles/triggered_main_loop.cpp'
1005
--- tests/mir_test_doubles/triggered_main_loop.cpp	2015-01-27 11:47:52 +0000
1006
+++ tests/mir_test_doubles/triggered_main_loop.cpp	2015-02-20 17:57:50 +0000
1007
@@ -85,8 +85,9 @@
1008
85
        action();
85
        action();
1009
86
}
86
}
1010
87
87
1013
88
std::unique_ptr<mir::time::Alarm> mtd::TriggeredMainLoop::notify_in(std::chrono::milliseconds delay,
88
std::unique_ptr<mir::time::Alarm>
1014
89
                                            callback call)
89
mtd::TriggeredMainLoop::notify_in(std::chrono::milliseconds delay,
1015
90
                                  callback const& call)
1016
90
{
91
{
1017
91
    base::notify_in(delay, call);
92
    base::notify_in(delay, call);
1018
92
    timeout_callbacks.push_back(call);
93
    timeout_callbacks.push_back(call);
1019
93
94
1020
=== modified file 'tests/unit-tests/compositor/test_buffer_queue.cpp'
1021
--- tests/unit-tests/compositor/test_buffer_queue.cpp	2015-02-17 06:38:35 +0000
1022
+++ tests/unit-tests/compositor/test_buffer_queue.cpp	2015-02-20 17:57:50 +0000
1023
@@ -1,5 +1,5 @@
1024
1
/*
1
/*
1026
2
 * Copyright © 2013-2014 Canonical Ltd.
2
 * Copyright © 2013-2015 Canonical Ltd.
1027
3
 *
3
 *
1028
4
 * This program is free software: you can redistribute it and/or modify
4
 * This program is free software: you can redistribute it and/or modify
1029
5
 * it under the terms of the GNU General Public License version 3 as
5
 * it under the terms of the GNU General Public License version 3 as
1030
@@ -1740,3 +1740,12 @@
1031
1740
    auto comp2 = q.compositor_acquire(new_compositor_id);
1740
    auto comp2 = q.compositor_acquire(new_compositor_id);
1032
1741
    ASSERT_THAT(comp2->id(), Eq(handle2->id()));
1741
    ASSERT_THAT(comp2->id(), Eq(handle2->id()));
1033
1742
}
1742
}
1034
1743
1035
1744
TEST_F(BufferQueueTest, creates_policy_with_lock_unlock_functions)
1036
1745
{
1037
1746
    int const nbuffers = 3;
1038
1747
1039
1748
    mtd::FrameDroppingPolicyFactoryMock mock_policy_factory;
1040
1749
    EXPECT_CALL(mock_policy_factory, create_policy(_, _, _));
1041
1750
    mc::BufferQueue q(nbuffers, allocator, basic_properties, mock_policy_factory);
1042
1751
}
1043
1743
1752
1044
=== modified file 'tests/unit-tests/compositor/test_timeout_frame_dropping_policy.cpp'
1045
--- tests/unit-tests/compositor/test_timeout_frame_dropping_policy.cpp	2014-05-22 20:48:20 +0000
1046
+++ tests/unit-tests/compositor/test_timeout_frame_dropping_policy.cpp	2015-02-20 17:57:50 +0000
1047
@@ -1,5 +1,5 @@
1048
1
/*
1
/*
1050
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
1051
3
 *
3
 *
1052
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify it
1053
5
 * under the terms of the GNU General Public License version 3,
5
 * under the terms of the GNU General Public License version 3,
1054
@@ -14,16 +14,18 @@
1055
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
1056
15
 *
15
 *
1057
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
1058
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
1059
17
 */
18
 */
1060
18
19
1061
19
#include "src/server/compositor/timeout_frame_dropping_policy_factory.h"
20
#include "src/server/compositor/timeout_frame_dropping_policy_factory.h"
1062
20
#include "mir/compositor/frame_dropping_policy.h"
21
#include "mir/compositor/frame_dropping_policy.h"
1063
21
22
1064
22
#include "mir_test_doubles/mock_timer.h"
23
#include "mir_test_doubles/mock_timer.h"
1066
23
24
#include "mir_test/auto_unblock_thread.h"
1067
24
#include "mir_test/gmock_fixes.h"
25
#include "mir_test/gmock_fixes.h"
1068
25
26
1069
26
#include <stdexcept>
27
#include <stdexcept>
1070
28
#include <mutex>
1071
27
29
1072
28
#include <gtest/gtest.h>
30
#include <gtest/gtest.h>
1073
29
#include <gmock/gmock.h>
31
#include <gmock/gmock.h>
1074
@@ -40,7 +42,7 @@
1075
40
    bool frame_dropped{false};
42
    bool frame_dropped{false};
1076
41
43
1077
42
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
44
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
1079
43
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; });
45
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; }, []{}, []{});
1080
44
46
1081
45
    clock->advance_time(timeout + std::chrono::milliseconds{1});
47
    clock->advance_time(timeout + std::chrono::milliseconds{1});
1082
46
    EXPECT_FALSE(frame_dropped);
48
    EXPECT_FALSE(frame_dropped);
1083
@@ -54,7 +56,7 @@
1084
54
    bool frame_dropped{false};
56
    bool frame_dropped{false};
1085
55
57
1086
56
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
58
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
1088
57
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; });
59
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; }, []{}, []{});
1089
58
    policy->swap_now_blocking();
60
    policy->swap_now_blocking();
1090
59
61
1091
60
    clock->advance_time(timeout - std::chrono::milliseconds{1});
62
    clock->advance_time(timeout - std::chrono::milliseconds{1});
1092
@@ -71,7 +73,7 @@
1093
71
73
1094
72
    bool frame_dropped{false};
74
    bool frame_dropped{false};
1095
73
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
75
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
1097
74
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; });
76
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; }, []{}, []{});
1098
75
77
1099
76
    policy->swap_now_blocking();
78
    policy->swap_now_blocking();
1100
77
    policy->swap_unblocked();
79
    policy->swap_unblocked();
1101
@@ -89,7 +91,7 @@
1102
89
91
1103
90
    bool frame_dropped{false};
92
    bool frame_dropped{false};
1104
91
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
93
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
1106
92
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; });
94
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; }, []{}, []{});
1107
93
95
1108
94
    policy->swap_now_blocking();
96
    policy->swap_now_blocking();
1109
95
    policy->swap_now_blocking();
97
    policy->swap_now_blocking();
1110
@@ -119,7 +121,7 @@
1111
119
121
1112
120
    bool frame_dropped{false};
122
    bool frame_dropped{false};
1113
121
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
123
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
1115
122
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; });
124
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; }, []{}, []{});
1116
123
125
1117
124
    policy->swap_now_blocking();
126
    policy->swap_now_blocking();
1118
125
    policy->swap_now_blocking();
127
    policy->swap_now_blocking();
1119
@@ -142,7 +144,7 @@
1120
142
144
1121
143
    bool frame_dropped{false};
145
    bool frame_dropped{false};
1122
144
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
146
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
1124
145
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; });
147
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; }, []{}, []{});
1125
146
148
1126
147
    policy->swap_now_blocking();
149
    policy->swap_now_blocking();
1127
148
    clock->advance_time(timeout - std::chrono::milliseconds{1});
150
    clock->advance_time(timeout - std::chrono::milliseconds{1});
1128
@@ -160,7 +162,7 @@
1129
160
162
1130
161
    bool frame_dropped{false};
163
    bool frame_dropped{false};
1131
162
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
164
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
1133
163
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; });
165
    auto policy = factory.create_policy([&frame_dropped]{ frame_dropped = true; }, []{}, []{});
1134
164
166
1135
165
    policy->swap_now_blocking();
167
    policy->swap_now_blocking();
1136
166
    policy->swap_now_blocking();
168
    policy->swap_now_blocking();
1137
@@ -184,3 +186,28 @@
1138
184
    clock->advance_time(timeout + std::chrono::milliseconds{1});
186
    clock->advance_time(timeout + std::chrono::milliseconds{1});
1139
185
    EXPECT_FALSE(frame_dropped);
187
    EXPECT_FALSE(frame_dropped);
1140
186
}
188
}
1141
189
1142
190
TEST(TimeoutFrameDroppingPolicy, policy_calls_lock_unlock_functions)
1143
191
{
1144
192
    using namespace testing;
1145
193
1146
194
    auto clock = std::make_shared<mt::FakeClock>();
1147
195
    auto timer = std::make_shared<mtd::FakeTimer>(clock);
1148
196
    std::chrono::milliseconds const timeout{1000};
1149
197
1150
198
    mc::TimeoutFrameDroppingPolicyFactory factory{timer, timeout};
1151
199
1152
200
    std::mutex m;
1153
201
    std::unique_lock<std::mutex> handler_guard{m, std::defer_lock};
1154
202
1155
203
    auto policy = factory.create_policy([&]
1156
204
    {
1157
205
        EXPECT_THAT(handler_guard.owns_lock(), Eq(true));
1158
206
    },
1159
207
    [&] { handler_guard.lock(); },
1160
208
    [&] { handler_guard.unlock(); });
1161
209
1162
210
1163
211
    policy->swap_now_blocking();
1164
212
    clock->advance_time(timeout + std::chrono::milliseconds{1});
1165
213
}
1166
187
214
1167
=== modified file 'tests/unit-tests/test_glib_main_loop.cpp'
1168
--- tests/unit-tests/test_glib_main_loop.cpp	2015-02-03 15:07:44 +0000
1169
+++ tests/unit-tests/test_glib_main_loop.cpp	2015-02-20 17:57:50 +0000
1170
@@ -1,5 +1,5 @@
1171
1
/*
1
/*
1173
2
 * Copyright © 2014 Canonical Ltd.
2
 * Copyright © 2014-2015 Canonical Ltd.
1174
3
 *
3
 *
1175
4
 * This program is free software: you can redistribute it and/or modify
4
 * This program is free software: you can redistribute it and/or modify
1176
5
 * it under the terms of the GNU General Public License version 3 as
5
 * it under the terms of the GNU General Public License version 3 as
1177
@@ -14,6 +14,7 @@
1178
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1179
15
 *
15
 *
1180
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
16
 * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
1181
17
 *              Alberto Aguirre <alberto.aguirre@canonical.com>
1182
17
 */
18
 */
1183
18
19
1184
19
#include "mir/glib_main_loop.h"
20
#include "mir/glib_main_loop.h"
1185
@@ -960,43 +961,45 @@
1186
960
}
961
}
1187
961
962
1188
962
TEST_F(GLibMainLoopAlarmTest, alarm_callback_cannot_deadlock)
963
TEST_F(GLibMainLoopAlarmTest, alarm_callback_cannot_deadlock)
1192
963
{   // Regression test for deadlock bug LP: #1339700
964
{
1193
964
    std::timed_mutex m;
965
    using namespace testing;
1194
965
    std::atomic_bool failed(false);
966
1195
967
    std::mutex m;
1196
968
    std::unique_lock<std::mutex> handler_guard{m, std::defer_lock};
1197
969
    std::atomic_bool exit{false};
1198
966
    int i = 0;
970
    int i = 0;
1199
967
    int const loops = 5;
971
    int const loops = 5;
1200
968
972
1202
969
    auto alarm = ml.notify_in(std::chrono::milliseconds{0}, [&]()
973
    auto alarm = ml.create_alarm([&]()
1203
970
    {
974
    {
1207
971
        // From this angle, ensure we can lock m (alarm should be unlocked)
975
        //In this handler context, the alarm dispatcher should have
1208
972
        failed = !m.try_lock_for(std::chrono::seconds{5});
976
        //acquired the handler guard
1209
973
        ASSERT_FALSE(failed);
977
        EXPECT_THAT(handler_guard.owns_lock(), Eq(true));
1210
974
        ++i;
978
        ++i;
1212
975
        m.unlock();
979
    },
1213
980
    [&] { handler_guard.lock(); },
1214
981
    [&] { handler_guard.unlock(); });
1215
982
1216
983
    mt::AutoUnblockThread t([&]{ exit = true; }, [&]()
1217
984
    {
1218
985
        std::unique_lock<std::mutex> guard{m};
1219
986
        while (i < loops && !exit)
1220
987
        {
1221
988
            // It's safe to call cancel now because lock ordering is enforced
1222
989
            // by passing the lock/unlock lambdas to alarm above
1223
990
            alarm->cancel();
1224
991
            guard.unlock();
1225
992
            std::this_thread::yield();
1226
993
            guard.lock();
1227
994
        }
1228
976
    });
995
    });
1229
977
996
1230
978
    std::thread t([&]()
1231
979
        {
1232
980
            m.lock();
1233
981
            while (i < loops && !failed)
1234
982
            {
1235
983
                // From this angle, ensure we can lock alarm while holding m
1236
984
                (void)alarm->state();
1237
985
                m.unlock();
1238
986
                std::this_thread::yield();
1239
987
                m.lock();
1240
988
            }
1241
989
            m.unlock();
1242
990
        });
1243
991
1244
992
    UnblockMainLoop unblocker(ml);
997
    UnblockMainLoop unblocker(ml);
1245
993
    for (int j = 0; j < loops; ++j)
998
    for (int j = 0; j < loops; ++j)
1246
994
    {
999
    {
1247
1000
        alarm->reschedule_in(std::chrono::milliseconds{10});
1248
995
        clock->advance_by(std::chrono::milliseconds{11}, ml);
1001
        clock->advance_by(std::chrono::milliseconds{11}, ml);
1249
996
        alarm->reschedule_in(std::chrono::milliseconds{10});
1250
997
    }
1002
    }
1251
998
1252
999
    t.join();
1253
1000
}
1003
}
1254
1001
1004
1255
1002
TEST_F(GLibMainLoopAlarmTest, alarm_fires_at_correct_time_point)
1005
TEST_F(GLibMainLoopAlarmTest, alarm_fires_at_correct_time_point)
1256
1003
1006
1257
=== modified file 'tests/unit-tests/test_raii.cpp'
1258
--- tests/unit-tests/test_raii.cpp	2013-10-21 14:21:00 +0000
1259
+++ tests/unit-tests/test_raii.cpp	2015-02-20 17:57:50 +0000
1260
@@ -179,3 +179,23 @@
1261
179
179
1262
180
    EXPECT_EQ(this, raii.get());
180
    EXPECT_EQ(this, raii.get());
1263
181
}
181
}
1264
182
1265
183
TEST_F(RaiiTest, paired_call_takes_std_function_refs)
1266
184
{
1267
185
    int creator_call_count = 0;
1268
186
    int deleter_call_count = 0;
1269
187
    int const expected_calls = 2;
1270
188
1271
189
    std::function<void()> creator = [&creator_call_count] { creator_call_count++; };
1272
190
    std::function<void()> deleter = [&deleter_call_count] { deleter_call_count++; };
1273
191
1274
192
    for (int i = 0; i < expected_calls; i++)
1275
193
    {
1276
194
        auto const raii = mir::raii::paired_calls(
1277
195
            std::ref(creator),
1278
196
            std::ref(deleter));
1279
197
    }
1280
198
1281
199
    EXPECT_THAT(creator_call_count, Eq(expected_calls));
1282
200
    EXPECT_THAT(deleter_call_count, Eq(expected_calls));
1283
201
}
Reviewer	Review Type	Date Requested	Status
Kevin DuBois (community)		2015-02-18	Approve on 2015-02-20
PS Jenkins bot (community)	continuous-integration		Approve on 2015-02-20
Alan Griffiths			Approve on 2015-02-20
Review via email: mp+250182@code.launchpad.net