1 /*
2 * Copyright 2021 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 #undef LOG_TAG
18 #define LOG_TAG "LayerStateTest"
19
20 #include <aidl/android/hardware/graphics/common/BufferUsage.h>
21 #include <compositionengine/impl/OutputLayer.h>
22 #include <compositionengine/impl/planner/LayerState.h>
23 #include <compositionengine/mock/LayerFE.h>
24 #include <compositionengine/mock/OutputLayer.h>
25 #include <gtest/gtest.h>
26 #include <log/log.h>
27
28 #include "android/hardware_buffer.h"
29 #include "compositionengine/LayerFECompositionState.h"
30
31 #include <aidl/android/hardware/graphics/composer3/Composition.h>
32
33 using ::aidl::android::hardware::graphics::common::BufferUsage;
34 using ::aidl::android::hardware::graphics::composer3::Composition;
35
36 namespace android::compositionengine::impl::planner {
37 namespace {
38
39 using testing::Return;
40 using testing::ReturnRef;
41
42 const std::string sDebugName = std::string("Test LayerFE");
43 const std::string sDebugNameTwo = std::string("Test LayerFE2");
44 const constexpr int32_t sSequenceId = 12345;
45 const constexpr int32_t sSequenceIdTwo = 123456;
46 const Rect sRectOne = Rect(10, 20, 30, 40);
47 const Rect sRectTwo = Rect(40, 30, 20, 10);
48 const FloatRect sFloatRectOne = FloatRect(100.f, 200.f, 300.f, 400.f);
49 const FloatRect sFloatRectTwo = FloatRect(400.f, 300.f, 200.f, 100.f);
50 const constexpr float sAlphaOne = 0.25f;
51 const constexpr float sAlphaTwo = 0.5f;
52 const Region sRegionOne = Region(sRectOne);
53 const Region sRegionTwo = Region(sRectTwo);
54 const mat4 sMat4One = mat4::scale(vec4(2.f, 3.f, 1.f, 1.f));
55 native_handle_t* const sFakeSidebandStreamOne = reinterpret_cast<native_handle_t*>(10);
56 native_handle_t* const sFakeSidebandStreamTwo = reinterpret_cast<native_handle_t*>(11);
57 const half4 sHalf4One = half4(0.2f, 0.3f, 0.4f, 0.5f);
58 const half4 sHalf4Two = half4(0.5f, 0.4f, 0.3f, 0.2f);
59 const std::string sMetadataKeyOne = std::string("Meta!");
60 const std::string sMetadataKeyTwo = std::string("Data!");
61 const GenericLayerMetadataEntry sMetadataValueOne = GenericLayerMetadataEntry{
62 .value = std::vector<uint8_t>({1, 2}),
63 };
64 const GenericLayerMetadataEntry sMetadataValueTwo = GenericLayerMetadataEntry{
65 .value = std::vector<uint8_t>({1, 3}),
66 };
67 const constexpr int32_t sBgBlurRadiusOne = 3;
68 const constexpr int32_t sBgBlurRadiusTwo = 4;
69 const BlurRegion sBlurRegionOne = BlurRegion{1, 2.f, 3.f, 4.f, 5.f, 6.f, 7, 8, 9, 10};
70 const BlurRegion sBlurRegionTwo = BlurRegion{2, 3.f, 4.f, 5.f, 6.f, 7.f, 8, 9, 10, 11};
71
72 struct LayerStateTest : public testing::Test {
LayerStateTestandroid::compositionengine::impl::planner::__anonf1bed48c0111::LayerStateTest73 LayerStateTest() {
74 const ::testing::TestInfo* const test_info =
75 ::testing::UnitTest::GetInstance()->current_test_info();
76 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
77 }
78
~LayerStateTestandroid::compositionengine::impl::planner::__anonf1bed48c0111::LayerStateTest79 ~LayerStateTest() {
80 const ::testing::TestInfo* const test_info =
81 ::testing::UnitTest::GetInstance()->current_test_info();
82 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
83 }
84
setupMocksForLayerandroid::compositionengine::impl::planner::__anonf1bed48c0111::LayerStateTest85 void setupMocksForLayer(mock::OutputLayer& layer, mock::LayerFE& layerFE,
86 const OutputLayerCompositionState& outputLayerState,
87 const LayerFECompositionState& layerFEState,
88 int32_t sequenceId = sSequenceId,
89 const std::string& debugName = sDebugName) {
90 EXPECT_CALL(layer, getLayerFE()).WillRepeatedly(ReturnRef(layerFE));
91 EXPECT_CALL(layer, getState()).WillRepeatedly(ReturnRef(outputLayerState));
92 EXPECT_CALL(layerFE, getSequence()).WillRepeatedly(Return(sequenceId));
93 EXPECT_CALL(layerFE, getDebugName()).WillRepeatedly(Return(debugName.c_str()));
94 EXPECT_CALL(layerFE, getCompositionState()).WillRepeatedly(Return(&layerFEState));
95 }
96
verifyUniqueDifferingFieldsandroid::compositionengine::impl::planner::__anonf1bed48c0111::LayerStateTest97 void verifyUniqueDifferingFields(const LayerState& lhs, const LayerState& rhs) {
98 EXPECT_EQ(lhs.getHash(), rhs.getHash());
99
100 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::None), lhs.getDifferingFields(rhs));
101 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::None), rhs.getDifferingFields(lhs));
102 }
103
verifyNonUniqueDifferingFieldsandroid::compositionengine::impl::planner::__anonf1bed48c0111::LayerStateTest104 void verifyNonUniqueDifferingFields(const LayerState& lhs, const LayerState& rhs,
105 ftl::Flags<LayerStateField> fields) {
106 EXPECT_NE(lhs.getHash(), rhs.getHash());
107
108 EXPECT_EQ(fields, lhs.getDifferingFields(rhs));
109 EXPECT_EQ(fields, rhs.getDifferingFields(lhs));
110 }
111
112 sp<mock::LayerFE> mLayerFE = sp<mock::LayerFE>::make();
113 mock::OutputLayer mOutputLayer;
114 std::unique_ptr<LayerState> mLayerState;
115 };
116
TEST_F(LayerStateTest,getOutputLayer)117 TEST_F(LayerStateTest, getOutputLayer) {
118 OutputLayerCompositionState outputLayerCompositionState;
119 LayerFECompositionState layerFECompositionState;
120 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
121 layerFECompositionState);
122 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
123 EXPECT_EQ(&mOutputLayer, mLayerState->getOutputLayer());
124 }
125
TEST_F(LayerStateTest,updateOutputLayer)126 TEST_F(LayerStateTest, updateOutputLayer) {
127 OutputLayerCompositionState outputLayerCompositionState;
128 LayerFECompositionState layerFECompositionState;
129 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
130 layerFECompositionState);
131 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
132 EXPECT_EQ(&mOutputLayer, mLayerState->getOutputLayer());
133
134 mock::OutputLayer newOutputLayer;
135 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
136 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
137 layerFECompositionState);
138 mLayerState->update(&newOutputLayer);
139 EXPECT_EQ(&newOutputLayer, mLayerState->getOutputLayer());
140 }
141
TEST_F(LayerStateTest,getId)142 TEST_F(LayerStateTest, getId) {
143 OutputLayerCompositionState outputLayerCompositionState;
144 LayerFECompositionState layerFECompositionState;
145 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
146 layerFECompositionState);
147 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
148 EXPECT_EQ(sSequenceId, mLayerState->getId());
149 }
150
TEST_F(LayerStateTest,updateId)151 TEST_F(LayerStateTest, updateId) {
152 OutputLayerCompositionState outputLayerCompositionState;
153 LayerFECompositionState layerFECompositionState;
154 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
155 layerFECompositionState);
156 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
157
158 mock::OutputLayer newOutputLayer;
159 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
160 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
161 layerFECompositionState, sSequenceIdTwo);
162 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
163 EXPECT_EQ(sSequenceIdTwo, mLayerState->getId());
164 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::Id), updates);
165 }
166
TEST_F(LayerStateTest,compareId)167 TEST_F(LayerStateTest, compareId) {
168 OutputLayerCompositionState outputLayerCompositionState;
169 LayerFECompositionState layerFECompositionState;
170 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
171 layerFECompositionState);
172 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
173 mock::OutputLayer newOutputLayer;
174 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
175 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
176 layerFECompositionState, sSequenceIdTwo);
177 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
178
179 EXPECT_NE(mLayerState->getId(), otherLayerState->getId());
180
181 // Id is a unique field, so it's not computed in the hash for a layer state.
182 verifyUniqueDifferingFields(*mLayerState, *otherLayerState);
183 EXPECT_FALSE(mLayerState->compare(*otherLayerState));
184 EXPECT_FALSE(otherLayerState->compare(*mLayerState));
185 }
186
TEST_F(LayerStateTest,getName)187 TEST_F(LayerStateTest, getName) {
188 OutputLayerCompositionState outputLayerCompositionState;
189 LayerFECompositionState layerFECompositionState;
190 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
191 layerFECompositionState);
192 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
193 EXPECT_EQ(sDebugName, mLayerState->getName());
194 }
195
TEST_F(LayerStateTest,updateName)196 TEST_F(LayerStateTest, updateName) {
197 OutputLayerCompositionState outputLayerCompositionState;
198 LayerFECompositionState layerFECompositionState;
199 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
200 layerFECompositionState);
201 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
202
203 mock::OutputLayer newOutputLayer;
204 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
205 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
206 layerFECompositionState, sSequenceId, sDebugNameTwo);
207 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
208 EXPECT_EQ(sDebugNameTwo, mLayerState->getName());
209 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::Name), updates);
210 }
211
TEST_F(LayerStateTest,compareName)212 TEST_F(LayerStateTest, compareName) {
213 OutputLayerCompositionState outputLayerCompositionState;
214 LayerFECompositionState layerFECompositionState;
215 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
216 layerFECompositionState);
217 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
218 mock::OutputLayer newOutputLayer;
219 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
220 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
221 layerFECompositionState, sSequenceId, sDebugNameTwo);
222 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
223
224 EXPECT_NE(mLayerState->getName(), otherLayerState->getName());
225
226 // Name is a unique field, so it's not computed in the hash for a layer state.
227 verifyUniqueDifferingFields(*mLayerState, *otherLayerState);
228 EXPECT_FALSE(mLayerState->compare(*otherLayerState));
229 EXPECT_FALSE(otherLayerState->compare(*mLayerState));
230 }
231
TEST_F(LayerStateTest,getDisplayFrame)232 TEST_F(LayerStateTest, getDisplayFrame) {
233 OutputLayerCompositionState outputLayerCompositionState;
234 outputLayerCompositionState.displayFrame = sRectOne;
235 LayerFECompositionState layerFECompositionState;
236 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
237 layerFECompositionState);
238 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
239 EXPECT_EQ(sRectOne, mLayerState->getDisplayFrame());
240 }
241
TEST_F(LayerStateTest,updateDisplayFrame)242 TEST_F(LayerStateTest, updateDisplayFrame) {
243 OutputLayerCompositionState outputLayerCompositionState;
244 outputLayerCompositionState.displayFrame = sRectOne;
245 LayerFECompositionState layerFECompositionState;
246 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
247 layerFECompositionState);
248 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
249
250 mock::OutputLayer newOutputLayer;
251 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
252 OutputLayerCompositionState outputLayerCompositionStateTwo;
253 outputLayerCompositionStateTwo.displayFrame = sRectTwo;
254 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
255 layerFECompositionState);
256 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
257 EXPECT_EQ(sRectTwo, mLayerState->getDisplayFrame());
258 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::DisplayFrame), updates);
259 }
260
TEST_F(LayerStateTest,compareDisplayFrame)261 TEST_F(LayerStateTest, compareDisplayFrame) {
262 OutputLayerCompositionState outputLayerCompositionState;
263 outputLayerCompositionState.displayFrame = sRectOne;
264 LayerFECompositionState layerFECompositionState;
265 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
266 layerFECompositionState);
267 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
268 mock::OutputLayer newOutputLayer;
269 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
270 OutputLayerCompositionState outputLayerCompositionStateTwo;
271 outputLayerCompositionStateTwo.displayFrame = sRectTwo;
272 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
273 layerFECompositionState);
274 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
275
276 EXPECT_NE(mLayerState->getDisplayFrame(), otherLayerState->getDisplayFrame());
277
278 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::DisplayFrame);
279 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
280 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
281 }
282
TEST_F(LayerStateTest,getCompositionType)283 TEST_F(LayerStateTest, getCompositionType) {
284 OutputLayerCompositionState outputLayerCompositionState;
285 LayerFECompositionState layerFECompositionState;
286 layerFECompositionState.compositionType = Composition::DEVICE;
287 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
288 layerFECompositionState);
289 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
290 EXPECT_EQ(Composition::DEVICE, mLayerState->getCompositionType());
291 }
292
TEST_F(LayerStateTest,getCompositionType_forcedClient)293 TEST_F(LayerStateTest, getCompositionType_forcedClient) {
294 OutputLayerCompositionState outputLayerCompositionState;
295 outputLayerCompositionState.forceClientComposition = true;
296 LayerFECompositionState layerFECompositionState;
297 layerFECompositionState.compositionType = Composition::DEVICE;
298 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
299 layerFECompositionState);
300 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
301 EXPECT_EQ(Composition::CLIENT, mLayerState->getCompositionType());
302 }
303
TEST_F(LayerStateTest,updateCompositionType)304 TEST_F(LayerStateTest, updateCompositionType) {
305 OutputLayerCompositionState outputLayerCompositionState;
306 LayerFECompositionState layerFECompositionState;
307 layerFECompositionState.compositionType = Composition::DEVICE;
308 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
309 layerFECompositionState);
310 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
311
312 mock::OutputLayer newOutputLayer;
313 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
314 LayerFECompositionState layerFECompositionStateTwo;
315 layerFECompositionStateTwo.compositionType = Composition::SOLID_COLOR;
316 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
317 layerFECompositionStateTwo);
318 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
319 EXPECT_EQ(Composition::SOLID_COLOR, mLayerState->getCompositionType());
320 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::CompositionType), updates);
321 }
322
TEST_F(LayerStateTest,compareCompositionType)323 TEST_F(LayerStateTest, compareCompositionType) {
324 OutputLayerCompositionState outputLayerCompositionState;
325 LayerFECompositionState layerFECompositionState;
326 layerFECompositionState.compositionType = Composition::DEVICE;
327 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
328 layerFECompositionState);
329 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
330 mock::OutputLayer newOutputLayer;
331 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
332 LayerFECompositionState layerFECompositionStateTwo;
333 layerFECompositionStateTwo.compositionType = Composition::SOLID_COLOR;
334 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
335 layerFECompositionStateTwo);
336 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
337
338 EXPECT_NE(mLayerState->getCompositionType(), otherLayerState->getCompositionType());
339
340 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState,
341 LayerStateField::CompositionType);
342 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
343 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
344 }
345
TEST_F(LayerStateTest,updateBuffer)346 TEST_F(LayerStateTest, updateBuffer) {
347 OutputLayerCompositionState outputLayerCompositionState;
348 LayerFECompositionState layerFECompositionState;
349 layerFECompositionState.buffer = new GraphicBuffer();
350 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
351 layerFECompositionState);
352 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
353
354 mock::OutputLayer newOutputLayer;
355 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
356 LayerFECompositionState layerFECompositionStateTwo;
357 layerFECompositionStateTwo.buffer = new GraphicBuffer();
358 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
359 layerFECompositionStateTwo);
360 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
361 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::Buffer), updates);
362 }
363
TEST_F(LayerStateTest,updateBufferSingleBufferedLegacy)364 TEST_F(LayerStateTest, updateBufferSingleBufferedLegacy) {
365 OutputLayerCompositionState outputLayerCompositionState;
366 LayerFECompositionState layerFECompositionState;
367 layerFECompositionState.buffer = new GraphicBuffer();
368 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
369 layerFECompositionState);
370 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
371
372 mock::OutputLayer newOutputLayer;
373 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
374 LayerFECompositionState layerFECompositionStateTwo;
375 layerFECompositionStateTwo.buffer = new GraphicBuffer();
376 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
377 layerFECompositionStateTwo);
378
379 for (uint64_t i = 0; i < 10; i++) {
380 layerFECompositionStateTwo.frameNumber = i;
381 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
382 layerFECompositionStateTwo);
383 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
384 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::Buffer), updates);
385 }
386 }
387
TEST_F(LayerStateTest,updateBufferSingleBufferedUsage)388 TEST_F(LayerStateTest, updateBufferSingleBufferedUsage) {
389 OutputLayerCompositionState outputLayerCompositionState;
390 LayerFECompositionState layerFECompositionState;
391 layerFECompositionState.buffer = new GraphicBuffer();
392 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
393 layerFECompositionState);
394 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
395
396 mock::OutputLayer newOutputLayer;
397 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
398 LayerFECompositionState layerFECompositionStateTwo;
399 layerFECompositionStateTwo.buffer = new GraphicBuffer();
400 layerFECompositionStateTwo.buffer->usage = static_cast<uint64_t>(BufferUsage::FRONT_BUFFER);
401 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
402 layerFECompositionStateTwo);
403
404 for (uint64_t i = 0; i < 10; i++) {
405 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
406 layerFECompositionStateTwo);
407 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
408 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::Buffer), updates);
409 }
410 }
411
TEST_F(LayerStateTest,compareBuffer)412 TEST_F(LayerStateTest, compareBuffer) {
413 OutputLayerCompositionState outputLayerCompositionState;
414 LayerFECompositionState layerFECompositionState;
415 layerFECompositionState.buffer = new GraphicBuffer();
416 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
417 layerFECompositionState);
418 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
419 mock::OutputLayer newOutputLayer;
420 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
421 LayerFECompositionState layerFECompositionStateTwo;
422 layerFECompositionStateTwo.buffer = new GraphicBuffer();
423 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
424 layerFECompositionStateTwo);
425 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
426
427 // A buffer is not a unique field, but the assertions are the same.
428 verifyUniqueDifferingFields(*mLayerState, *otherLayerState);
429
430 // Buffers are explicitly excluded from comparison
431 EXPECT_FALSE(mLayerState->compare(*otherLayerState));
432 EXPECT_FALSE(otherLayerState->compare(*mLayerState));
433 }
434
TEST_F(LayerStateTest,updateSourceCrop)435 TEST_F(LayerStateTest, updateSourceCrop) {
436 OutputLayerCompositionState outputLayerCompositionState;
437 outputLayerCompositionState.sourceCrop = sFloatRectOne;
438 LayerFECompositionState layerFECompositionState;
439 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
440 layerFECompositionState);
441 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
442
443 mock::OutputLayer newOutputLayer;
444 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
445 OutputLayerCompositionState outputLayerCompositionStateTwo;
446 outputLayerCompositionStateTwo.sourceCrop = sFloatRectTwo;
447 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
448 layerFECompositionState);
449 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
450 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::SourceCrop), updates);
451 }
452
TEST_F(LayerStateTest,compareSourceCrop)453 TEST_F(LayerStateTest, compareSourceCrop) {
454 OutputLayerCompositionState outputLayerCompositionState;
455 outputLayerCompositionState.sourceCrop = sFloatRectOne;
456 LayerFECompositionState layerFECompositionState;
457 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
458 layerFECompositionState);
459 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
460 mock::OutputLayer newOutputLayer;
461 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
462 OutputLayerCompositionState outputLayerCompositionStateTwo;
463 outputLayerCompositionStateTwo.sourceCrop = sFloatRectTwo;
464 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
465 layerFECompositionState);
466 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
467
468 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::SourceCrop);
469
470 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
471 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
472 }
473
TEST_F(LayerStateTest,updateBufferTransform)474 TEST_F(LayerStateTest, updateBufferTransform) {
475 OutputLayerCompositionState outputLayerCompositionState;
476 outputLayerCompositionState.bufferTransform = Hwc2::Transform::FLIP_H;
477 LayerFECompositionState layerFECompositionState;
478 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
479 layerFECompositionState);
480 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
481
482 mock::OutputLayer newOutputLayer;
483 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
484 OutputLayerCompositionState outputLayerCompositionStateTwo;
485 outputLayerCompositionStateTwo.bufferTransform = Hwc2::Transform::FLIP_V;
486 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
487 layerFECompositionState);
488 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
489 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::BufferTransform), updates);
490 }
491
TEST_F(LayerStateTest,compareBufferTransform)492 TEST_F(LayerStateTest, compareBufferTransform) {
493 OutputLayerCompositionState outputLayerCompositionState;
494 outputLayerCompositionState.bufferTransform = Hwc2::Transform::FLIP_H;
495 LayerFECompositionState layerFECompositionState;
496 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
497 layerFECompositionState);
498 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
499 mock::OutputLayer newOutputLayer;
500 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
501 OutputLayerCompositionState outputLayerCompositionStateTwo;
502 outputLayerCompositionStateTwo.bufferTransform = Hwc2::Transform::FLIP_V;
503 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
504 layerFECompositionState);
505 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
506
507 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState,
508 LayerStateField::BufferTransform);
509
510 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
511 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
512 }
513
TEST_F(LayerStateTest,updateBlendMode)514 TEST_F(LayerStateTest, updateBlendMode) {
515 OutputLayerCompositionState outputLayerCompositionState;
516 LayerFECompositionState layerFECompositionState;
517 layerFECompositionState.blendMode = hal::BlendMode::COVERAGE;
518 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
519 layerFECompositionState);
520 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
521
522 mock::OutputLayer newOutputLayer;
523 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
524 LayerFECompositionState layerFECompositionStateTwo;
525 layerFECompositionStateTwo.blendMode = hal::BlendMode::PREMULTIPLIED;
526 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
527 layerFECompositionStateTwo);
528 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
529 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::BlendMode), updates);
530 }
531
TEST_F(LayerStateTest,compareBlendMode)532 TEST_F(LayerStateTest, compareBlendMode) {
533 OutputLayerCompositionState outputLayerCompositionState;
534 LayerFECompositionState layerFECompositionState;
535 layerFECompositionState.blendMode = hal::BlendMode::COVERAGE;
536 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
537 layerFECompositionState);
538 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
539 mock::OutputLayer newOutputLayer;
540 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
541 LayerFECompositionState layerFECompositionStateTwo;
542 layerFECompositionStateTwo.blendMode = hal::BlendMode::PREMULTIPLIED;
543 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
544 layerFECompositionStateTwo);
545 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
546
547 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::BlendMode);
548
549 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
550 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
551 }
552
TEST_F(LayerStateTest,updateAlpha)553 TEST_F(LayerStateTest, updateAlpha) {
554 OutputLayerCompositionState outputLayerCompositionState;
555 LayerFECompositionState layerFECompositionState;
556 layerFECompositionState.alpha = sAlphaOne;
557 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
558 layerFECompositionState);
559 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
560
561 mock::OutputLayer newOutputLayer;
562 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
563 LayerFECompositionState layerFECompositionStateTwo;
564 layerFECompositionStateTwo.alpha = sAlphaTwo;
565 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
566 layerFECompositionStateTwo);
567 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
568 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::Alpha), updates);
569 }
570
TEST_F(LayerStateTest,compareAlpha)571 TEST_F(LayerStateTest, compareAlpha) {
572 OutputLayerCompositionState outputLayerCompositionState;
573 LayerFECompositionState layerFECompositionState;
574 layerFECompositionState.alpha = sAlphaOne;
575 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
576 layerFECompositionState);
577 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
578 mock::OutputLayer newOutputLayer;
579 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
580 LayerFECompositionState layerFECompositionStateTwo;
581 layerFECompositionStateTwo.alpha = sAlphaTwo;
582 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
583 layerFECompositionStateTwo);
584 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
585
586 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::Alpha);
587
588 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
589 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
590 }
591
TEST_F(LayerStateTest,updateLayerMetadata)592 TEST_F(LayerStateTest, updateLayerMetadata) {
593 OutputLayerCompositionState outputLayerCompositionState;
594 LayerFECompositionState layerFECompositionState;
595 layerFECompositionState.metadata[sMetadataKeyOne] = sMetadataValueOne;
596 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
597 layerFECompositionState);
598 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
599
600 mock::OutputLayer newOutputLayer;
601 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
602 LayerFECompositionState layerFECompositionStateTwo;
603 layerFECompositionStateTwo.metadata[sMetadataKeyTwo] = sMetadataValueTwo;
604 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
605 layerFECompositionStateTwo);
606 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
607 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::LayerMetadata), updates);
608 }
609
TEST_F(LayerStateTest,compareLayerMetadata)610 TEST_F(LayerStateTest, compareLayerMetadata) {
611 OutputLayerCompositionState outputLayerCompositionState;
612 LayerFECompositionState layerFECompositionState;
613 layerFECompositionState.metadata[sMetadataKeyOne] = sMetadataValueOne;
614 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
615 layerFECompositionState);
616 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
617 mock::OutputLayer newOutputLayer;
618 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
619 LayerFECompositionState layerFECompositionStateTwo;
620 layerFECompositionStateTwo.metadata[sMetadataKeyTwo] = sMetadataValueTwo;
621 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
622 layerFECompositionStateTwo);
623 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
624
625 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::LayerMetadata);
626
627 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
628 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
629 }
630
TEST_F(LayerStateTest,getVisibleRegion)631 TEST_F(LayerStateTest, getVisibleRegion) {
632 OutputLayerCompositionState outputLayerCompositionState;
633 outputLayerCompositionState.visibleRegion = sRegionOne;
634 LayerFECompositionState layerFECompositionState;
635 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
636 layerFECompositionState);
637 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
638 EXPECT_TRUE(mLayerState->getVisibleRegion().hasSameRects(sRegionOne));
639 }
640
TEST_F(LayerStateTest,updateVisibleRegion)641 TEST_F(LayerStateTest, updateVisibleRegion) {
642 OutputLayerCompositionState outputLayerCompositionState;
643 outputLayerCompositionState.visibleRegion = sRegionOne;
644 LayerFECompositionState layerFECompositionState;
645 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
646 layerFECompositionState);
647 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
648
649 mock::OutputLayer newOutputLayer;
650 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
651 OutputLayerCompositionState outputLayerCompositionStateTwo;
652 outputLayerCompositionStateTwo.visibleRegion = sRegionTwo;
653 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
654 layerFECompositionState);
655 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
656 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::VisibleRegion), updates);
657 }
658
TEST_F(LayerStateTest,compareVisibleRegion)659 TEST_F(LayerStateTest, compareVisibleRegion) {
660 OutputLayerCompositionState outputLayerCompositionState;
661 outputLayerCompositionState.visibleRegion = sRegionOne;
662 LayerFECompositionState layerFECompositionState;
663 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
664 layerFECompositionState);
665 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
666 mock::OutputLayer newOutputLayer;
667 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
668 OutputLayerCompositionState outputLayerCompositionStateTwo;
669 outputLayerCompositionStateTwo.visibleRegion = sRegionTwo;
670 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
671 layerFECompositionState);
672 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
673
674 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::VisibleRegion);
675
676 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
677 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
678 }
679
TEST_F(LayerStateTest,updateDataspace)680 TEST_F(LayerStateTest, updateDataspace) {
681 OutputLayerCompositionState outputLayerCompositionState;
682 outputLayerCompositionState.dataspace = ui::Dataspace::SRGB;
683 LayerFECompositionState layerFECompositionState;
684 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
685 layerFECompositionState);
686 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
687
688 mock::OutputLayer newOutputLayer;
689 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
690 OutputLayerCompositionState outputLayerCompositionStateTwo;
691 outputLayerCompositionStateTwo.dataspace = ui::Dataspace::DISPLAY_P3;
692 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
693 layerFECompositionState);
694 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
695 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::Dataspace), updates);
696 }
697
TEST_F(LayerStateTest,compareDataspace)698 TEST_F(LayerStateTest, compareDataspace) {
699 OutputLayerCompositionState outputLayerCompositionState;
700 outputLayerCompositionState.dataspace = ui::Dataspace::SRGB;
701 LayerFECompositionState layerFECompositionState;
702 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
703 layerFECompositionState);
704 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
705 mock::OutputLayer newOutputLayer;
706 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
707 OutputLayerCompositionState outputLayerCompositionStateTwo;
708 outputLayerCompositionStateTwo.dataspace = ui::Dataspace::DISPLAY_P3;
709 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
710 layerFECompositionState);
711 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
712
713 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::Dataspace);
714
715 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
716 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
717 }
718
TEST_F(LayerStateTest,updatePixelFormat)719 TEST_F(LayerStateTest, updatePixelFormat) {
720 OutputLayerCompositionState outputLayerCompositionState;
721 LayerFECompositionState layerFECompositionState;
722 layerFECompositionState.buffer =
723 new GraphicBuffer(1, 1, PIXEL_FORMAT_RGBA_8888,
724 AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
725 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
726 "buffer1");
727 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
728 layerFECompositionState);
729 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
730
731 mock::OutputLayer newOutputLayer;
732 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
733 LayerFECompositionState layerFECompositionStateTwo;
734 layerFECompositionStateTwo.buffer =
735 new GraphicBuffer(1, 1, PIXEL_FORMAT_RGBX_8888,
736 AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
737 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
738 "buffer2");
739 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
740 layerFECompositionStateTwo);
741 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
742 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::Buffer) |
743 ftl::Flags<LayerStateField>(LayerStateField::PixelFormat),
744 updates);
745 }
746
TEST_F(LayerStateTest,comparePixelFormat)747 TEST_F(LayerStateTest, comparePixelFormat) {
748 OutputLayerCompositionState outputLayerCompositionState;
749 LayerFECompositionState layerFECompositionState;
750 layerFECompositionState.buffer =
751 new GraphicBuffer(1, 1, PIXEL_FORMAT_RGBA_8888,
752 AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
753 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
754 "buffer1");
755 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
756 layerFECompositionState);
757 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
758 mock::OutputLayer newOutputLayer;
759 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
760 LayerFECompositionState layerFECompositionStateTwo;
761 layerFECompositionStateTwo.buffer =
762 new GraphicBuffer(1, 1, PIXEL_FORMAT_RGBX_8888,
763 AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
764 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
765 "buffer2");
766 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
767 layerFECompositionStateTwo);
768 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
769
770 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState,
771 ftl::Flags<LayerStateField>(LayerStateField::PixelFormat));
772
773 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
774 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
775 }
776
TEST_F(LayerStateTest,updateColorTransform)777 TEST_F(LayerStateTest, updateColorTransform) {
778 OutputLayerCompositionState outputLayerCompositionState;
779 LayerFECompositionState layerFECompositionState;
780 layerFECompositionState.colorTransformIsIdentity = true;
781 layerFECompositionState.colorTransform = mat4();
782 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
783 layerFECompositionState);
784 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
785
786 mock::OutputLayer newOutputLayer;
787 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
788 LayerFECompositionState layerFECompositionStateTwo;
789 layerFECompositionStateTwo.colorTransformIsIdentity = false;
790 layerFECompositionStateTwo.colorTransform = sMat4One;
791 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
792 layerFECompositionStateTwo);
793 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
794 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::ColorTransform), updates);
795 }
796
TEST_F(LayerStateTest,compareColorTransform)797 TEST_F(LayerStateTest, compareColorTransform) {
798 OutputLayerCompositionState outputLayerCompositionState;
799 LayerFECompositionState layerFECompositionState;
800 layerFECompositionState.colorTransformIsIdentity = true;
801 layerFECompositionState.colorTransform = mat4();
802 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
803 layerFECompositionState);
804 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
805 mock::OutputLayer newOutputLayer;
806 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
807 LayerFECompositionState layerFECompositionStateTwo;
808 layerFECompositionStateTwo.colorTransformIsIdentity = false;
809 layerFECompositionStateTwo.colorTransform = sMat4One;
810 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
811 layerFECompositionStateTwo);
812 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
813
814 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::ColorTransform);
815
816 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
817 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
818 }
819
TEST_F(LayerStateTest,updateSidebandStream)820 TEST_F(LayerStateTest, updateSidebandStream) {
821 OutputLayerCompositionState outputLayerCompositionState;
822 LayerFECompositionState layerFECompositionState;
823 layerFECompositionState.sidebandStream = NativeHandle::create(sFakeSidebandStreamOne, false);
824 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
825 layerFECompositionState);
826 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
827
828 mock::OutputLayer newOutputLayer;
829 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
830 LayerFECompositionState layerFECompositionStateTwo;
831 layerFECompositionStateTwo.sidebandStream = NativeHandle::create(sFakeSidebandStreamTwo, false);
832 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
833 layerFECompositionStateTwo);
834 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
835 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::SidebandStream), updates);
836 }
837
TEST_F(LayerStateTest,compareSidebandStream)838 TEST_F(LayerStateTest, compareSidebandStream) {
839 OutputLayerCompositionState outputLayerCompositionState;
840 LayerFECompositionState layerFECompositionState;
841 layerFECompositionState.sidebandStream = NativeHandle::create(sFakeSidebandStreamOne, false);
842 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
843 layerFECompositionState);
844 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
845 mock::OutputLayer newOutputLayer;
846 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
847 LayerFECompositionState layerFECompositionStateTwo;
848 layerFECompositionStateTwo.sidebandStream = NativeHandle::create(sFakeSidebandStreamTwo, false);
849 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
850 layerFECompositionStateTwo);
851 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
852
853 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::SidebandStream);
854
855 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
856 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
857 }
858
TEST_F(LayerStateTest,updateSolidColor)859 TEST_F(LayerStateTest, updateSolidColor) {
860 OutputLayerCompositionState outputLayerCompositionState;
861 LayerFECompositionState layerFECompositionState;
862 layerFECompositionState.color = sHalf4One;
863 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
864 layerFECompositionState);
865 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
866
867 mock::OutputLayer newOutputLayer;
868 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
869 LayerFECompositionState layerFECompositionStateTwo;
870 layerFECompositionStateTwo.color = sHalf4Two;
871 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
872 layerFECompositionStateTwo);
873 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
874 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::SolidColor), updates);
875 }
876
TEST_F(LayerStateTest,compareSolidColor)877 TEST_F(LayerStateTest, compareSolidColor) {
878 OutputLayerCompositionState outputLayerCompositionState;
879 LayerFECompositionState layerFECompositionState;
880 layerFECompositionState.color = sHalf4One;
881 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
882 layerFECompositionState);
883 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
884 mock::OutputLayer newOutputLayer;
885 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
886 LayerFECompositionState layerFECompositionStateTwo;
887 layerFECompositionStateTwo.color = sHalf4Two;
888 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
889 layerFECompositionStateTwo);
890 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
891
892 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::SolidColor);
893
894 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
895 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
896 }
897
TEST_F(LayerStateTest,updateBackgroundBlur)898 TEST_F(LayerStateTest, updateBackgroundBlur) {
899 OutputLayerCompositionState outputLayerCompositionState;
900 LayerFECompositionState layerFECompositionState;
901 layerFECompositionState.backgroundBlurRadius = sBgBlurRadiusOne;
902 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
903 layerFECompositionState);
904 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
905
906 mock::OutputLayer newOutputLayer;
907 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
908 LayerFECompositionState layerFECompositionStateTwo;
909 layerFECompositionStateTwo.backgroundBlurRadius = sBgBlurRadiusTwo;
910 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
911 layerFECompositionStateTwo);
912 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
913 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::BackgroundBlurRadius), updates);
914 }
915
TEST_F(LayerStateTest,compareBackgroundBlur)916 TEST_F(LayerStateTest, compareBackgroundBlur) {
917 OutputLayerCompositionState outputLayerCompositionState;
918 LayerFECompositionState layerFECompositionState;
919 layerFECompositionState.backgroundBlurRadius = sBgBlurRadiusOne;
920 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
921 layerFECompositionState);
922 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
923 mock::OutputLayer newOutputLayer;
924 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
925 LayerFECompositionState layerFECompositionStateTwo;
926 layerFECompositionStateTwo.backgroundBlurRadius = sBgBlurRadiusTwo;
927 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
928 layerFECompositionStateTwo);
929 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
930
931 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState,
932 LayerStateField::BackgroundBlurRadius);
933
934 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
935 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
936 }
937
TEST_F(LayerStateTest,updateBlurRegions)938 TEST_F(LayerStateTest, updateBlurRegions) {
939 OutputLayerCompositionState outputLayerCompositionState;
940 LayerFECompositionState layerFECompositionState;
941 layerFECompositionState.blurRegions.push_back(sBlurRegionOne);
942 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
943 layerFECompositionState);
944 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
945
946 mock::OutputLayer newOutputLayer;
947 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
948 LayerFECompositionState layerFECompositionStateTwo;
949 layerFECompositionStateTwo.blurRegions.push_back(sBlurRegionTwo);
950 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
951 layerFECompositionStateTwo);
952 ftl::Flags<LayerStateField> updates = mLayerState->update(&newOutputLayer);
953 EXPECT_EQ(ftl::Flags<LayerStateField>(LayerStateField::BlurRegions), updates);
954 }
955
TEST_F(LayerStateTest,compareBlurRegions)956 TEST_F(LayerStateTest, compareBlurRegions) {
957 OutputLayerCompositionState outputLayerCompositionState;
958 LayerFECompositionState layerFECompositionState;
959 layerFECompositionState.blurRegions.push_back(sBlurRegionOne);
960 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
961 layerFECompositionState);
962 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
963 mock::OutputLayer newOutputLayer;
964 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
965 LayerFECompositionState layerFECompositionStateTwo;
966 layerFECompositionStateTwo.blurRegions.push_back(sBlurRegionTwo);
967 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
968 layerFECompositionStateTwo);
969 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
970
971 verifyNonUniqueDifferingFields(*mLayerState, *otherLayerState, LayerStateField::BlurRegions);
972
973 EXPECT_TRUE(mLayerState->compare(*otherLayerState));
974 EXPECT_TRUE(otherLayerState->compare(*mLayerState));
975 }
976
TEST_F(LayerStateTest,hasBlurBehind_noBlur_returnsFalse)977 TEST_F(LayerStateTest, hasBlurBehind_noBlur_returnsFalse) {
978 OutputLayerCompositionState outputLayerCompositionState;
979 LayerFECompositionState layerFECompositionState;
980 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
981 layerFECompositionState);
982 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
983 EXPECT_FALSE(mLayerState->hasBlurBehind());
984 }
985
TEST_F(LayerStateTest,hasBlurBehind_withBackgroundBlur_returnsTrue)986 TEST_F(LayerStateTest, hasBlurBehind_withBackgroundBlur_returnsTrue) {
987 OutputLayerCompositionState outputLayerCompositionState;
988 LayerFECompositionState layerFECompositionState;
989 layerFECompositionState.backgroundBlurRadius = sBgBlurRadiusOne;
990 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
991 layerFECompositionState);
992 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
993 EXPECT_TRUE(mLayerState->hasBlurBehind());
994 }
995
TEST_F(LayerStateTest,hasBlurBehind_withBlurRegion_returnsTrue)996 TEST_F(LayerStateTest, hasBlurBehind_withBlurRegion_returnsTrue) {
997 OutputLayerCompositionState outputLayerCompositionState;
998 LayerFECompositionState layerFECompositionState;
999 layerFECompositionState.blurRegions.push_back(sBlurRegionOne);
1000 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
1001 layerFECompositionState);
1002 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
1003 EXPECT_TRUE(mLayerState->hasBlurBehind());
1004 }
1005
TEST_F(LayerStateTest,dumpDoesNotCrash)1006 TEST_F(LayerStateTest, dumpDoesNotCrash) {
1007 OutputLayerCompositionState outputLayerCompositionState;
1008 LayerFECompositionState layerFECompositionState;
1009 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
1010 layerFECompositionState);
1011 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
1012 std::string dump;
1013 mLayerState->dump(dump);
1014 EXPECT_TRUE(dump.size() > 0);
1015 }
1016
TEST_F(LayerStateTest,framesSinceBufferUpdate)1017 TEST_F(LayerStateTest, framesSinceBufferUpdate) {
1018 OutputLayerCompositionState outputLayerCompositionState;
1019 LayerFECompositionState layerFECompositionState;
1020 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
1021 layerFECompositionState);
1022 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
1023
1024 EXPECT_EQ(0, mLayerState->getFramesSinceBufferUpdate());
1025 mLayerState->incrementFramesSinceBufferUpdate();
1026 EXPECT_EQ(1, mLayerState->getFramesSinceBufferUpdate());
1027 mLayerState->resetFramesSinceBufferUpdate();
1028 EXPECT_EQ(0, mLayerState->getFramesSinceBufferUpdate());
1029 }
1030
TEST_F(LayerStateTest,getNonBufferHash_doesNotCommute)1031 TEST_F(LayerStateTest, getNonBufferHash_doesNotCommute) {
1032 OutputLayerCompositionState outputLayerCompositionState;
1033 outputLayerCompositionState.displayFrame = sRectOne;
1034 LayerFECompositionState layerFECompositionState;
1035 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
1036 layerFECompositionState);
1037 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
1038 mock::OutputLayer newOutputLayer;
1039 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
1040 OutputLayerCompositionState outputLayerCompositionStateTwo;
1041 outputLayerCompositionStateTwo.displayFrame = sRectTwo;
1042 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
1043 layerFECompositionState);
1044 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
1045
1046 EXPECT_NE(getNonBufferHash({mLayerState.get(), otherLayerState.get()}),
1047 getNonBufferHash({otherLayerState.get(), mLayerState.get()}));
1048 }
1049
TEST_F(LayerStateTest,getNonBufferHash_isIdempotent)1050 TEST_F(LayerStateTest, getNonBufferHash_isIdempotent) {
1051 OutputLayerCompositionState outputLayerCompositionState;
1052 outputLayerCompositionState.displayFrame = sRectOne;
1053 LayerFECompositionState layerFECompositionState;
1054 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
1055 layerFECompositionState);
1056 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
1057 mock::OutputLayer newOutputLayer;
1058 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
1059 OutputLayerCompositionState outputLayerCompositionStateTwo;
1060 outputLayerCompositionStateTwo.displayFrame = sRectTwo;
1061 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionStateTwo,
1062 layerFECompositionState);
1063 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
1064
1065 EXPECT_EQ(getNonBufferHash({mLayerState.get(), otherLayerState.get()}),
1066 getNonBufferHash({mLayerState.get(), otherLayerState.get()}));
1067 }
1068
TEST_F(LayerStateTest,getNonBufferHash_filtersOutBuffers)1069 TEST_F(LayerStateTest, getNonBufferHash_filtersOutBuffers) {
1070 OutputLayerCompositionState outputLayerCompositionState;
1071 LayerFECompositionState layerFECompositionState;
1072 layerFECompositionState.buffer = new GraphicBuffer();
1073 setupMocksForLayer(mOutputLayer, *mLayerFE, outputLayerCompositionState,
1074 layerFECompositionState);
1075 mLayerState = std::make_unique<LayerState>(&mOutputLayer);
1076
1077 mock::OutputLayer newOutputLayer;
1078 sp<mock::LayerFE> newLayerFE = sp<mock::LayerFE>::make();
1079 LayerFECompositionState layerFECompositionStateTwo;
1080 layerFECompositionStateTwo.buffer = new GraphicBuffer();
1081 setupMocksForLayer(newOutputLayer, *newLayerFE, outputLayerCompositionState,
1082 layerFECompositionStateTwo);
1083 auto otherLayerState = std::make_unique<LayerState>(&newOutputLayer);
1084
1085 EXPECT_EQ(getNonBufferHash({mLayerState.get()}), getNonBufferHash({otherLayerState.get()}));
1086 }
1087
1088 } // namespace
1089 } // namespace android::compositionengine::impl::planner
1090