1 /*
2 * Copyright 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include "FrontEnd/LayerHierarchy.h"
21 #include "FrontEnd/LayerLifecycleManager.h"
22 #include "LayerHierarchyTest.h"
23
24 #define UPDATE_AND_VERIFY(HIERARCHY) \
25 ({ \
26 SCOPED_TRACE(""); \
27 updateAndVerify((HIERARCHY)); \
28 })
29
30 namespace android::surfaceflinger::frontend {
31
32 // To run test:
33 /**
34 mp :libsurfaceflinger_unittest && adb sync; adb shell \
35 /data/nativetest/libsurfaceflinger_unittest/libsurfaceflinger_unittest \
36 --gtest_filter="LayerHierarchyTest.*" --gtest_repeat=100 \
37 --gtest_shuffle \
38 --gtest_brief=1
39 */
40
41 class LayerHierarchyTest : public LayerHierarchyTestBase {
42 protected:
LayerHierarchyTest()43 LayerHierarchyTest() : LayerHierarchyTestBase() { mLifecycleManager.commitChanges(); }
44 };
45
46 // reparenting tests
TEST_F(LayerHierarchyTest,addLayer)47 TEST_F(LayerHierarchyTest, addLayer) {
48 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
49 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2};
50 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
51 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
52 expectedTraversalPath = {};
53 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
54
55 createRootLayer(3);
56 createLayer(112, 11);
57 createLayer(12211, 1221);
58 UPDATE_AND_VERIFY(hierarchyBuilder);
59 expectedTraversalPath = {1, 11, 111, 112, 12, 121, 122, 1221, 12211, 13, 2, 3};
60 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
61 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
62 expectedTraversalPath = {};
63 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
64 }
65
TEST_F(LayerHierarchyTest,reparentLayer)66 TEST_F(LayerHierarchyTest, reparentLayer) {
67 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
68 reparentLayer(2, 11);
69 reparentLayer(111, 12);
70 reparentLayer(1221, 1);
71 reparentLayer(1221, 13);
72 UPDATE_AND_VERIFY(hierarchyBuilder);
73
74 std::vector<uint32_t> expectedTraversalPath = {1, 11, 2, 12, 111, 121, 122, 13, 1221};
75 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
76 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
77 expectedTraversalPath = {};
78 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
79 }
80
TEST_F(LayerHierarchyTest,reparentLayerToNull)81 TEST_F(LayerHierarchyTest, reparentLayerToNull) {
82 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
83
84 reparentLayer(2, UNASSIGNED_LAYER_ID);
85 reparentLayer(11, UNASSIGNED_LAYER_ID);
86 reparentLayer(1221, 13);
87 reparentLayer(1221, UNASSIGNED_LAYER_ID);
88
89 UPDATE_AND_VERIFY(hierarchyBuilder);
90
91 std::vector<uint32_t> expectedTraversalPath = {1, 12, 121, 122, 13};
92 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
93 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
94 expectedTraversalPath = {2, 11, 111, 1221};
95 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
96 }
97
TEST_F(LayerHierarchyTest,reparentLayerToNullAndDestroyHandles)98 TEST_F(LayerHierarchyTest, reparentLayerToNullAndDestroyHandles) {
99 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
100 reparentLayer(2, UNASSIGNED_LAYER_ID);
101 reparentLayer(11, UNASSIGNED_LAYER_ID);
102 reparentLayer(1221, UNASSIGNED_LAYER_ID);
103
104 destroyLayerHandle(2);
105 destroyLayerHandle(11);
106 destroyLayerHandle(1221);
107
108 UPDATE_AND_VERIFY(hierarchyBuilder);
109
110 std::vector<uint32_t> expectedTraversalPath = {1, 12, 121, 122, 13};
111 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
112 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
113 expectedTraversalPath = {111};
114 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
115 }
116
TEST_F(LayerHierarchyTest,destroyHandleThenDestroyParentLayer)117 TEST_F(LayerHierarchyTest, destroyHandleThenDestroyParentLayer) {
118 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
119 destroyLayerHandle(111);
120 UPDATE_AND_VERIFY(hierarchyBuilder);
121
122 // handle is destroyed but layer is kept alive and reachable by parent
123 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2};
124 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
125 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
126 expectedTraversalPath = {};
127 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
128
129 // destroy parent layer and the child gets destroyed
130 reparentLayer(11, UNASSIGNED_LAYER_ID);
131 destroyLayerHandle(11);
132 UPDATE_AND_VERIFY(hierarchyBuilder);
133
134 expectedTraversalPath = {1, 12, 121, 122, 1221, 13, 2};
135 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
136 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
137 expectedTraversalPath = {};
138 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
139 }
140
TEST_F(LayerHierarchyTest,layerSurvivesTemporaryReparentToNull)141 TEST_F(LayerHierarchyTest, layerSurvivesTemporaryReparentToNull) {
142 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
143 reparentLayer(11, UNASSIGNED_LAYER_ID);
144 reparentLayer(11, 1);
145
146 UPDATE_AND_VERIFY(hierarchyBuilder);
147
148 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2};
149 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
150 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
151 expectedTraversalPath = {};
152 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
153 }
154
155 // offscreen tests
TEST_F(LayerHierarchyTest,layerMovesOnscreen)156 TEST_F(LayerHierarchyTest, layerMovesOnscreen) {
157 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
158
159 reparentLayer(11, UNASSIGNED_LAYER_ID);
160 UPDATE_AND_VERIFY(hierarchyBuilder);
161
162 reparentLayer(11, 1);
163 UPDATE_AND_VERIFY(hierarchyBuilder);
164
165 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2};
166 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
167 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
168 expectedTraversalPath = {};
169 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
170 }
171
TEST_F(LayerHierarchyTest,addLayerToOffscreenParent)172 TEST_F(LayerHierarchyTest, addLayerToOffscreenParent) {
173 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
174
175 reparentLayer(11, UNASSIGNED_LAYER_ID);
176 UPDATE_AND_VERIFY(hierarchyBuilder);
177
178 createLayer(112, 11);
179 UPDATE_AND_VERIFY(hierarchyBuilder);
180
181 std::vector<uint32_t> expectedTraversalPath = {1, 12, 121, 122, 1221, 13, 2};
182 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
183 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
184 expectedTraversalPath = {11, 111, 112};
185 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
186 }
187
188 // rel-z tests
TEST_F(LayerHierarchyTest,setRelativeParent)189 TEST_F(LayerHierarchyTest, setRelativeParent) {
190 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
191 reparentRelativeLayer(11, 2);
192 UPDATE_AND_VERIFY(hierarchyBuilder);
193
194 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 11, 111};
195 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
196 expectedTraversalPath = {1, 12, 121, 122, 1221, 13, 2, 11, 111};
197 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
198 expectedTraversalPath = {};
199 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
200 }
201
TEST_F(LayerHierarchyTest,reparentFromRelativeParentWithSetLayer)202 TEST_F(LayerHierarchyTest, reparentFromRelativeParentWithSetLayer) {
203 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
204 reparentRelativeLayer(11, 2);
205 UPDATE_AND_VERIFY(hierarchyBuilder);
206
207 // This calls setLayer
208 removeRelativeZ(11);
209 UPDATE_AND_VERIFY(hierarchyBuilder);
210
211 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2};
212 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
213 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
214 expectedTraversalPath = {};
215 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
216 }
217
TEST_F(LayerHierarchyTest,reparentToRelativeParent)218 TEST_F(LayerHierarchyTest, reparentToRelativeParent) {
219 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
220 reparentRelativeLayer(11, 2);
221 UPDATE_AND_VERIFY(hierarchyBuilder);
222
223 reparentLayer(11, 2);
224 UPDATE_AND_VERIFY(hierarchyBuilder);
225
226 std::vector<uint32_t> expectedTraversalPath = {1, 12, 121, 122, 1221, 13, 2, 11, 111};
227 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
228 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
229 expectedTraversalPath = {};
230 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
231 }
232
TEST_F(LayerHierarchyTest,setParentAsRelativeParent)233 TEST_F(LayerHierarchyTest, setParentAsRelativeParent) {
234 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
235 reparentLayer(11, 2);
236 UPDATE_AND_VERIFY(hierarchyBuilder);
237
238 reparentRelativeLayer(11, 2);
239 UPDATE_AND_VERIFY(hierarchyBuilder);
240
241 std::vector<uint32_t> expectedTraversalPath = {1, 12, 121, 122, 1221, 13, 2, 11, 111};
242 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
243 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
244 expectedTraversalPath = {};
245 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
246 }
247
TEST_F(LayerHierarchyTest,relativeChildMovesOffscreenIsNotTraversable)248 TEST_F(LayerHierarchyTest, relativeChildMovesOffscreenIsNotTraversable) {
249 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
250 reparentRelativeLayer(11, 2);
251 UPDATE_AND_VERIFY(hierarchyBuilder);
252
253 reparentLayer(2, UNASSIGNED_LAYER_ID);
254 UPDATE_AND_VERIFY(hierarchyBuilder);
255
256 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13};
257 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
258 expectedTraversalPath = {1, 12, 121, 122, 1221, 13};
259 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
260 expectedTraversalPath = {2, 11, 111};
261 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
262 }
263
TEST_F(LayerHierarchyTest,reparentRelativeLayer)264 TEST_F(LayerHierarchyTest, reparentRelativeLayer) {
265 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
266 reparentRelativeLayer(11, 2);
267 UPDATE_AND_VERIFY(hierarchyBuilder);
268
269 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 11, 111};
270 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
271 expectedTraversalPath = {1, 12, 121, 122, 1221, 13, 2, 11, 111};
272 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
273 expectedTraversalPath = {};
274 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
275
276 reparentLayer(11, 1);
277 UPDATE_AND_VERIFY(hierarchyBuilder);
278 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 11, 111};
279 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
280 expectedTraversalPath = {1, 12, 121, 122, 1221, 13, 2, 11, 111};
281 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
282 expectedTraversalPath = {};
283 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
284
285 setZ(11, 0);
286 UPDATE_AND_VERIFY(hierarchyBuilder);
287 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2};
288 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
289 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2};
290 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
291 expectedTraversalPath = {};
292 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
293 }
294
295 // mirror tests
TEST_F(LayerHierarchyTest,canTraverseMirrorLayer)296 TEST_F(LayerHierarchyTest, canTraverseMirrorLayer) {
297 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
298
299 mirrorLayer(/*layer*/ 14, /*parent*/ 1, /*layerToMirror*/ 11);
300 UPDATE_AND_VERIFY(hierarchyBuilder);
301
302 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122,
303 1221, 13, 14, 11, 111, 2};
304 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
305 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
306 expectedTraversalPath = {};
307 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
308 }
309
TEST_F(LayerHierarchyTest,canMirrorOffscreenLayer)310 TEST_F(LayerHierarchyTest, canMirrorOffscreenLayer) {
311 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
312
313 reparentLayer(11, UNASSIGNED_LAYER_ID);
314 mirrorLayer(/*layer*/ 14, /*parent*/ 1, /*layerToMirror*/ 11);
315 UPDATE_AND_VERIFY(hierarchyBuilder);
316
317 std::vector<uint32_t> expectedTraversalPath = {1, 12, 121, 122, 1221, 13, 14, 11, 111, 2};
318 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
319 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
320 expectedTraversalPath = {11, 111};
321 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
322 }
323
TEST_F(LayerHierarchyTest,newChildLayerIsUpdatedInMirrorHierarchy)324 TEST_F(LayerHierarchyTest, newChildLayerIsUpdatedInMirrorHierarchy) {
325 mirrorLayer(/*layer*/ 14, /*parent*/ 1, /*layerToMirror*/ 11);
326 mLifecycleManager.commitChanges();
327 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
328
329 createLayer(1111, 111);
330 createLayer(112, 11);
331 UPDATE_AND_VERIFY(hierarchyBuilder);
332
333 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 1111, 112, 12, 121, 122,
334 1221, 13, 14, 11, 111, 1111, 112, 2};
335 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
336 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
337 expectedTraversalPath = {};
338 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
339 }
340
341 // mirror & relatives tests
TEST_F(LayerHierarchyTest,mirrorWithRelativeOutsideMirrorHierarchy)342 TEST_F(LayerHierarchyTest, mirrorWithRelativeOutsideMirrorHierarchy) {
343 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
344 reparentRelativeLayer(111, 12);
345 mirrorLayer(/*layer*/ 14, /*parent*/ 1, /*layerToMirror*/ 11);
346
347 // ROOT
348 // ├── 1
349 // │ ├── 11
350 // │ │ └── 111
351 // │ ├── 12
352 // │ │ ├── 121
353 // │ │ ├── 122
354 // │ │ │ └── 1221
355 // │ │ └ - 111 (relative)
356 // │ ├── 13
357 // │ └── 14
358 // │ └ * 11 (mirroring)
359 // └── 2
360
361 UPDATE_AND_VERIFY(hierarchyBuilder);
362
363 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 111, 121, 122,
364 1221, 13, 14, 11, 111, 2};
365 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
366 // 111 is not reachable in the mirror
367 expectedTraversalPath = {1, 11, 12, 111, 121, 122, 1221, 13, 14, 11, 2};
368 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
369 expectedTraversalPath = {};
370 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
371 }
372
TEST_F(LayerHierarchyTest,mirrorWithRelativeInsideMirrorHierarchy)373 TEST_F(LayerHierarchyTest, mirrorWithRelativeInsideMirrorHierarchy) {
374 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
375 reparentRelativeLayer(1221, 12);
376 mirrorLayer(/*layer*/ 14, /*parent*/ 1, /*layerToMirror*/ 12);
377
378 // ROOT
379 // ├── 1
380 // │ ├── 11
381 // │ │ └── 111
382 // │ ├── 12
383 // │ │ ├── 121
384 // │ │ ├── 122
385 // │ │ │ └── 1221
386 // │ │ └ - 1221 (relative)
387 // │ ├── 13
388 // │ └── 14
389 // │ └ * 12 (mirroring)
390 // └── 2
391
392 UPDATE_AND_VERIFY(hierarchyBuilder);
393 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 1221,
394 13, 14, 12, 121, 122, 1221, 1221, 2};
395 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
396 // relative layer 1221 is traversable in the mirrored hierarchy as well
397 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 14, 12, 121, 122, 1221, 2};
398 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
399 expectedTraversalPath = {};
400 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
401 }
402
TEST_F(LayerHierarchyTest,childMovesOffscreenWhenRelativeParentDies)403 TEST_F(LayerHierarchyTest, childMovesOffscreenWhenRelativeParentDies) {
404 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
405
406 reparentRelativeLayer(11, 2);
407 reparentLayer(2, UNASSIGNED_LAYER_ID);
408 destroyLayerHandle(2);
409
410 UPDATE_AND_VERIFY(hierarchyBuilder);
411 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13};
412 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
413 expectedTraversalPath = {1, 12, 121, 122, 1221, 13};
414 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
415 expectedTraversalPath = {11, 111};
416 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
417
418 // remove relative parent so layer becomes onscreen again
419 removeRelativeZ(11);
420 UPDATE_AND_VERIFY(hierarchyBuilder);
421
422 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13};
423 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
424 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
425 expectedTraversalPath = {};
426 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
427 }
428
TEST_F(LayerHierarchyTest,offscreenLayerCannotBeRelativeToOnscreenLayer)429 TEST_F(LayerHierarchyTest, offscreenLayerCannotBeRelativeToOnscreenLayer) {
430 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
431 reparentRelativeLayer(1221, 2);
432 UPDATE_AND_VERIFY(hierarchyBuilder);
433
434 // verify relz path
435 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 1221};
436 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
437 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 13, 2, 1221};
438 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
439 expectedTraversalPath = {};
440 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
441
442 // offscreen layer cannot be reached as a relative child
443 reparentLayer(12, UNASSIGNED_LAYER_ID);
444 UPDATE_AND_VERIFY(hierarchyBuilder);
445
446 expectedTraversalPath = {1, 11, 111, 13, 2};
447 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
448 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
449 expectedTraversalPath = {12, 121, 122, 1221};
450 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
451
452 // layer when onscreen can be reached as a relative child again
453 reparentLayer(12, 1);
454 UPDATE_AND_VERIFY(hierarchyBuilder);
455
456 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 1221};
457 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
458 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 13, 2, 1221};
459 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
460 expectedTraversalPath = {};
461 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
462 }
463
TEST_F(LayerHierarchyTest,backgroundLayersAreBehindParentLayer)464 TEST_F(LayerHierarchyTest, backgroundLayersAreBehindParentLayer) {
465 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
466
467 updateBackgroundColor(1, 0.5);
468 UPDATE_AND_VERIFY(hierarchyBuilder);
469 auto hierarchy = hierarchyBuilder.getPartialHierarchy(1, /*childrenOnly=*/true);
470 auto bgLayerId = hierarchy.mChildren.front().first->getLayer()->id;
471 std::vector<uint32_t> expectedTraversalPath = {1, bgLayerId, 11, 111, 12,
472 121, 122, 1221, 13, 2};
473 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
474 expectedTraversalPath = {bgLayerId, 1, 11, 111, 12, 121, 122, 1221, 13, 2};
475 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
476 expectedTraversalPath = {};
477 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
478 }
479
480 // cycle tests
TEST_F(LayerHierarchyTest,ParentBecomesTheChild)481 TEST_F(LayerHierarchyTest, ParentBecomesTheChild) {
482 // remove default hierarchy
483 mLifecycleManager = LayerLifecycleManager();
484 createRootLayer(1);
485 createLayer(11, 1);
486 reparentLayer(1, 11);
487 mLifecycleManager.commitChanges();
488 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
489
490 std::vector<uint32_t> expectedTraversalPath = {};
491 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
492 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
493 expectedTraversalPath = {};
494 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
495 }
496
TEST_F(LayerHierarchyTest,RelativeLoops)497 TEST_F(LayerHierarchyTest, RelativeLoops) {
498 // remove default hierarchy
499 mLifecycleManager = LayerLifecycleManager();
500 createRootLayer(1);
501 createRootLayer(2);
502 createLayer(11, 1);
503 reparentRelativeLayer(11, 2);
504 reparentRelativeLayer(2, 11);
505 mLifecycleManager.commitChanges();
506 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
507
508 // fix loop
509 uint32_t invalidRelativeRoot;
510 bool hasRelZLoop = hierarchyBuilder.getHierarchy().hasRelZLoop(invalidRelativeRoot);
511 EXPECT_TRUE(hasRelZLoop);
512 mLifecycleManager.fixRelativeZLoop(invalidRelativeRoot);
513 hierarchyBuilder.update(mLifecycleManager.getLayers(), mLifecycleManager.getDestroyedLayers());
514 EXPECT_EQ(invalidRelativeRoot, 11u);
515 EXPECT_FALSE(hierarchyBuilder.getHierarchy().hasRelZLoop(invalidRelativeRoot));
516
517 std::vector<uint32_t> expectedTraversalPath = {1, 11, 2, 2};
518 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
519 expectedTraversalPath = {1};
520 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
521 expectedTraversalPath = {11, 2};
522 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
523 }
524
TEST_F(LayerHierarchyTest,IndirectRelativeLoops)525 TEST_F(LayerHierarchyTest, IndirectRelativeLoops) {
526 // remove default hierarchy
527 mLifecycleManager = LayerLifecycleManager();
528 createRootLayer(1);
529 createRootLayer(2);
530 createLayer(11, 1);
531 createLayer(111, 11);
532 createLayer(21, 2);
533 createLayer(22, 2);
534 createLayer(221, 22);
535 reparentRelativeLayer(22, 111);
536 reparentRelativeLayer(11, 221);
537 mLifecycleManager.commitChanges();
538 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
539
540 // fix loop
541 uint32_t invalidRelativeRoot;
542 bool hasRelZLoop = hierarchyBuilder.getHierarchy().hasRelZLoop(invalidRelativeRoot);
543 EXPECT_TRUE(hasRelZLoop);
544 mLifecycleManager.fixRelativeZLoop(invalidRelativeRoot);
545 hierarchyBuilder.update(mLifecycleManager.getLayers(), mLifecycleManager.getDestroyedLayers());
546 EXPECT_FALSE(hierarchyBuilder.getHierarchy().hasRelZLoop(invalidRelativeRoot));
547
548 std::vector<uint32_t> expectedTraversalPath = {1, 11, 111, 22, 221, 2, 21, 22, 221};
549 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
550 expectedTraversalPath = {1, 2, 21};
551 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
552 expectedTraversalPath = {11, 111, 22, 221};
553 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
554 }
555
TEST_F(LayerHierarchyTest,ReparentRootLayerToNull)556 TEST_F(LayerHierarchyTest, ReparentRootLayerToNull) {
557 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
558 reparentLayer(1, UNASSIGNED_LAYER_ID);
559 UPDATE_AND_VERIFY(hierarchyBuilder);
560
561 std::vector<uint32_t> expectedTraversalPath = {2};
562 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
563 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
564 expectedTraversalPath = {1, 11, 111, 12, 121, 122, 1221, 13};
565 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
566 }
567
TEST_F(LayerHierarchyTest,AddRemoveLayerInSameTransaction)568 TEST_F(LayerHierarchyTest, AddRemoveLayerInSameTransaction) {
569 // remove default hierarchy
570 mLifecycleManager = LayerLifecycleManager();
571 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
572 createRootLayer(1);
573 destroyLayerHandle(1);
574 UPDATE_AND_VERIFY(hierarchyBuilder);
575
576 std::vector<uint32_t> expectedTraversalPath = {};
577 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
578 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
579 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
580 }
581
582 // traversal path test
TEST_F(LayerHierarchyTest,traversalPathId)583 TEST_F(LayerHierarchyTest, traversalPathId) {
584 setZ(122, -1);
585 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
586 auto checkTraversalPathIdVisitor =
587 [](const LayerHierarchy& hierarchy,
588 const LayerHierarchy::TraversalPath& traversalPath) -> bool {
589 EXPECT_EQ(hierarchy.getLayer()->id, traversalPath.id);
590 return true;
591 };
592 hierarchyBuilder.getHierarchy().traverse(checkTraversalPathIdVisitor);
593 hierarchyBuilder.getHierarchy().traverseInZOrder(checkTraversalPathIdVisitor);
594 }
595
TEST_F(LayerHierarchyTest,zorderRespectsLayerSequenceId)596 TEST_F(LayerHierarchyTest, zorderRespectsLayerSequenceId) {
597 // remove default hierarchy
598 mLifecycleManager = LayerLifecycleManager();
599 createRootLayer(1);
600 createRootLayer(2);
601 createRootLayer(4);
602 createRootLayer(5);
603 createLayer(11, 1);
604 createLayer(51, 5);
605 createLayer(53, 5);
606
607 mLifecycleManager.commitChanges();
608 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
609 UPDATE_AND_VERIFY(hierarchyBuilder);
610 std::vector<uint32_t> expectedTraversalPath = {1, 11, 2, 4, 5, 51, 53};
611 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
612
613 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
614 expectedTraversalPath = {};
615 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
616
617 // A new layer is added with a smaller sequence id. Make sure its sorted correctly. While
618 // sequence ids are always incremented, this scenario can happen when a layer is reparented.
619 createRootLayer(3);
620 createLayer(52, 5);
621
622 UPDATE_AND_VERIFY(hierarchyBuilder);
623 expectedTraversalPath = {1, 11, 2, 3, 4, 5, 51, 52, 53};
624 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
625 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
626 expectedTraversalPath = {};
627 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
628 }
629
TEST_F(LayerHierarchyTest,zorderRespectsLayerZ)630 TEST_F(LayerHierarchyTest, zorderRespectsLayerZ) {
631 // remove default hierarchy
632 mLifecycleManager = LayerLifecycleManager();
633 createRootLayer(1);
634 createLayer(11, 1);
635 createLayer(12, 1);
636 createLayer(13, 1);
637 setZ(11, -1);
638 setZ(12, 2);
639 setZ(13, 1);
640
641 mLifecycleManager.commitChanges();
642 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
643 UPDATE_AND_VERIFY(hierarchyBuilder);
644 std::vector<uint32_t> expectedTraversalPath = {1, 11, 13, 12};
645 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
646
647 expectedTraversalPath = {11, 1, 13, 12};
648 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
649 expectedTraversalPath = {};
650 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
651 }
652
TEST_F(LayerHierarchyTest,zorderRespectsLayerStack)653 TEST_F(LayerHierarchyTest, zorderRespectsLayerStack) {
654 // remove default hierarchy
655 mLifecycleManager = LayerLifecycleManager();
656 createRootLayer(1);
657 createRootLayer(2);
658 createLayer(11, 1);
659 createLayer(21, 2);
660 setLayerStack(1, 20);
661 setLayerStack(2, 10);
662
663 mLifecycleManager.commitChanges();
664 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
665 UPDATE_AND_VERIFY(hierarchyBuilder);
666 std::vector<uint32_t> expectedTraversalPath = {2, 21, 1, 11};
667 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
668
669 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expectedTraversalPath);
670 expectedTraversalPath = {};
671 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expectedTraversalPath);
672 }
673
TEST_F(LayerHierarchyTest,canMirrorDisplay)674 TEST_F(LayerHierarchyTest, canMirrorDisplay) {
675 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
676 setFlags(12, layer_state_t::eLayerSkipScreenshot, layer_state_t::eLayerSkipScreenshot);
677 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
678 setLayerStack(3, 1);
679 UPDATE_AND_VERIFY(hierarchyBuilder);
680
681 std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 3,
682 1, 11, 111, 12, 121, 122, 1221, 13, 2};
683 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expected);
684 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expected);
685 expected = {};
686 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expected);
687 }
688
TEST_F(LayerHierarchyTest,mirrorNonExistingDisplay)689 TEST_F(LayerHierarchyTest, mirrorNonExistingDisplay) {
690 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
691 setFlags(12, layer_state_t::eLayerSkipScreenshot, layer_state_t::eLayerSkipScreenshot);
692 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(5));
693 setLayerStack(3, 1);
694 UPDATE_AND_VERIFY(hierarchyBuilder);
695
696 std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 3};
697 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expected);
698 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expected);
699 expected = {};
700 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expected);
701 }
702
TEST_F(LayerHierarchyTest,newRootLayerIsMirrored)703 TEST_F(LayerHierarchyTest, newRootLayerIsMirrored) {
704 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
705 setFlags(12, layer_state_t::eLayerSkipScreenshot, layer_state_t::eLayerSkipScreenshot);
706 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
707 setLayerStack(3, 1);
708 UPDATE_AND_VERIFY(hierarchyBuilder);
709
710 createRootLayer(4);
711 UPDATE_AND_VERIFY(hierarchyBuilder);
712
713 std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 4, 3,
714 1, 11, 111, 12, 121, 122, 1221, 13, 2, 4};
715 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expected);
716 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expected);
717 expected = {};
718 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expected);
719 }
720
TEST_F(LayerHierarchyTest,removedRootLayerIsNoLongerMirrored)721 TEST_F(LayerHierarchyTest, removedRootLayerIsNoLongerMirrored) {
722 LayerHierarchyBuilder hierarchyBuilder(mLifecycleManager.getLayers());
723 setFlags(12, layer_state_t::eLayerSkipScreenshot, layer_state_t::eLayerSkipScreenshot);
724 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
725 setLayerStack(3, 1);
726 UPDATE_AND_VERIFY(hierarchyBuilder);
727
728 reparentLayer(1, UNASSIGNED_LAYER_ID);
729 destroyLayerHandle(1);
730 UPDATE_AND_VERIFY(hierarchyBuilder);
731
732 std::vector<uint32_t> expected = {2, 3, 2};
733 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()), expected);
734 EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()), expected);
735 expected = {11, 111, 12, 121, 122, 1221, 13};
736 EXPECT_EQ(getTraversalPath(hierarchyBuilder.getOffscreenHierarchy()), expected);
737 }
738
739 } // namespace android::surfaceflinger::frontend
740