1 /*
2 * Copyright 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <compositionengine/CompositionRefreshArgs.h>
18 #include <compositionengine/LayerFECompositionState.h>
19 #include <compositionengine/impl/CompositionEngine.h>
20 #include <compositionengine/mock/LayerFE.h>
21 #include <compositionengine/mock/Output.h>
22 #include <compositionengine/mock/OutputLayer.h>
23 #include <gtest/gtest.h>
24 #include <renderengine/mock/RenderEngine.h>
25
26 #include "MockHWComposer.h"
27 #include "TimeStats/TimeStats.h"
28
29 namespace android::compositionengine {
30 namespace {
31
32 using ::testing::_;
33 using ::testing::InSequence;
34 using ::testing::Ref;
35 using ::testing::Return;
36 using ::testing::ReturnRef;
37 using ::testing::SaveArg;
38 using ::testing::StrictMock;
39
40 struct CompositionEngineTest : public testing::Test {
41 android::mock::HWComposer* mHwc = new StrictMock<android::mock::HWComposer>();
42 renderengine::mock::RenderEngine* mRenderEngine =
43 new StrictMock<renderengine::mock::RenderEngine>();
44 std::shared_ptr<TimeStats> mTimeStats;
45
46 impl::CompositionEngine mEngine;
47 CompositionRefreshArgs mRefreshArgs;
48
49 std::shared_ptr<mock::Output> mOutput1{std::make_shared<StrictMock<mock::Output>>()};
50 std::shared_ptr<mock::Output> mOutput2{std::make_shared<StrictMock<mock::Output>>()};
51 std::shared_ptr<mock::Output> mOutput3{std::make_shared<StrictMock<mock::Output>>()};
52 };
53
TEST_F(CompositionEngineTest,canInstantiateCompositionEngine)54 TEST_F(CompositionEngineTest, canInstantiateCompositionEngine) {
55 auto engine = impl::createCompositionEngine();
56 EXPECT_TRUE(engine.get() != nullptr);
57 }
58
TEST_F(CompositionEngineTest,canSetHWComposer)59 TEST_F(CompositionEngineTest, canSetHWComposer) {
60 mEngine.setHwComposer(std::unique_ptr<android::HWComposer>(mHwc));
61
62 EXPECT_EQ(mHwc, &mEngine.getHwComposer());
63 }
64
TEST_F(CompositionEngineTest,canSetRenderEngine)65 TEST_F(CompositionEngineTest, canSetRenderEngine) {
66 mEngine.setRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
67
68 EXPECT_EQ(mRenderEngine, &mEngine.getRenderEngine());
69 }
70
TEST_F(CompositionEngineTest,canSetTimeStats)71 TEST_F(CompositionEngineTest, canSetTimeStats) {
72 mEngine.setTimeStats(mTimeStats);
73
74 EXPECT_EQ(mTimeStats.get(), &mEngine.getTimeStats());
75 }
76
77 /*
78 * CompositionEngine::present
79 */
80
81 struct CompositionEnginePresentTest : public CompositionEngineTest {
82 struct CompositionEnginePartialMock : public impl::CompositionEngine {
83 // These are the overridable functions CompositionEngine::present() may
84 // call, and have separate test coverage.
85 MOCK_METHOD1(preComposition, void(CompositionRefreshArgs&));
86 };
87
88 StrictMock<CompositionEnginePartialMock> mEngine;
89 };
90
TEST_F(CompositionEnginePresentTest,worksWithEmptyRequest)91 TEST_F(CompositionEnginePresentTest, worksWithEmptyRequest) {
92 // present() always calls preComposition()
93 EXPECT_CALL(mEngine, preComposition(Ref(mRefreshArgs)));
94
95 mEngine.present(mRefreshArgs);
96 }
97
TEST_F(CompositionEnginePresentTest,worksAsExpected)98 TEST_F(CompositionEnginePresentTest, worksAsExpected) {
99 // Expect calls to in a certain sequence
100 InSequence seq;
101
102 // present() always calls preComposition()
103 EXPECT_CALL(mEngine, preComposition(Ref(mRefreshArgs)));
104
105 // The first step in presenting is to make sure all outputs are prepared.
106 EXPECT_CALL(*mOutput1, prepare(Ref(mRefreshArgs), _));
107 EXPECT_CALL(*mOutput2, prepare(Ref(mRefreshArgs), _));
108 EXPECT_CALL(*mOutput3, prepare(Ref(mRefreshArgs), _));
109
110 // The next step in presenting is to make sure all outputs have the latest
111 // state from the front-end (SurfaceFlinger).
112 EXPECT_CALL(*mOutput1, updateLayerStateFromFE(Ref(mRefreshArgs)));
113 EXPECT_CALL(*mOutput2, updateLayerStateFromFE(Ref(mRefreshArgs)));
114 EXPECT_CALL(*mOutput3, updateLayerStateFromFE(Ref(mRefreshArgs)));
115
116 // The last step is to actually present each output.
117 EXPECT_CALL(*mOutput1, present(Ref(mRefreshArgs)));
118 EXPECT_CALL(*mOutput2, present(Ref(mRefreshArgs)));
119 EXPECT_CALL(*mOutput3, present(Ref(mRefreshArgs)));
120
121 mRefreshArgs.outputs = {mOutput1, mOutput2, mOutput3};
122 mEngine.present(mRefreshArgs);
123 }
124
125 /*
126 * CompositionEngine::updateCursorAsync
127 */
128
129 struct CompositionEngineUpdateCursorAsyncTest : public CompositionEngineTest {
130 public:
131 struct Layer {
Layerandroid::compositionengine::__anon95ee30f80111::CompositionEngineUpdateCursorAsyncTest::Layer132 Layer() { EXPECT_CALL(outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(layerFE)); }
133
134 StrictMock<mock::OutputLayer> outputLayer;
135 StrictMock<mock::LayerFE> layerFE;
136 LayerFECompositionState layerFEState;
137 };
138
CompositionEngineUpdateCursorAsyncTestandroid::compositionengine::__anon95ee30f80111::CompositionEngineUpdateCursorAsyncTest139 CompositionEngineUpdateCursorAsyncTest() {
140 EXPECT_CALL(*mOutput1, getOutputLayerCount()).WillRepeatedly(Return(0u));
141 EXPECT_CALL(*mOutput1, getOutputLayerOrderedByZByIndex(_)).Times(0);
142
143 EXPECT_CALL(*mOutput2, getOutputLayerCount()).WillRepeatedly(Return(1u));
144 EXPECT_CALL(*mOutput2, getOutputLayerOrderedByZByIndex(0))
145 .WillRepeatedly(Return(&mOutput2Layer1.outputLayer));
146
147 EXPECT_CALL(*mOutput3, getOutputLayerCount()).WillRepeatedly(Return(2u));
148 EXPECT_CALL(*mOutput3, getOutputLayerOrderedByZByIndex(0))
149 .WillRepeatedly(Return(&mOutput3Layer1.outputLayer));
150 EXPECT_CALL(*mOutput3, getOutputLayerOrderedByZByIndex(1))
151 .WillRepeatedly(Return(&mOutput3Layer2.outputLayer));
152 }
153
154 Layer mOutput2Layer1;
155 Layer mOutput3Layer1;
156 Layer mOutput3Layer2;
157 };
158
TEST_F(CompositionEngineUpdateCursorAsyncTest,handlesNoOutputs)159 TEST_F(CompositionEngineUpdateCursorAsyncTest, handlesNoOutputs) {
160 mEngine.updateCursorAsync(mRefreshArgs);
161 }
162
TEST_F(CompositionEngineUpdateCursorAsyncTest,handlesNoLayersBeingCursorLayers)163 TEST_F(CompositionEngineUpdateCursorAsyncTest, handlesNoLayersBeingCursorLayers) {
164 EXPECT_CALL(mOutput3Layer1.outputLayer, isHardwareCursor()).WillRepeatedly(Return(false));
165 EXPECT_CALL(mOutput3Layer2.outputLayer, isHardwareCursor()).WillRepeatedly(Return(false));
166 EXPECT_CALL(mOutput2Layer1.outputLayer, isHardwareCursor()).WillRepeatedly(Return(false));
167
168 mRefreshArgs.outputs = {mOutput1, mOutput2, mOutput3};
169
170 mEngine.updateCursorAsync(mRefreshArgs);
171 }
172
TEST_F(CompositionEngineUpdateCursorAsyncTest,handlesMultipleLayersBeingCursorLayers)173 TEST_F(CompositionEngineUpdateCursorAsyncTest, handlesMultipleLayersBeingCursorLayers) {
174 {
175 InSequence seq;
176 EXPECT_CALL(mOutput2Layer1.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));
177 EXPECT_CALL(mOutput2Layer1.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));
178 EXPECT_CALL(mOutput2Layer1.outputLayer, writeCursorPositionToHWC());
179 }
180
181 {
182 InSequence seq;
183 EXPECT_CALL(mOutput3Layer1.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));
184 EXPECT_CALL(mOutput3Layer1.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));
185 EXPECT_CALL(mOutput3Layer1.outputLayer, writeCursorPositionToHWC());
186 }
187
188 {
189 InSequence seq;
190 EXPECT_CALL(mOutput3Layer2.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));
191 EXPECT_CALL(mOutput3Layer2.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));
192 EXPECT_CALL(mOutput3Layer2.outputLayer, writeCursorPositionToHWC());
193 }
194
195 mRefreshArgs.outputs = {mOutput1, mOutput2, mOutput3};
196
197 mEngine.updateCursorAsync(mRefreshArgs);
198 }
199
200 /*
201 * CompositionEngine::preComposition
202 */
203
204 struct CompositionTestPreComposition : public CompositionEngineTest {
205 sp<StrictMock<mock::LayerFE>> mLayer1FE{new StrictMock<mock::LayerFE>()};
206 sp<StrictMock<mock::LayerFE>> mLayer2FE{new StrictMock<mock::LayerFE>()};
207 sp<StrictMock<mock::LayerFE>> mLayer3FE{new StrictMock<mock::LayerFE>()};
208 };
209
TEST_F(CompositionTestPreComposition,preCompositionSetsFrameTimestamp)210 TEST_F(CompositionTestPreComposition, preCompositionSetsFrameTimestamp) {
211 const nsecs_t before = systemTime(SYSTEM_TIME_MONOTONIC);
212 mEngine.preComposition(mRefreshArgs);
213 const nsecs_t after = systemTime(SYSTEM_TIME_MONOTONIC);
214
215 // The frame timestamp should be between the before and after timestamps
216 EXPECT_GE(mEngine.getLastFrameRefreshTimestamp(), before);
217 EXPECT_LE(mEngine.getLastFrameRefreshTimestamp(), after);
218 }
219
TEST_F(CompositionTestPreComposition,preCompositionInvokesLayerPreCompositionWithFrameTimestamp)220 TEST_F(CompositionTestPreComposition, preCompositionInvokesLayerPreCompositionWithFrameTimestamp) {
221 nsecs_t ts1 = 0;
222 nsecs_t ts2 = 0;
223 nsecs_t ts3 = 0;
224 EXPECT_CALL(*mLayer1FE, onPreComposition(_)).WillOnce(DoAll(SaveArg<0>(&ts1), Return(false)));
225 EXPECT_CALL(*mLayer2FE, onPreComposition(_)).WillOnce(DoAll(SaveArg<0>(&ts2), Return(false)));
226 EXPECT_CALL(*mLayer3FE, onPreComposition(_)).WillOnce(DoAll(SaveArg<0>(&ts3), Return(false)));
227
228 mRefreshArgs.outputs = {mOutput1};
229 mRefreshArgs.layers = {mLayer1FE, mLayer2FE, mLayer3FE};
230
231 mEngine.preComposition(mRefreshArgs);
232
233 // Each of the onPreComposition calls should used the same refresh timestamp
234 EXPECT_EQ(ts1, mEngine.getLastFrameRefreshTimestamp());
235 EXPECT_EQ(ts2, mEngine.getLastFrameRefreshTimestamp());
236 EXPECT_EQ(ts3, mEngine.getLastFrameRefreshTimestamp());
237 }
238
TEST_F(CompositionTestPreComposition,preCompositionDefaultsToNoUpdateNeeded)239 TEST_F(CompositionTestPreComposition, preCompositionDefaultsToNoUpdateNeeded) {
240 EXPECT_CALL(*mLayer1FE, onPreComposition(_)).WillOnce(Return(false));
241 EXPECT_CALL(*mLayer2FE, onPreComposition(_)).WillOnce(Return(false));
242 EXPECT_CALL(*mLayer3FE, onPreComposition(_)).WillOnce(Return(false));
243
244 mEngine.setNeedsAnotherUpdateForTest(true);
245
246 mRefreshArgs.outputs = {mOutput1};
247 mRefreshArgs.layers = {mLayer1FE, mLayer2FE, mLayer3FE};
248
249 mEngine.preComposition(mRefreshArgs);
250
251 // The call should have cleared the needsAnotherUpdate flag
252 EXPECT_FALSE(mEngine.needsAnotherUpdate());
253 }
254
TEST_F(CompositionTestPreComposition,preCompositionSetsNeedsAnotherUpdateIfAtLeastOneLayerRequestsIt)255 TEST_F(CompositionTestPreComposition,
256 preCompositionSetsNeedsAnotherUpdateIfAtLeastOneLayerRequestsIt) {
257 EXPECT_CALL(*mLayer1FE, onPreComposition(_)).WillOnce(Return(true));
258 EXPECT_CALL(*mLayer2FE, onPreComposition(_)).WillOnce(Return(false));
259 EXPECT_CALL(*mLayer3FE, onPreComposition(_)).WillOnce(Return(false));
260
261 mRefreshArgs.outputs = {mOutput1};
262 mRefreshArgs.layers = {mLayer1FE, mLayer2FE, mLayer3FE};
263
264 mEngine.preComposition(mRefreshArgs);
265
266 EXPECT_TRUE(mEngine.needsAnotherUpdate());
267 }
268
269 } // namespace
270 } // namespace android::compositionengine
271