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