~hikiko/mir/mir.unity8-desktop-session

« back to all changes in this revision

Viewing changes to tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release, Daniel van Vugt, Ubuntu daily release
  • Date: 2014-01-08 02:04:38 UTC
  • mfrom: (1.1.54)
  • Revision ID: package-import@ubuntu.com-20140108020438-ikbu7qqm9v2l026y
Tags: 0.1.3+14.04.20140108-0ubuntu1
[ Daniel van Vugt ]
* Preparing for release 0.1.3

[ Ubuntu daily release ]
* Automatic snapshot from revision 1170

Show diffs side-by-side

added added

removed removed

Lines of Context:
18
18
 
19
19
#include "src/server/compositor/default_display_buffer_compositor_factory.h"
20
20
#include "mir/compositor/display_buffer_compositor.h"
21
 
#include "src/server/compositor/overlay_renderer.h"
22
21
#include "mir/compositor/scene.h"
23
22
#include "src/server/compositor/renderer.h"
24
23
#include "src/server/compositor/renderer_factory.h"
32
31
#include "mir_test_doubles/stub_compositing_criteria.h"
33
32
#include "mir_test_doubles/null_display_buffer.h"
34
33
#include "mir_test_doubles/mock_buffer.h"
 
34
#include "mir_test_doubles/stub_buffer.h"
35
35
 
36
36
#include <gmock/gmock.h>
37
37
#include <gtest/gtest.h>
38
38
 
 
39
namespace mg = mir::graphics;
39
40
namespace mc = mir::compositor;
40
41
namespace geom = mir::geometry;
41
42
namespace mt = mir::test;
54
55
    MOCK_METHOD0(unlock, void());
55
56
};
56
57
 
57
 
struct MockOverlayRenderer : public mc::OverlayRenderer
58
 
{
59
 
    MOCK_METHOD2(render, void(geom::Rectangle const&, std::function<void(std::shared_ptr<void> const&)>));
60
 
 
61
 
    ~MockOverlayRenderer() noexcept {}
62
 
};
63
 
 
64
58
struct FakeScene : mc::Scene
65
59
{
66
60
    FakeScene(std::vector<mc::CompositingCriteria*> surfaces) :
67
61
        surfaces(surfaces)
68
62
    {
 
63
        ON_CALL(stub_stream, lock_compositor_buffer(testing::_))
 
64
            .WillByDefault(testing::Return(std::make_shared<mtd::StubBuffer>()));
69
65
    }
70
66
 
71
67
    // Ugly...should we use delegation?
99
95
    void lock() {}
100
96
    void unlock() {}
101
97
 
102
 
    mtd::MockBufferStream stub_stream;
 
98
    testing::NiceMock<mtd::MockBufferStream> stub_stream;
103
99
    std::vector<mc::CompositingCriteria*> surfaces;
104
100
};
105
101
 
110
106
    {
111
107
    }
112
108
 
113
 
    void clear(unsigned long f) override { renderer->clear(f); }
114
 
    void render(std::function<void(std::shared_ptr<void> const&)> save_resource,
115
 
                mc::CompositingCriteria const& info, mc::BufferStream& stream)
116
 
    {
117
 
        renderer->render(save_resource, info, stream);
 
109
    void clear() const override
 
110
    {
 
111
        renderer->clear();
 
112
    }
 
113
 
 
114
    void render(mc::CompositingCriteria const& criteria, mg::Buffer& buffer) const override
 
115
    {
 
116
        renderer->render(criteria, buffer);
118
117
    }
119
118
 
120
119
    mc::Renderer* const renderer;
144
143
 
145
144
    StubRendererFactory renderer_factory;
146
145
    MockScene scene;
147
 
    NiceMock<MockOverlayRenderer> overlay_renderer;
148
 
    mtd::MockDisplayBuffer display_buffer;
 
146
    NiceMock<mtd::MockDisplayBuffer> display_buffer;
149
147
 
150
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,_,_)).Times(0);
 
148
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,_)).Times(0);
151
149
 
152
150
    EXPECT_CALL(display_buffer, view_area())
153
151
        .Times(AtLeast(1))
167
165
 
168
166
    mc::DefaultDisplayBufferCompositorFactory factory(
169
167
        mt::fake_shared(scene),
170
 
        mt::fake_shared(renderer_factory),
171
 
        mt::fake_shared(overlay_renderer));
172
 
 
173
 
    auto comp = factory.create_compositor_for(display_buffer);
174
 
 
175
 
    comp->composite();
176
 
}
177
 
 
178
 
TEST(DefaultDisplayBufferCompositor, render_overlay)
179
 
{
180
 
    using namespace testing;
181
 
 
182
 
    StubRendererFactory renderer_factory;
183
 
    NiceMock<MockScene> scene;
184
 
    NiceMock<mtd::MockDisplayBuffer> display_buffer;
185
 
    MockOverlayRenderer overlay_renderer;
186
 
 
187
 
    ON_CALL(display_buffer, view_area())
188
 
        .WillByDefault(Return(geom::Rectangle()));
189
 
 
190
 
    EXPECT_CALL(overlay_renderer, render(_, _)).Times(1);
191
 
 
192
 
    mc::DefaultDisplayBufferCompositorFactory factory(
193
 
        mt::fake_shared(scene),
194
 
        mt::fake_shared(renderer_factory),
195
 
        mt::fake_shared(overlay_renderer));
 
168
        mt::fake_shared(renderer_factory));
196
169
 
197
170
    auto comp = factory.create_compositor_for(display_buffer);
198
171
 
205
178
 
206
179
    StubRendererFactory renderer_factory;
207
180
    mtd::NullDisplayBuffer display_buffer;
208
 
    NiceMock<MockOverlayRenderer> overlay_renderer;
209
181
 
210
182
    NiceMock<mtd::MockCompositingCriteria> mock_criteria1, mock_criteria2, mock_criteria3;
211
183
 
229
201
    renderable_vec.push_back(&mock_criteria2);
230
202
    renderable_vec.push_back(&mock_criteria3);
231
203
 
232
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(mock_criteria1),_)).Times(1);
233
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(mock_criteria2),_)).Times(0);
234
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(mock_criteria3),_)).Times(1);
 
204
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(mock_criteria1),_)).Times(1);
 
205
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(mock_criteria2),_)).Times(0);
 
206
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(mock_criteria3),_)).Times(1);
235
207
 
236
208
    FakeScene scene(renderable_vec);
237
209
 
238
210
    mc::DefaultDisplayBufferCompositorFactory factory(
239
211
        mt::fake_shared(scene),
240
 
        mt::fake_shared(renderer_factory),
241
 
        mt::fake_shared(overlay_renderer));
 
212
        mt::fake_shared(renderer_factory));
242
213
 
243
214
    auto comp = factory.create_compositor_for(display_buffer);
244
215
 
250
221
    using namespace testing;
251
222
 
252
223
    StubRendererFactory renderer_factory;
253
 
    NiceMock<MockOverlayRenderer> overlay_renderer;
254
224
 
255
225
    geom::Rectangle screen{{0, 0}, {1366, 768}};
256
226
 
271
241
    renderable_vec.push_back(&small);
272
242
    renderable_vec.push_back(&fullscreen);
273
243
 
274
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
 
244
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
275
245
        .Times(0);
276
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
 
246
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(fullscreen),_))
277
247
        .Times(0);
278
248
 
279
249
    FakeScene scene(renderable_vec);
286
256
 
287
257
    mc::DefaultDisplayBufferCompositorFactory factory(
288
258
        mt::fake_shared(scene),
289
 
        mt::fake_shared(renderer_factory),
290
 
        mt::fake_shared(overlay_renderer));
 
259
        mt::fake_shared(renderer_factory));
291
260
 
292
261
    auto comp = factory.create_compositor_for(display_buffer);
293
262
 
299
268
    using namespace testing;
300
269
 
301
270
    StubRendererFactory renderer_factory;
302
 
    NiceMock<MockOverlayRenderer> overlay_renderer;
303
271
 
304
272
    geom::Rectangle screen{{0, 0}, {1366, 768}};
305
273
 
320
288
    renderable_vec.push_back(&fullscreen);
321
289
    renderable_vec.push_back(&small);
322
290
 
323
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
 
291
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
324
292
        .Times(1);
325
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
 
293
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(fullscreen),_))
326
294
        .Times(1);
327
295
 
328
296
    FakeScene scene(renderable_vec);
330
298
    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
331
299
    EXPECT_CALL(*compositor_buffer, can_bypass())
332
300
        .Times(0);
333
 
    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
334
 
        .Times(0);
335
301
 
336
302
    mc::DefaultDisplayBufferCompositorFactory factory(
337
303
        mt::fake_shared(scene),
338
 
        mt::fake_shared(renderer_factory),
339
 
        mt::fake_shared(overlay_renderer));
 
304
        mt::fake_shared(renderer_factory));
340
305
 
341
306
    auto comp = factory.create_compositor_for(display_buffer);
342
307
 
348
313
    using namespace testing;
349
314
 
350
315
    StubRendererFactory renderer_factory;
351
 
    NiceMock<MockOverlayRenderer> overlay_renderer;
352
316
 
353
317
    geom::Rectangle screen{{0, 0}, {1366, 768}};
354
318
 
369
333
    renderable_vec.push_back(&small);
370
334
    renderable_vec.push_back(&fullscreen);
371
335
 
372
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
 
336
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
373
337
        .Times(0);  // zero due to occlusion detection
374
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
 
338
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(fullscreen),_))
375
339
        .Times(1);
376
340
 
377
341
    FakeScene scene(renderable_vec);
379
343
    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
380
344
    EXPECT_CALL(*compositor_buffer, can_bypass())
381
345
        .Times(0);
382
 
    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
383
 
        .Times(0);
384
346
 
385
347
    mc::DefaultDisplayBufferCompositorFactory factory(
386
348
        mt::fake_shared(scene),
387
 
        mt::fake_shared(renderer_factory),
388
 
        mt::fake_shared(overlay_renderer));
 
349
        mt::fake_shared(renderer_factory));
389
350
 
390
351
    auto comp = factory.create_compositor_for(display_buffer);
391
352
 
397
358
    using namespace testing;
398
359
 
399
360
    StubRendererFactory renderer_factory;
400
 
    NiceMock<MockOverlayRenderer> overlay_renderer;
401
361
 
402
362
    geom::Rectangle screen{{0, 0}, {1366, 768}};
403
363
 
418
378
    renderable_vec.push_back(&small);
419
379
    renderable_vec.push_back(&fullscreen);
420
380
 
421
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
 
381
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
422
382
        .Times(0);  // zero due to occlusion detection
423
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
 
383
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(fullscreen),_))
424
384
        .Times(1);
425
385
 
426
386
    FakeScene scene(renderable_vec);
427
387
 
428
388
    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
429
389
    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
430
 
        .WillOnce(Return(compositor_buffer));
 
390
        .WillRepeatedly(Return(compositor_buffer));
431
391
    EXPECT_CALL(*compositor_buffer, can_bypass())
432
392
        .WillRepeatedly(Return(false));
433
393
 
434
394
    mc::DefaultDisplayBufferCompositorFactory factory(
435
395
        mt::fake_shared(scene),
436
 
        mt::fake_shared(renderer_factory),
437
 
        mt::fake_shared(overlay_renderer));
 
396
        mt::fake_shared(renderer_factory));
438
397
 
439
398
    auto comp = factory.create_compositor_for(display_buffer);
440
399
 
446
405
    using namespace testing;
447
406
 
448
407
    StubRendererFactory renderer_factory;
449
 
    NiceMock<MockOverlayRenderer> overlay_renderer;
450
408
 
451
409
    geom::Rectangle screen{{0, 0}, {1366, 768}};
452
410
 
467
425
    renderable_vec.push_back(&fullscreen);
468
426
    renderable_vec.push_back(&small);
469
427
 
470
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
 
428
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
471
429
        .Times(1);
472
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
 
430
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(fullscreen),_))
473
431
        .Times(1);
474
432
 
475
433
    FakeScene scene(renderable_vec);
477
435
    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
478
436
    EXPECT_CALL(*compositor_buffer, can_bypass())
479
437
        .Times(0);
480
 
    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
481
 
        .Times(0);
482
438
 
483
439
    mc::DefaultDisplayBufferCompositorFactory factory(
484
440
        mt::fake_shared(scene),
485
 
        mt::fake_shared(renderer_factory),
486
 
        mt::fake_shared(overlay_renderer));
 
441
        mt::fake_shared(renderer_factory));
487
442
 
488
443
    auto comp = factory.create_compositor_for(display_buffer);
489
444
 
499
454
        .Times(0);
500
455
    EXPECT_CALL(display_buffer, post_update())
501
456
        .Times(0);
502
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
 
457
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
503
458
        .Times(0);
504
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
 
459
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(fullscreen),_))
505
460
        .Times(0);
506
461
    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
507
 
        .WillOnce(Return(compositor_buffer));
 
462
        .WillRepeatedly(Return(compositor_buffer));
508
463
    EXPECT_CALL(*compositor_buffer, can_bypass())
509
464
        .WillOnce(Return(true));
510
465
    comp->composite();
517
472
        .Times(1);
518
473
    EXPECT_CALL(display_buffer, post_update())
519
474
        .Times(1);
520
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
 
475
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
521
476
        .Times(1);
522
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
523
 
        .Times(0);
524
 
    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
 
477
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(fullscreen),_))
525
478
        .Times(0);
526
479
    EXPECT_CALL(*compositor_buffer, can_bypass())
527
480
        .Times(0);
533
486
    using namespace testing;
534
487
 
535
488
    StubRendererFactory renderer_factory;
536
 
    NiceMock<MockOverlayRenderer> overlay_renderer;
537
489
 
538
490
    geom::Rectangle screen{{0, 0}, {1366, 768}};
539
491
 
554
506
    renderable_vec.push_back(&small);
555
507
    renderable_vec.push_back(&large);
556
508
 
557
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(small),_))
 
509
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
558
510
        .Times(0);
559
 
    EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(large),_))
 
511
    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(large),_))
560
512
        .Times(1);
561
513
 
562
514
    FakeScene scene(renderable_vec);
563
515
 
564
516
    mc::DefaultDisplayBufferCompositorFactory factory(
565
517
        mt::fake_shared(scene),
566
 
        mt::fake_shared(renderer_factory),
567
 
        mt::fake_shared(overlay_renderer));
 
518
        mt::fake_shared(renderer_factory));
568
519
 
569
520
    auto comp = factory.create_compositor_for(display_buffer);
570
521