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 <common/test/FlagUtils.h>
21 #include <renderengine/mock/FakeExternalTexture.h>
22
23 #include "FrontEnd/LayerHierarchy.h"
24 #include "FrontEnd/LayerLifecycleManager.h"
25 #include "FrontEnd/LayerSnapshotBuilder.h"
26 #include "Layer.h"
27 #include "LayerHierarchyTest.h"
28 #include "ui/GraphicTypes.h"
29
30 #include <com_android_graphics_libgui_flags.h>
31 #include <cmath>
32
33 #define UPDATE_AND_VERIFY(BUILDER, ...) \
34 ({ \
35 SCOPED_TRACE(""); \
36 updateAndVerify((BUILDER), /*displayChanges=*/false, __VA_ARGS__); \
37 })
38
39 #define UPDATE_AND_VERIFY_WITH_DISPLAY_CHANGES(BUILDER, ...) \
40 ({ \
41 SCOPED_TRACE(""); \
42 updateAndVerify((BUILDER), /*displayChanges=*/true, __VA_ARGS__); \
43 })
44
45 namespace android::surfaceflinger::frontend {
46
47 using ftl::Flags;
48 using namespace ftl::flag_operators;
49 using namespace com::android::graphics::surfaceflinger;
50
51 // To run test:
52 /**
53 mp :libsurfaceflinger_unittest && adb sync; adb shell \
54 /data/nativetest/libsurfaceflinger_unittest/libsurfaceflinger_unittest \
55 --gtest_filter="LayerSnapshotTest.*" --gtest_brief=1
56 */
57
58 class LayerSnapshotTest : public LayerSnapshotTestBase {
59 protected:
60 const Layer::FrameRate FRAME_RATE_VOTE1 =
61 Layer::FrameRate(67_Hz, scheduler::FrameRateCompatibility::Default);
62 const Layer::FrameRate FRAME_RATE_VOTE2 =
63 Layer::FrameRate(14_Hz, scheduler::FrameRateCompatibility::Default);
64 const Layer::FrameRate FRAME_RATE_VOTE3 =
65 Layer::FrameRate(99_Hz, scheduler::FrameRateCompatibility::Default);
66 const Layer::FrameRate FRAME_RATE_TREE =
67 Layer::FrameRate(Fps(), scheduler::FrameRateCompatibility::NoVote);
68 const Layer::FrameRate FRAME_RATE_NO_VOTE =
69 Layer::FrameRate(Fps(), scheduler::FrameRateCompatibility::Default);
70
LayerSnapshotTest()71 LayerSnapshotTest() : LayerSnapshotTestBase() {
72 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
73 }
74
update(LayerSnapshotBuilder & actualBuilder,LayerSnapshotBuilder::Args & args)75 void update(LayerSnapshotBuilder& actualBuilder, LayerSnapshotBuilder::Args& args) {
76 if (mLifecycleManager.getGlobalChanges().test(RequestedLayerState::Changes::Hierarchy)) {
77 mHierarchyBuilder.update(mLifecycleManager);
78 }
79 args.root = mHierarchyBuilder.getHierarchy();
80 actualBuilder.update(args);
81 }
82
update(LayerSnapshotBuilder & actualBuilder)83 void update(LayerSnapshotBuilder& actualBuilder) {
84 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
85 .layerLifecycleManager = mLifecycleManager,
86 .includeMetadata = false,
87 .displays = mFrontEndDisplayInfos,
88 .globalShadowSettings = globalShadowSettings,
89 .supportsBlur = true,
90 .supportedLayerGenericMetadata = {},
91 .genericLayerMetadataKeyMap = {}};
92 update(actualBuilder, args);
93 }
94
updateAndVerify(LayerSnapshotBuilder & actualBuilder,bool hasDisplayChanges,const std::vector<uint32_t> expectedVisibleLayerIdsInZOrder)95 void updateAndVerify(LayerSnapshotBuilder& actualBuilder, bool hasDisplayChanges,
96 const std::vector<uint32_t> expectedVisibleLayerIdsInZOrder) {
97 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
98 .layerLifecycleManager = mLifecycleManager,
99 .includeMetadata = false,
100 .displays = mFrontEndDisplayInfos,
101 .displayChanges = hasDisplayChanges,
102 .globalShadowSettings = globalShadowSettings,
103 .supportsBlur = true,
104 .supportedLayerGenericMetadata = {},
105 .genericLayerMetadataKeyMap = {}};
106 update(actualBuilder, args);
107
108 // rebuild layer snapshots from scratch and verify that it matches the updated state.
109 LayerSnapshotBuilder expectedBuilder(args);
110 mLifecycleManager.commitChanges();
111 ASSERT_TRUE(expectedBuilder.getSnapshots().size() > 0);
112 ASSERT_TRUE(actualBuilder.getSnapshots().size() > 0);
113
114 std::vector<uint32_t> actualVisibleLayerIdsInZOrder;
115 actualBuilder.forEachVisibleSnapshot(
116 [&actualVisibleLayerIdsInZOrder](const LayerSnapshot& snapshot) {
117 actualVisibleLayerIdsInZOrder.push_back(snapshot.path.id);
118 });
119 EXPECT_EQ(expectedVisibleLayerIdsInZOrder, actualVisibleLayerIdsInZOrder);
120 }
121
getSnapshot(uint32_t layerId)122 LayerSnapshot* getSnapshot(uint32_t layerId) { return mSnapshotBuilder.getSnapshot(layerId); }
getSnapshot(const LayerHierarchy::TraversalPath path)123 LayerSnapshot* getSnapshot(const LayerHierarchy::TraversalPath path) {
124 return mSnapshotBuilder.getSnapshot(path);
125 }
126 LayerSnapshotBuilder mSnapshotBuilder;
127 static const std::vector<uint32_t> STARTING_ZORDER;
128 };
129 const std::vector<uint32_t> LayerSnapshotTest::STARTING_ZORDER = {1, 11, 111, 12, 121,
130 122, 1221, 13, 2};
131
TEST_F(LayerSnapshotTest,buildSnapshot)132 TEST_F(LayerSnapshotTest, buildSnapshot) {
133 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
134 .layerLifecycleManager = mLifecycleManager,
135 .includeMetadata = false,
136 .displays = mFrontEndDisplayInfos,
137 .globalShadowSettings = globalShadowSettings,
138 .supportedLayerGenericMetadata = {},
139 .genericLayerMetadataKeyMap = {}};
140 LayerSnapshotBuilder builder(args);
141 }
142
TEST_F(LayerSnapshotTest,updateSnapshot)143 TEST_F(LayerSnapshotTest, updateSnapshot) {
144 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
145 .layerLifecycleManager = mLifecycleManager,
146 .includeMetadata = false,
147 .displays = mFrontEndDisplayInfos,
148 .globalShadowSettings = globalShadowSettings,
149 .supportedLayerGenericMetadata = {},
150 .genericLayerMetadataKeyMap = {}
151
152 };
153
154 LayerSnapshotBuilder builder;
155 builder.update(args);
156 }
157
158 // update using parent snapshot data
TEST_F(LayerSnapshotTest,croppedByParent)159 TEST_F(LayerSnapshotTest, croppedByParent) {
160 /// MAKE ALL LAYERS VISIBLE BY DEFAULT
161 DisplayInfo info;
162 info.info.logicalHeight = 100;
163 info.info.logicalWidth = 200;
164 mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
165 FloatRect layerCrop(0, 0, 10, 20);
166 setCrop(11, layerCrop);
167 EXPECT_TRUE(mLifecycleManager.getGlobalChanges().test(RequestedLayerState::Changes::Geometry));
168 UPDATE_AND_VERIFY_WITH_DISPLAY_CHANGES(mSnapshotBuilder, STARTING_ZORDER);
169 EXPECT_EQ(getSnapshot(11)->geomCrop, layerCrop);
170 EXPECT_EQ(getSnapshot(111)->geomLayerBounds, layerCrop);
171 float maxHeight = static_cast<float>(info.info.logicalHeight * 10);
172 float maxWidth = static_cast<float>(info.info.logicalWidth * 10);
173
174 FloatRect maxDisplaySize(-maxWidth, -maxHeight, maxWidth, maxHeight);
175 EXPECT_EQ(getSnapshot(1)->geomLayerBounds, maxDisplaySize);
176 }
177
178 // visibility tests
TEST_F(LayerSnapshotTest,newLayerHiddenByPolicy)179 TEST_F(LayerSnapshotTest, newLayerHiddenByPolicy) {
180 createLayer(112, 11);
181 hideLayer(112);
182 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
183
184 showLayer(112);
185 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 11, 111, 112, 12, 121, 122, 1221, 13, 2});
186 }
187
TEST_F(LayerSnapshotTest,hiddenByParent)188 TEST_F(LayerSnapshotTest, hiddenByParent) {
189 hideLayer(11);
190 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 13, 2});
191 }
192
TEST_F(LayerSnapshotTest,reparentShowsChild)193 TEST_F(LayerSnapshotTest, reparentShowsChild) {
194 hideLayer(11);
195 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 13, 2});
196
197 showLayer(11);
198 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
199 }
200
TEST_F(LayerSnapshotTest,reparentHidesChild)201 TEST_F(LayerSnapshotTest, reparentHidesChild) {
202 hideLayer(11);
203 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 13, 2});
204
205 reparentLayer(121, 11);
206 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 122, 1221, 13, 2});
207 }
208
TEST_F(LayerSnapshotTest,unHidingUpdatesSnapshot)209 TEST_F(LayerSnapshotTest, unHidingUpdatesSnapshot) {
210 hideLayer(11);
211 Rect crop(1, 2, 3, 4);
212 setCrop(111, crop);
213 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 13, 2});
214
215 showLayer(11);
216 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
217 EXPECT_EQ(getSnapshot(111)->geomLayerBounds, crop.toFloatRect());
218 }
219
TEST_F(LayerSnapshotTest,childBehindParentCanBeHiddenByParent)220 TEST_F(LayerSnapshotTest, childBehindParentCanBeHiddenByParent) {
221 setZ(111, -1);
222 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 111, 11, 12, 121, 122, 1221, 13, 2});
223
224 hideLayer(11);
225 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 13, 2});
226 }
227
TEST_F(LayerSnapshotTest,offscreenLayerSnapshotIsInvisible)228 TEST_F(LayerSnapshotTest, offscreenLayerSnapshotIsInvisible) {
229 EXPECT_EQ(getSnapshot(111)->isVisible, true);
230
231 reparentLayer(11, UNASSIGNED_LAYER_ID);
232 destroyLayerHandle(11);
233 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 13, 2});
234
235 EXPECT_EQ(getSnapshot(111)->isVisible, false);
236 EXPECT_TRUE(getSnapshot(111)->changes.test(RequestedLayerState::Changes::Visibility));
237 }
238
239 // relative tests
TEST_F(LayerSnapshotTest,RelativeParentCanHideChild)240 TEST_F(LayerSnapshotTest, RelativeParentCanHideChild) {
241 reparentRelativeLayer(13, 11);
242 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 11, 13, 111, 12, 121, 122, 1221, 2});
243
244 hideLayer(11);
245 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 2});
246 }
247
TEST_F(LayerSnapshotTest,ReparentingToHiddenRelativeParentHidesChild)248 TEST_F(LayerSnapshotTest, ReparentingToHiddenRelativeParentHidesChild) {
249 hideLayer(11);
250 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 13, 2});
251 reparentRelativeLayer(13, 11);
252 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 12, 121, 122, 1221, 2});
253 }
254
TEST_F(LayerSnapshotTest,AlphaInheritedByChildren)255 TEST_F(LayerSnapshotTest, AlphaInheritedByChildren) {
256 setAlpha(1, 0.5);
257 setAlpha(122, 0.5);
258 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
259 EXPECT_EQ(getSnapshot(1)->alpha, 0.5f);
260 EXPECT_EQ(getSnapshot(12)->alpha, 0.5f);
261 EXPECT_EQ(getSnapshot(1221)->alpha, 0.25f);
262 }
263
TEST_F(LayerSnapshotTest,AlphaInheritedByChildWhenParentIsHiddenByInvalidTransform)264 TEST_F(LayerSnapshotTest, AlphaInheritedByChildWhenParentIsHiddenByInvalidTransform) {
265 setMatrix(1, 0, 0, 0, 0);
266 update(mSnapshotBuilder);
267 mLifecycleManager.commitChanges();
268
269 setAlpha(1, 0.5);
270 update(mSnapshotBuilder);
271 mLifecycleManager.commitChanges();
272
273 setMatrix(1, 1, 0, 0, 1);
274 update(mSnapshotBuilder);
275 mLifecycleManager.commitChanges();
276
277 EXPECT_EQ(getSnapshot(1)->alpha, 0.5f);
278 EXPECT_EQ(getSnapshot(11)->alpha, 0.5f);
279 }
280
TEST_F(LayerSnapshotTest,AlphaInheritedByChildWhenParentIsHidden)281 TEST_F(LayerSnapshotTest, AlphaInheritedByChildWhenParentIsHidden) {
282 hideLayer(1);
283 update(mSnapshotBuilder);
284 mLifecycleManager.commitChanges();
285
286 setAlpha(1, 0.5);
287 update(mSnapshotBuilder);
288 mLifecycleManager.commitChanges();
289
290 showLayer(1);
291 update(mSnapshotBuilder);
292 mLifecycleManager.commitChanges();
293
294 EXPECT_EQ(getSnapshot(1)->alpha, 0.5f);
295 EXPECT_EQ(getSnapshot(11)->alpha, 0.5f);
296 }
297
298 // Change states
TEST_F(LayerSnapshotTest,UpdateClearsPreviousChangeStates)299 TEST_F(LayerSnapshotTest, UpdateClearsPreviousChangeStates) {
300 setCrop(1, Rect(1, 2, 3, 4));
301 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
302 EXPECT_TRUE(getSnapshot(1)->changes.test(RequestedLayerState::Changes::Geometry));
303 EXPECT_TRUE(getSnapshot(11)->changes.test(RequestedLayerState::Changes::Geometry));
304 setCrop(2, Rect(1, 2, 3, 4));
305 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
306 EXPECT_TRUE(getSnapshot(2)->changes.test(RequestedLayerState::Changes::Geometry));
307 EXPECT_FALSE(getSnapshot(1)->changes.test(RequestedLayerState::Changes::Geometry));
308 EXPECT_FALSE(getSnapshot(11)->changes.test(RequestedLayerState::Changes::Geometry));
309 }
310
TEST_F(LayerSnapshotTest,FastPathClearsPreviousChangeStates)311 TEST_F(LayerSnapshotTest, FastPathClearsPreviousChangeStates) {
312 setColor(11, {1._hf, 0._hf, 0._hf});
313 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
314 EXPECT_EQ(getSnapshot(11)->changes,
315 RequestedLayerState::Changes::Content);
316 EXPECT_EQ(getSnapshot(11)->clientChanges, layer_state_t::eColorChanged);
317 EXPECT_EQ(getSnapshot(1)->changes.get(), 0u);
318 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
319 EXPECT_EQ(getSnapshot(11)->changes.get(), 0u);
320 }
321
TEST_F(LayerSnapshotTest,FastPathSetsChangeFlagToContent)322 TEST_F(LayerSnapshotTest, FastPathSetsChangeFlagToContent) {
323 setColor(1, {1._hf, 0._hf, 0._hf});
324 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
325 EXPECT_EQ(getSnapshot(1)->changes,
326 RequestedLayerState::Changes::Content);
327 EXPECT_EQ(getSnapshot(1)->clientChanges, layer_state_t::eColorChanged);
328 }
329
TEST_F(LayerSnapshotTest,ChildrenInheritGameMode)330 TEST_F(LayerSnapshotTest, ChildrenInheritGameMode) {
331 setGameMode(1, gui::GameMode::Performance);
332 EXPECT_EQ(mLifecycleManager.getGlobalChanges(),
333 RequestedLayerState::Changes::GameMode | RequestedLayerState::Changes::Metadata);
334 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
335 EXPECT_EQ(getSnapshot(1)->clientChanges, layer_state_t::eMetadataChanged);
336 EXPECT_EQ(getSnapshot(1)->gameMode, gui::GameMode::Performance);
337 EXPECT_EQ(getSnapshot(11)->gameMode, gui::GameMode::Performance);
338 }
339
TEST_F(LayerSnapshotTest,ChildrenCanOverrideGameMode)340 TEST_F(LayerSnapshotTest, ChildrenCanOverrideGameMode) {
341 setGameMode(1, gui::GameMode::Performance);
342 setGameMode(11, gui::GameMode::Battery);
343 EXPECT_EQ(mLifecycleManager.getGlobalChanges(),
344 RequestedLayerState::Changes::GameMode | RequestedLayerState::Changes::Metadata);
345 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
346 EXPECT_EQ(getSnapshot(1)->clientChanges, layer_state_t::eMetadataChanged);
347 EXPECT_EQ(getSnapshot(1)->gameMode, gui::GameMode::Performance);
348 EXPECT_EQ(getSnapshot(11)->gameMode, gui::GameMode::Battery);
349 }
350
TEST_F(LayerSnapshotTest,ReparentingUpdatesGameMode)351 TEST_F(LayerSnapshotTest, ReparentingUpdatesGameMode) {
352 setGameMode(1, gui::GameMode::Performance);
353 EXPECT_EQ(mLifecycleManager.getGlobalChanges(),
354 RequestedLayerState::Changes::GameMode | RequestedLayerState::Changes::Metadata);
355 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
356 EXPECT_EQ(getSnapshot(1)->clientChanges, layer_state_t::eMetadataChanged);
357 EXPECT_EQ(getSnapshot(1)->gameMode, gui::GameMode::Performance);
358 EXPECT_EQ(getSnapshot(2)->gameMode, gui::GameMode::Unsupported);
359
360 reparentLayer(2, 1);
361 setZ(2, 2);
362 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
363 EXPECT_EQ(getSnapshot(2)->gameMode, gui::GameMode::Performance);
364 }
365
TEST_F(LayerSnapshotTest,UpdateMetadata)366 TEST_F(LayerSnapshotTest, UpdateMetadata) {
367 std::vector<QueuedTransactionState> transactions;
368 transactions.emplace_back();
369 transactions.back().states.push_back({});
370 transactions.back().states.front().state.what = layer_state_t::eMetadataChanged;
371 // This test focuses on metadata used by ARC++ to ensure LayerMetadata is updated correctly,
372 // and not using stale data.
373 transactions.back().states.front().state.metadata = LayerMetadata();
374 transactions.back().states.front().state.metadata.setInt32(METADATA_OWNER_UID, 123);
375 transactions.back().states.front().state.metadata.setInt32(METADATA_WINDOW_TYPE, 234);
376 transactions.back().states.front().state.metadata.setInt32(METADATA_TASK_ID, 345);
377 transactions.back().states.front().state.metadata.setInt32(METADATA_MOUSE_CURSOR, 456);
378 transactions.back().states.front().state.metadata.setInt32(METADATA_ACCESSIBILITY_ID, 567);
379 transactions.back().states.front().state.metadata.setInt32(METADATA_OWNER_PID, 678);
380 transactions.back().states.front().state.metadata.setInt32(METADATA_CALLING_UID, 789);
381
382 transactions.back().states.front().layerId = 1;
383 transactions.back().states.front().state.layerId = static_cast<int32_t>(1);
384
385 mLifecycleManager.applyTransactions(transactions);
386 EXPECT_EQ(mLifecycleManager.getGlobalChanges(), RequestedLayerState::Changes::Metadata);
387
388 // Setting includeMetadata=true to ensure metadata update is applied to LayerSnapshot
389 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
390 .layerLifecycleManager = mLifecycleManager,
391 .includeMetadata = true,
392 .displays = mFrontEndDisplayInfos,
393 .globalShadowSettings = globalShadowSettings,
394 .supportsBlur = true,
395 .supportedLayerGenericMetadata = {},
396 .genericLayerMetadataKeyMap = {}};
397 update(mSnapshotBuilder, args);
398
399 EXPECT_EQ(getSnapshot(1)->clientChanges, layer_state_t::eMetadataChanged);
400 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_OWNER_UID, -1), 123);
401 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_WINDOW_TYPE, -1), 234);
402 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_TASK_ID, -1), 345);
403 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_MOUSE_CURSOR, -1), 456);
404 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_ACCESSIBILITY_ID, -1), 567);
405 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_OWNER_PID, -1), 678);
406 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_CALLING_UID, -1), 789);
407 }
408
TEST_F(LayerSnapshotTest,UpdateMetadataOfHiddenLayers)409 TEST_F(LayerSnapshotTest, UpdateMetadataOfHiddenLayers) {
410 hideLayer(1);
411
412 std::vector<QueuedTransactionState> transactions;
413 transactions.emplace_back();
414 transactions.back().states.push_back({});
415 transactions.back().states.front().state.what = layer_state_t::eMetadataChanged;
416 // This test focuses on metadata used by ARC++ to ensure LayerMetadata is updated correctly,
417 // and not using stale data.
418 transactions.back().states.front().state.metadata = LayerMetadata();
419 transactions.back().states.front().state.metadata.setInt32(METADATA_OWNER_UID, 123);
420 transactions.back().states.front().state.metadata.setInt32(METADATA_WINDOW_TYPE, 234);
421 transactions.back().states.front().state.metadata.setInt32(METADATA_TASK_ID, 345);
422 transactions.back().states.front().state.metadata.setInt32(METADATA_MOUSE_CURSOR, 456);
423 transactions.back().states.front().state.metadata.setInt32(METADATA_ACCESSIBILITY_ID, 567);
424 transactions.back().states.front().state.metadata.setInt32(METADATA_OWNER_PID, 678);
425 transactions.back().states.front().state.metadata.setInt32(METADATA_CALLING_UID, 789);
426
427 transactions.back().states.front().layerId = 1;
428 transactions.back().states.front().state.layerId = static_cast<int32_t>(1);
429
430 mLifecycleManager.applyTransactions(transactions);
431 EXPECT_EQ(mLifecycleManager.getGlobalChanges(),
432 RequestedLayerState::Changes::Metadata | RequestedLayerState::Changes::Visibility |
433 RequestedLayerState::Changes::VisibleRegion |
434 RequestedLayerState::Changes::AffectsChildren);
435
436 // Setting includeMetadata=true to ensure metadata update is applied to LayerSnapshot
437 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
438 .layerLifecycleManager = mLifecycleManager,
439 .includeMetadata = true,
440 .displays = mFrontEndDisplayInfos,
441 .globalShadowSettings = globalShadowSettings,
442 .supportsBlur = true,
443 .supportedLayerGenericMetadata = {},
444 .genericLayerMetadataKeyMap = {}};
445 update(mSnapshotBuilder, args);
446
447 EXPECT_EQ(static_cast<int64_t>(getSnapshot(1)->clientChanges),
448 layer_state_t::eMetadataChanged | layer_state_t::eFlagsChanged);
449 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_OWNER_UID, -1), 123);
450 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_WINDOW_TYPE, -1), 234);
451 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_TASK_ID, -1), 345);
452 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_MOUSE_CURSOR, -1), 456);
453 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_ACCESSIBILITY_ID, -1), 567);
454 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_OWNER_PID, -1), 678);
455 EXPECT_EQ(getSnapshot(1)->layerMetadata.getInt32(METADATA_CALLING_UID, -1), 789);
456 }
457
TEST_F(LayerSnapshotTest,NoLayerVoteForParentWithChildVotes)458 TEST_F(LayerSnapshotTest, NoLayerVoteForParentWithChildVotes) {
459 // ROOT
460 // ├── 1
461 // │ ├── 11 (frame rate set)
462 // │ │ └── 111
463 // │ ├── 12
464 // │ │ ├── 121
465 // │ │ └── 122
466 // │ │ └── 1221
467 // │ └── 13
468 // └── 2
469
470 setFrameRate(11, 90.0, ANATIVEWINDOW_FRAME_RATE_EXACT, ANATIVEWINDOW_CHANGE_FRAME_RATE_ALWAYS);
471 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
472
473 EXPECT_EQ(getSnapshot(11)->frameRate.vote.rate.getIntValue(), 90);
474 EXPECT_EQ(getSnapshot(11)->frameRate.vote.type, scheduler::FrameRateCompatibility::Exact);
475 EXPECT_EQ(getSnapshot(111)->frameRate.vote.rate.getIntValue(), 90);
476 EXPECT_EQ(getSnapshot(111)->frameRate.vote.type, scheduler::FrameRateCompatibility::Exact);
477 EXPECT_EQ(getSnapshot(1)->frameRate.vote.rate.getIntValue(), 0);
478 EXPECT_EQ(getSnapshot(1)->frameRate.vote.type, scheduler::FrameRateCompatibility::NoVote);
479 }
480
TEST_F(LayerSnapshotTest,NoLayerVoteForParentWithChildVotesDoesNotAffectSiblings)481 TEST_F(LayerSnapshotTest, NoLayerVoteForParentWithChildVotesDoesNotAffectSiblings) {
482 // ROOT
483 // ├── 1 (verify layer has no vote)
484 // │ ├── 11 (frame rate set)
485 // │ │ └── 111
486 // │ ├── 12 (frame rate set)
487 // │ │ ├── 121
488 // │ │ └── 122
489 // │ │ └── 1221
490 // │ └── 13 (verify layer has default vote)
491 // └── 2
492
493 setFrameRate(11, 90.0, ANATIVEWINDOW_FRAME_RATE_EXACT, ANATIVEWINDOW_CHANGE_FRAME_RATE_ALWAYS);
494 setFrameRate(12, 45.0, ANATIVEWINDOW_FRAME_RATE_EXACT, ANATIVEWINDOW_CHANGE_FRAME_RATE_ALWAYS);
495
496 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
497
498 EXPECT_EQ(getSnapshot(11)->frameRate.vote.rate.getIntValue(), 90);
499 EXPECT_EQ(getSnapshot(11)->frameRate.vote.type, scheduler::FrameRateCompatibility::Exact);
500 EXPECT_EQ(getSnapshot(111)->frameRate.vote.rate.getIntValue(), 90);
501 EXPECT_EQ(getSnapshot(111)->frameRate.vote.type, scheduler::FrameRateCompatibility::Exact);
502 EXPECT_EQ(getSnapshot(12)->frameRate.vote.rate.getIntValue(), 45);
503 EXPECT_EQ(getSnapshot(12)->frameRate.vote.type, scheduler::FrameRateCompatibility::Exact);
504 EXPECT_EQ(getSnapshot(121)->frameRate.vote.rate.getIntValue(), 45);
505 EXPECT_EQ(getSnapshot(121)->frameRate.vote.type, scheduler::FrameRateCompatibility::Exact);
506 EXPECT_EQ(getSnapshot(1221)->frameRate.vote.rate.getIntValue(), 45);
507 EXPECT_EQ(getSnapshot(1221)->frameRate.vote.type, scheduler::FrameRateCompatibility::Exact);
508
509 EXPECT_EQ(getSnapshot(1)->frameRate.vote.rate.getIntValue(), 0);
510 EXPECT_EQ(getSnapshot(1)->frameRate.vote.type, scheduler::FrameRateCompatibility::NoVote);
511 EXPECT_EQ(getSnapshot(13)->frameRate.vote.rate.getIntValue(), 0);
512 EXPECT_EQ(getSnapshot(13)->frameRate.vote.type, scheduler::FrameRateCompatibility::Default);
513 EXPECT_EQ(getSnapshot(2)->frameRate.vote.rate.getIntValue(), 0);
514 EXPECT_EQ(getSnapshot(2)->frameRate.vote.type, scheduler::FrameRateCompatibility::Default);
515 }
516
TEST_F(LayerSnapshotTest,CanCropTouchableRegion)517 TEST_F(LayerSnapshotTest, CanCropTouchableRegion) {
518 // ROOT
519 // ├── 1
520 // │ ├── 11
521 // │ │ └── 111 (touchregion set to touch but cropped by layer 13)
522 // │ ├── 12
523 // │ │ ├── 121
524 // │ │ └── 122
525 // │ │ └── 1221
526 // │ └── 13 (crop set to touchCrop)
527 // └── 2
528
529 Rect touchCrop{300, 300, 400, 500};
530 setCrop(13, touchCrop);
531 Region touch{Rect{0, 0, 1000, 1000}};
532 setTouchableRegionCrop(111, touch, /*touchCropId=*/13, /*replaceTouchableRegionWithCrop=*/true);
533 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
534 EXPECT_EQ(getSnapshot({.id = 111})->inputInfo.touchableRegion.bounds(), touchCrop);
535
536 Rect modifiedTouchCrop{100, 300, 400, 700};
537 setCrop(13, modifiedTouchCrop);
538 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
539 EXPECT_EQ(getSnapshot({.id = 111})->inputInfo.touchableRegion.bounds(), modifiedTouchCrop);
540 }
541
TEST_F(LayerSnapshotTest,CanCropTouchableRegionWithDisplayTransform)542 TEST_F(LayerSnapshotTest, CanCropTouchableRegionWithDisplayTransform) {
543 DisplayInfo displayInfo;
544 displayInfo.transform = ui::Transform(ui::Transform::RotationFlags::ROT_90, 1000, 1000);
545 mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), displayInfo);
546
547 Rect touchCrop{300, 300, 400, 500};
548 createRootLayer(3);
549 setCrop(3, touchCrop);
550 setLayerStack(3, 1);
551 Region touch{Rect{0, 0, 1000, 1000}};
552 setTouchableRegionCrop(3, touch, /*touchCropId=*/3, /*replaceTouchableRegionWithCrop=*/false);
553
554 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 11, 111, 12, 121, 122, 1221, 13, 2, 3});
555 Rect rotatedCrop = {500, 300, 700, 400};
556 EXPECT_EQ(getSnapshot({.id = 3})->inputInfo.touchableRegion.bounds(), rotatedCrop);
557 }
558
TEST_F(LayerSnapshotTest,blurUpdatesWhenAlphaChanges)559 TEST_F(LayerSnapshotTest, blurUpdatesWhenAlphaChanges) {
560 int blurRadius = 42;
561 setBackgroundBlurRadius(1221, static_cast<uint32_t>(blurRadius));
562
563 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
564 EXPECT_EQ(getSnapshot({.id = 1221})->backgroundBlurRadius, blurRadius);
565
566 blurRadius = 21;
567 setBackgroundBlurRadius(1221, static_cast<uint32_t>(blurRadius));
568 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
569 EXPECT_EQ(getSnapshot({.id = 1221})->backgroundBlurRadius, blurRadius);
570
571 static constexpr float alpha = 0.5;
572 setAlpha(12, alpha);
573 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
574 EXPECT_EQ(getSnapshot({.id = 1221})->backgroundBlurRadius,
575 static_cast<int>(static_cast<float>(blurRadius) * alpha));
576 }
577
578 // Display Mirroring Tests
579 // tree with 3 levels of children
580 // ROOT (DISPLAY 0)
581 // ├── 1
582 // │ ├── 11
583 // │ │ └── 111
584 // │ ├── 12 (has skip screenshot flag)
585 // │ │ ├── 121
586 // │ │ └── 122
587 // │ │ └── 1221
588 // │ └── 13
589 // └── 2
590 // ROOT (DISPLAY 1)
591 // └── 3 (mirrors display 0)
TEST_F(LayerSnapshotTest,displayMirrorRespectsLayerSkipScreenshotFlag)592 TEST_F(LayerSnapshotTest, displayMirrorRespectsLayerSkipScreenshotFlag) {
593 setFlags(12, layer_state_t::eLayerSkipScreenshot, layer_state_t::eLayerSkipScreenshot);
594 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
595 setLayerStack(3, 1);
596
597 std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 3, 1, 11, 111, 13, 2};
598 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
599 }
600
601 // ROOT (DISPLAY 0)
602 // ├── 1
603 // │ ├── 11
604 // │ │ └── 111
605 // │ └── 13
606 // └── 2
607 // ROOT (DISPLAY 3)
608 // └── 3 (mirrors display 0)
TEST_F(LayerSnapshotTest,mirrorLayerGetsCorrectLayerStack)609 TEST_F(LayerSnapshotTest, mirrorLayerGetsCorrectLayerStack) {
610 reparentLayer(12, UNASSIGNED_LAYER_ID);
611 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
612 setLayerStack(3, 3);
613 createDisplayMirrorLayer(4, ui::LayerStack::fromValue(0));
614 setLayerStack(4, 4);
615
616 std::vector<uint32_t> expected = {1, 11, 111, 13, 2, 3, 1, 11, 111,
617 13, 2, 4, 1, 11, 111, 13, 2};
618 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
619 EXPECT_EQ(getSnapshot({.id = 111, .mirrorRootIds = 3u})->outputFilter.layerStack.id, 3u);
620 EXPECT_EQ(getSnapshot({.id = 111, .mirrorRootIds = 4u})->outputFilter.layerStack.id, 4u);
621 }
622
623 // ROOT (DISPLAY 0)
624 // ├── 1 (crop 50x50)
625 // │ ├── 11
626 // │ │ └── 111
627 // │ └── 13
628 // └── 2
629 // ROOT (DISPLAY 3)
630 // └── 3 (mirrors display 0) (crop 100x100)
TEST_F(LayerSnapshotTest,mirrorLayerTouchIsCroppedByMirrorRoot)631 TEST_F(LayerSnapshotTest, mirrorLayerTouchIsCroppedByMirrorRoot) {
632 reparentLayer(12, UNASSIGNED_LAYER_ID);
633 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
634 setLayerStack(3, 3);
635 setCrop(1, Rect{50, 50});
636 setCrop(3, Rect{100, 100});
637 setCrop(111, Rect{200, 200});
638 Region touch{Rect{0, 0, 1000, 1000}};
639 setTouchableRegion(111, touch);
640 std::vector<uint32_t> expected = {1, 11, 111, 13, 2, 3, 1, 11, 111, 13, 2};
641 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
642 EXPECT_TRUE(getSnapshot({.id = 111})->inputInfo.touchableRegion.hasSameRects(touch));
643 Region touchCroppedByMirrorRoot{Rect{0, 0, 50, 50}};
644 EXPECT_TRUE(getSnapshot({.id = 111, .mirrorRootIds = 3u})
645 ->inputInfo.touchableRegion.hasSameRects(touchCroppedByMirrorRoot));
646 }
647
TEST_F(LayerSnapshotTest,canRemoveDisplayMirror)648 TEST_F(LayerSnapshotTest, canRemoveDisplayMirror) {
649 setFlags(12, layer_state_t::eLayerSkipScreenshot, layer_state_t::eLayerSkipScreenshot);
650 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
651 setLayerStack(3, 1);
652 std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 3, 1, 11, 111, 13, 2};
653 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
654 destroyLayerHandle(3);
655 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
656 }
657
TEST_F(LayerSnapshotTest,cleanUpUnreachableSnapshotsAfterMirroring)658 TEST_F(LayerSnapshotTest, cleanUpUnreachableSnapshotsAfterMirroring) {
659 size_t startingNumSnapshots = mSnapshotBuilder.getSnapshots().size();
660 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
661 setLayerStack(3, 1);
662 std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 3,
663 1, 11, 111, 12, 121, 122, 1221, 13, 2};
664 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
665 destroyLayerHandle(3);
666 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
667
668 EXPECT_EQ(startingNumSnapshots, mSnapshotBuilder.getSnapshots().size());
669 }
670
TEST_F(LayerSnapshotTest,canMirrorDisplayWithMirrors)671 TEST_F(LayerSnapshotTest, canMirrorDisplayWithMirrors) {
672 reparentLayer(12, UNASSIGNED_LAYER_ID);
673 mirrorLayer(/*layer*/ 14, /*parent*/ 1, /*layerToMirror*/ 11);
674 std::vector<uint32_t> expected = {1, 11, 111, 13, 14, 11, 111, 2};
675 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
676
677 createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0));
678 setLayerStack(3, 3);
679 expected = {1, 11, 111, 13, 14, 11, 111, 2, 3, 1, 11, 111, 13, 14, 11, 111, 2};
680 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
681 EXPECT_EQ(getSnapshot({.id = 11, .mirrorRootIds = 14u})->outputFilter.layerStack.id, 0u);
682 EXPECT_EQ(getSnapshot({.id = 11, .mirrorRootIds = 3u})->outputFilter.layerStack.id, 3u);
683 EXPECT_EQ(getSnapshot({.id = 11, .mirrorRootIds = 3u, 14u})->outputFilter.layerStack.id, 3u);
684 }
685
686 // Rel z doesn't create duplicate snapshots but this is for completeness
TEST_F(LayerSnapshotTest,cleanUpUnreachableSnapshotsAfterRelZ)687 TEST_F(LayerSnapshotTest, cleanUpUnreachableSnapshotsAfterRelZ) {
688 size_t startingNumSnapshots = mSnapshotBuilder.getSnapshots().size();
689 reparentRelativeLayer(13, 11);
690 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 11, 13, 111, 12, 121, 122, 1221, 2});
691 setZ(13, 0);
692 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
693
694 EXPECT_EQ(startingNumSnapshots, mSnapshotBuilder.getSnapshots().size());
695 }
696
TEST_F(LayerSnapshotTest,cleanUpUnreachableSnapshotsAfterLayerDestruction)697 TEST_F(LayerSnapshotTest, cleanUpUnreachableSnapshotsAfterLayerDestruction) {
698 size_t startingNumSnapshots = mSnapshotBuilder.getSnapshots().size();
699 destroyLayerHandle(2);
700 destroyLayerHandle(122);
701
702 std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 122, 1221, 13};
703 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
704
705 EXPECT_LE(startingNumSnapshots - 2, mSnapshotBuilder.getSnapshots().size());
706 }
707
TEST_F(LayerSnapshotTest,snashotContainsMetadataFromLayerCreationArgs)708 TEST_F(LayerSnapshotTest, snashotContainsMetadataFromLayerCreationArgs) {
709 LayerCreationArgs args(std::make_optional<uint32_t>(200));
710 args.name = "testlayer";
711 args.addToRoot = true;
712 args.metadata.setInt32(42, 24);
713
714 std::vector<std::unique_ptr<RequestedLayerState>> layers;
715 layers.emplace_back(std::make_unique<RequestedLayerState>(args));
716 EXPECT_TRUE(layers.back()->metadata.has(42));
717 EXPECT_EQ(layers.back()->metadata.getInt32(42, 0), 24);
718 mLifecycleManager.addLayers(std::move(layers));
719
720 std::vector<uint32_t> expected = STARTING_ZORDER;
721 expected.push_back(200);
722 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
723
724 EXPECT_TRUE(mSnapshotBuilder.getSnapshot(200)->layerMetadata.has(42));
725 EXPECT_EQ(mSnapshotBuilder.getSnapshot(200)->layerMetadata.getInt32(42, 0), 24);
726 }
727
TEST_F(LayerSnapshotTest,frameRateSelectionPriorityPassedToChildLayers)728 TEST_F(LayerSnapshotTest, frameRateSelectionPriorityPassedToChildLayers) {
729 setFrameRateSelectionPriority(11, 1);
730
731 setFrameRateSelectionPriority(12, 2);
732
733 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
734 EXPECT_EQ(getSnapshot({.id = 1})->frameRateSelectionPriority, Layer::PRIORITY_UNSET);
735 EXPECT_EQ(getSnapshot({.id = 11})->frameRateSelectionPriority, 1);
736 EXPECT_EQ(getSnapshot({.id = 12})->frameRateSelectionPriority, 2);
737 EXPECT_EQ(getSnapshot({.id = 122})->frameRateSelectionPriority, 2);
738 EXPECT_EQ(getSnapshot({.id = 1221})->frameRateSelectionPriority, 2);
739
740 // reparent and verify the child gets the new parent's framerate selection priority
741 reparentLayer(122, 11);
742
743 std::vector<uint32_t> expected = {1, 11, 111, 122, 1221, 12, 121, 13, 2};
744 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
745 EXPECT_EQ(getSnapshot({.id = 1})->frameRateSelectionPriority, Layer::PRIORITY_UNSET);
746 EXPECT_EQ(getSnapshot({.id = 11})->frameRateSelectionPriority, 1);
747 EXPECT_EQ(getSnapshot({.id = 12})->frameRateSelectionPriority, 2);
748 EXPECT_EQ(getSnapshot({.id = 122})->frameRateSelectionPriority, 1);
749 EXPECT_EQ(getSnapshot({.id = 1221})->frameRateSelectionPriority, 1);
750 }
751
TEST_F(LayerSnapshotTest,framerate)752 TEST_F(LayerSnapshotTest, framerate) {
753 setFrameRate(11, 244.f, 0, 0);
754
755 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
756 // verify parent is gets no vote
757 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
758 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
759 scheduler::FrameRateCompatibility::NoVote);
760 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
761
762 // verify layer and children get the requested votes
763 EXPECT_TRUE(getSnapshot({.id = 11})->frameRate.vote.rate.isValid());
764 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.rate.getValue(), 244.f);
765 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.type,
766 scheduler::FrameRateCompatibility::Default);
767 EXPECT_TRUE(getSnapshot({.id = 11})->changes.test(RequestedLayerState::Changes::FrameRate));
768
769 EXPECT_TRUE(getSnapshot({.id = 111})->frameRate.vote.rate.isValid());
770 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.rate.getValue(), 244.f);
771 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.type,
772 scheduler::FrameRateCompatibility::Default);
773 EXPECT_TRUE(getSnapshot({.id = 111})->changes.test(RequestedLayerState::Changes::FrameRate));
774
775 // reparent and verify the child gets the new parent's framerate
776 reparentLayer(122, 11);
777
778 std::vector<uint32_t> expected = {1, 11, 111, 122, 1221, 12, 121, 13, 2};
779 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
780 // verify parent is gets no vote
781 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
782 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
783 scheduler::FrameRateCompatibility::NoVote);
784
785 // verify layer and children get the requested votes
786 EXPECT_TRUE(getSnapshot({.id = 11})->frameRate.vote.rate.isValid());
787 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.rate.getValue(), 244.f);
788 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.type,
789 scheduler::FrameRateCompatibility::Default);
790
791 EXPECT_TRUE(getSnapshot({.id = 111})->frameRate.vote.rate.isValid());
792 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.rate.getValue(), 244.f);
793 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.type,
794 scheduler::FrameRateCompatibility::Default);
795
796 EXPECT_TRUE(getSnapshot({.id = 122})->frameRate.vote.rate.isValid());
797 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.rate.getValue(), 244.f);
798 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.type,
799 scheduler::FrameRateCompatibility::Default);
800 EXPECT_TRUE(getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::FrameRate));
801
802 // reparent and verify the new parent gets no vote
803 reparentLayer(11, 2);
804 expected = {1, 12, 121, 13, 2, 11, 111, 122, 1221};
805 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
806
807 // verify old parent has invalid framerate (default)
808 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
809 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
810 scheduler::FrameRateCompatibility::Default);
811 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
812
813 // verify new parent get no vote
814 EXPECT_FALSE(getSnapshot({.id = 2})->frameRate.vote.rate.isValid());
815 EXPECT_EQ(getSnapshot({.id = 2})->frameRate.vote.type,
816 scheduler::FrameRateCompatibility::NoVote);
817 EXPECT_TRUE(getSnapshot({.id = 2})->changes.test(RequestedLayerState::Changes::FrameRate));
818
819 // verify layer and children get the requested votes (unchanged)
820 EXPECT_TRUE(getSnapshot({.id = 11})->frameRate.vote.rate.isValid());
821 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.rate.getValue(), 244.f);
822 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.type,
823 scheduler::FrameRateCompatibility::Default);
824
825 EXPECT_TRUE(getSnapshot({.id = 111})->frameRate.vote.rate.isValid());
826 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.rate.getValue(), 244.f);
827 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.type,
828 scheduler::FrameRateCompatibility::Default);
829
830 EXPECT_TRUE(getSnapshot({.id = 122})->frameRate.vote.rate.isValid());
831 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.rate.getValue(), 244.f);
832 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.type,
833 scheduler::FrameRateCompatibility::Default);
834 }
835
TEST_F(LayerSnapshotTest,frameRateSetAndGet)836 TEST_F(LayerSnapshotTest, frameRateSetAndGet) {
837 setFrameRate(1, FRAME_RATE_VOTE1.vote.rate.getValue(), 0, 0);
838 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
839 // verify parent is gets no vote
840 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE1);
841 }
842
TEST_F(LayerSnapshotTest,frameRateSetAndGetParent)843 TEST_F(LayerSnapshotTest, frameRateSetAndGetParent) {
844 setFrameRate(111, FRAME_RATE_VOTE1.vote.rate.getValue(), 0, 0);
845 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
846 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_TREE);
847 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_TREE);
848 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE1);
849
850 setFrameRate(111, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
851 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
852 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_NO_VOTE);
853 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_NO_VOTE);
854 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_NO_VOTE);
855 }
856
TEST_F(LayerSnapshotTest,frameRateSetAndGetParentAllVote)857 TEST_F(LayerSnapshotTest, frameRateSetAndGetParentAllVote) {
858 setFrameRate(1, FRAME_RATE_VOTE3.vote.rate.getValue(), 0, 0);
859 setFrameRate(11, FRAME_RATE_VOTE2.vote.rate.getValue(), 0, 0);
860 setFrameRate(111, FRAME_RATE_VOTE1.vote.rate.getValue(), 0, 0);
861 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
862
863 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE3);
864 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE2);
865 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE1);
866
867 setFrameRate(111, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
868 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
869 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE3);
870 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE2);
871 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE2);
872
873 setFrameRate(11, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
874 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
875 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE3);
876 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE3);
877 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE3);
878
879 setFrameRate(1, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
880 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
881 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_NO_VOTE);
882 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_NO_VOTE);
883 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_NO_VOTE);
884 }
885
TEST_F(LayerSnapshotTest,frameRateSetAndGetChild)886 TEST_F(LayerSnapshotTest, frameRateSetAndGetChild) {
887 setFrameRate(1, FRAME_RATE_VOTE1.vote.rate.getValue(), 0, 0);
888 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
889 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE1);
890 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE1);
891 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE1);
892
893 setFrameRate(1, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
894 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
895 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_NO_VOTE);
896 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_NO_VOTE);
897 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_NO_VOTE);
898 }
899
TEST_F(LayerSnapshotTest,frameRateSetAndGetChildAllVote)900 TEST_F(LayerSnapshotTest, frameRateSetAndGetChildAllVote) {
901 setFrameRate(1, FRAME_RATE_VOTE3.vote.rate.getValue(), 0, 0);
902 setFrameRate(11, FRAME_RATE_VOTE2.vote.rate.getValue(), 0, 0);
903 setFrameRate(111, FRAME_RATE_VOTE1.vote.rate.getValue(), 0, 0);
904 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
905 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE3);
906 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE2);
907 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE1);
908
909 setFrameRate(1, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
910 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
911 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_TREE);
912 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE2);
913 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE1);
914
915 setFrameRate(11, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
916 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
917 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_TREE);
918 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_TREE);
919 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE1);
920
921 setFrameRate(111, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
922 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
923 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_NO_VOTE);
924 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_NO_VOTE);
925 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_NO_VOTE);
926 }
927
TEST_F(LayerSnapshotTest,frameRateSetAndGetChildAddAfterVote)928 TEST_F(LayerSnapshotTest, frameRateSetAndGetChildAddAfterVote) {
929 setFrameRate(1, FRAME_RATE_VOTE1.vote.rate.getValue(), 0, 0);
930 reparentLayer(111, 2);
931 std::vector<uint32_t> traversalOrder = {1, 11, 12, 121, 122, 1221, 13, 2, 111};
932 UPDATE_AND_VERIFY(mSnapshotBuilder, traversalOrder);
933 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE1);
934 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE1);
935 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_NO_VOTE);
936
937 reparentLayer(111, 11);
938 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
939 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE1);
940 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE1);
941 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE1);
942
943 setFrameRate(1, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
944 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
945 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_NO_VOTE);
946 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_NO_VOTE);
947 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_NO_VOTE);
948 }
949
TEST_F(LayerSnapshotTest,frameRateSetAndGetChildRemoveAfterVote)950 TEST_F(LayerSnapshotTest, frameRateSetAndGetChildRemoveAfterVote) {
951 setFrameRate(1, FRAME_RATE_VOTE1.vote.rate.getValue(), 0, 0);
952 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
953 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE1);
954 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE1);
955 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_VOTE1);
956
957 reparentLayer(111, 2);
958 std::vector<uint32_t> traversalOrder = {1, 11, 12, 121, 122, 1221, 13, 2, 111};
959 UPDATE_AND_VERIFY(mSnapshotBuilder, traversalOrder);
960 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_VOTE1);
961 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE1);
962 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_NO_VOTE);
963
964 setFrameRate(1, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
965 UPDATE_AND_VERIFY(mSnapshotBuilder, traversalOrder);
966 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_NO_VOTE);
967 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_NO_VOTE);
968 EXPECT_EQ(getSnapshot({.id = 111})->frameRate, FRAME_RATE_NO_VOTE);
969 }
970
TEST_F(LayerSnapshotTest,frameRateAddChildForParentWithTreeVote)971 TEST_F(LayerSnapshotTest, frameRateAddChildForParentWithTreeVote) {
972 setFrameRate(11, FRAME_RATE_VOTE1.vote.rate.getValue(), 0, 0);
973 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
974 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_TREE);
975 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_VOTE1);
976 EXPECT_EQ(getSnapshot({.id = 12})->frameRate, FRAME_RATE_NO_VOTE);
977
978 setFrameRate(11, FRAME_RATE_NO_VOTE.vote.rate.getValue(), 0, 0);
979 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
980 EXPECT_EQ(getSnapshot({.id = 1})->frameRate, FRAME_RATE_NO_VOTE);
981 EXPECT_EQ(getSnapshot({.id = 11})->frameRate, FRAME_RATE_NO_VOTE);
982 EXPECT_EQ(getSnapshot({.id = 12})->frameRate, FRAME_RATE_NO_VOTE);
983 }
984
TEST_F(LayerSnapshotTest,translateDataspace)985 TEST_F(LayerSnapshotTest, translateDataspace) {
986 setDataspace(1, ui::Dataspace::UNKNOWN);
987 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
988 EXPECT_EQ(getSnapshot({.id = 1})->dataspace, ui::Dataspace::V0_SRGB);
989 }
990
991 // This test is similar to "frameRate" test case but checks that the setFrameRateCategory API
992 // interaction also works correctly with the setFrameRate API within SF frontend.
TEST_F(LayerSnapshotTest,frameRateWithCategory)993 TEST_F(LayerSnapshotTest, frameRateWithCategory) {
994 SET_FLAG_FOR_TEST(flags::frame_rate_category_mrr, true);
995
996 // ROOT
997 // ├── 1
998 // │ ├── 11 (frame rate set to 244.f)
999 // │ │ └── 111
1000 // │ ├── 12
1001 // │ │ ├── 121
1002 // │ │ └── 122 (frame rate category set to Normal)
1003 // │ │ └── 1221
1004 // │ └── 13
1005 // └── 2
1006 setFrameRate(11, 244.f, 0, 0);
1007 setFrameRateCategory(122, ANATIVEWINDOW_FRAME_RATE_CATEGORY_NORMAL);
1008
1009 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1010 // verify parent 1 gets no vote
1011 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
1012 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
1013 scheduler::FrameRateCompatibility::NoVote);
1014 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
1015
1016 // verify layer 11 and children 111 get the requested votes
1017 EXPECT_TRUE(getSnapshot({.id = 11})->frameRate.vote.rate.isValid());
1018 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.rate.getValue(), 244.f);
1019 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.type,
1020 scheduler::FrameRateCompatibility::Default);
1021 EXPECT_TRUE(getSnapshot({.id = 11})->changes.test(RequestedLayerState::Changes::FrameRate));
1022
1023 EXPECT_TRUE(getSnapshot({.id = 111})->frameRate.vote.rate.isValid());
1024 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.rate.getValue(), 244.f);
1025 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.type,
1026 scheduler::FrameRateCompatibility::Default);
1027 EXPECT_TRUE(getSnapshot({.id = 111})->changes.test(RequestedLayerState::Changes::FrameRate));
1028
1029 // verify parent 12 gets no vote
1030 EXPECT_FALSE(getSnapshot({.id = 12})->frameRate.vote.rate.isValid());
1031 EXPECT_EQ(getSnapshot({.id = 12})->frameRate.vote.type,
1032 scheduler::FrameRateCompatibility::NoVote);
1033 EXPECT_TRUE(getSnapshot({.id = 12})->changes.test(RequestedLayerState::Changes::FrameRate));
1034
1035 // verify layer 122 and children 1221 get the requested votes
1036 EXPECT_FALSE(getSnapshot({.id = 122})->frameRate.vote.rate.isValid());
1037 EXPECT_TRUE(getSnapshot({.id = 122})->frameRate.isValid());
1038 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.type,
1039 scheduler::FrameRateCompatibility::Default);
1040 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.category, FrameRateCategory::Normal);
1041 EXPECT_TRUE(getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::FrameRate));
1042 EXPECT_TRUE(
1043 getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::AffectsChildren));
1044
1045 EXPECT_FALSE(getSnapshot({.id = 1221})->frameRate.vote.rate.isValid());
1046 EXPECT_TRUE(getSnapshot({.id = 1221})->frameRate.isValid());
1047 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.vote.type,
1048 scheduler::FrameRateCompatibility::Default);
1049 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.category, FrameRateCategory::Normal);
1050 EXPECT_TRUE(getSnapshot({.id = 1221})->changes.test(RequestedLayerState::Changes::FrameRate));
1051 EXPECT_TRUE(
1052 getSnapshot({.id = 1221})->changes.test(RequestedLayerState::Changes::AffectsChildren));
1053
1054 // reparent and verify the child does NOT get the new parent's framerate because it already has
1055 // the frame rate category specified.
1056 // ROOT
1057 // ├─1
1058 // │ ├─11 (frame rate set to 244.f)
1059 // │ │ ├─111
1060 // │ │ └─122 (frame rate category set to Normal)
1061 // │ │ └─1221
1062 // │ ├─12
1063 // │ │ └─121
1064 // │ └─13
1065 // └─2
1066 reparentLayer(122, 11);
1067
1068 std::vector<uint32_t> expected = {1, 11, 111, 122, 1221, 12, 121, 13, 2};
1069 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
1070 // verify parent is gets no vote
1071 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
1072 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
1073 scheduler::FrameRateCompatibility::NoVote);
1074
1075 // verify layer 11 and children 111 get the requested votes
1076 EXPECT_TRUE(getSnapshot({.id = 11})->frameRate.vote.rate.isValid());
1077 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.rate.getValue(), 244.f);
1078 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.type,
1079 scheduler::FrameRateCompatibility::Default);
1080
1081 EXPECT_TRUE(getSnapshot({.id = 111})->frameRate.vote.rate.isValid());
1082 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.rate.getValue(), 244.f);
1083 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.type,
1084 scheduler::FrameRateCompatibility::Default);
1085
1086 // verify layer 122 and children 1221 get the requested category vote (unchanged from
1087 // reparenting)
1088 EXPECT_FALSE(getSnapshot({.id = 122})->frameRate.vote.rate.isValid());
1089 EXPECT_TRUE(getSnapshot({.id = 122})->frameRate.isValid());
1090 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.type,
1091 scheduler::FrameRateCompatibility::Default);
1092 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.category, FrameRateCategory::Normal);
1093 EXPECT_TRUE(getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::FrameRate));
1094
1095 EXPECT_FALSE(getSnapshot({.id = 1221})->frameRate.vote.rate.isValid());
1096 EXPECT_TRUE(getSnapshot({.id = 1221})->frameRate.isValid());
1097 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.vote.type,
1098 scheduler::FrameRateCompatibility::Default);
1099 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.category, FrameRateCategory::Normal);
1100 EXPECT_TRUE(getSnapshot({.id = 1221})->changes.test(RequestedLayerState::Changes::FrameRate));
1101 }
1102
TEST_F(LayerSnapshotTest,frameRateSelectionStrategy)1103 TEST_F(LayerSnapshotTest, frameRateSelectionStrategy) {
1104 // ROOT
1105 // ├── 1
1106 // │ ├── 11
1107 // │ │ └── 111
1108 // │ ├── 12 (frame rate set to 244.f with strategy OverrideChildren)
1109 // │ │ ├── 121
1110 // │ │ └── 122 (frame rate set to 123.f but should be overridden by layer 12)
1111 // │ │ └── 1221
1112 // │ └── 13
1113 // └── 2
1114 setFrameRate(12, 244.f, 0, 0);
1115 setFrameRate(122, 123.f, 0, 0);
1116 setFrameRateSelectionStrategy(12, 1 /* OverrideChildren */);
1117
1118 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1119 // verify parent 1 gets no vote
1120 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
1121 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
1122 scheduler::FrameRateCompatibility::NoVote);
1123 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
1124
1125 // verify layer 12 and all descendants (121, 122, 1221) get the requested vote
1126 EXPECT_EQ(getSnapshot({.id = 12})->frameRate.vote.rate.getValue(), 244.f);
1127 EXPECT_EQ(getSnapshot({.id = 12})->frameRateSelectionStrategy,
1128 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1129 EXPECT_TRUE(getSnapshot({.id = 12})->changes.test(RequestedLayerState::Changes::FrameRate));
1130
1131 EXPECT_EQ(getSnapshot({.id = 121})->frameRate.vote.rate.getValue(), 244.f);
1132 EXPECT_EQ(getSnapshot({.id = 121})->frameRateSelectionStrategy,
1133 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1134 EXPECT_TRUE(getSnapshot({.id = 121})->changes.test(RequestedLayerState::Changes::FrameRate));
1135
1136 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.rate.getValue(), 244.f);
1137 EXPECT_EQ(getSnapshot({.id = 122})->frameRateSelectionStrategy,
1138 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1139 EXPECT_TRUE(getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::FrameRate));
1140
1141 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.vote.rate.getValue(), 244.f);
1142 EXPECT_EQ(getSnapshot({.id = 1221})->frameRateSelectionStrategy,
1143 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1144 EXPECT_TRUE(getSnapshot({.id = 1221})->changes.test(RequestedLayerState::Changes::FrameRate));
1145
1146 // ROOT
1147 // ├── 1
1148 // │ ├── 11
1149 // │ │ └── 111
1150 // │ ├── 12 (frame rate set to default with strategy default)
1151 // │ │ ├── 121
1152 // │ │ └── 122 (frame rate set to 123.f)
1153 // │ │ └── 1221
1154 // │ └── 13
1155 // └── 2
1156 setFrameRate(12, -1.f, 0, 0);
1157 setFrameRateSelectionStrategy(12, 0 /* Default */);
1158 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1159 // verify parent 1 gets no vote
1160 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
1161 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
1162 scheduler::FrameRateCompatibility::NoVote);
1163 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
1164
1165 // verify layer 12 and all descendants (121, 122, 1221) get the requested vote
1166 EXPECT_FALSE(getSnapshot({.id = 12})->frameRate.vote.rate.isValid());
1167 EXPECT_EQ(getSnapshot({.id = 12})->frameRate.vote.type,
1168 scheduler::FrameRateCompatibility::NoVote);
1169 EXPECT_EQ(getSnapshot({.id = 12})->frameRateSelectionStrategy,
1170 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1171 EXPECT_TRUE(getSnapshot({.id = 12})->changes.test(RequestedLayerState::Changes::FrameRate));
1172
1173 EXPECT_FALSE(getSnapshot({.id = 121})->frameRate.vote.rate.isValid());
1174 EXPECT_EQ(getSnapshot({.id = 121})->frameRateSelectionStrategy,
1175 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1176 EXPECT_EQ(getSnapshot({.id = 121})->frameRate.vote.type,
1177 scheduler::FrameRateCompatibility::Default);
1178 EXPECT_TRUE(getSnapshot({.id = 121})->changes.test(RequestedLayerState::Changes::FrameRate));
1179
1180 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.rate.getValue(), 123.f);
1181 EXPECT_EQ(getSnapshot({.id = 122})->frameRateSelectionStrategy,
1182 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1183 EXPECT_TRUE(getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::FrameRate));
1184
1185 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.vote.rate.getValue(), 123.f);
1186 EXPECT_EQ(getSnapshot({.id = 1221})->frameRateSelectionStrategy,
1187 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1188 EXPECT_TRUE(getSnapshot({.id = 1221})->changes.test(RequestedLayerState::Changes::FrameRate));
1189 }
1190
TEST_F(LayerSnapshotTest,frameRateSelectionStrategyWithCategory)1191 TEST_F(LayerSnapshotTest, frameRateSelectionStrategyWithCategory) {
1192 SET_FLAG_FOR_TEST(flags::frame_rate_category_mrr, true);
1193
1194 // ROOT
1195 // ├── 1
1196 // │ ├── 11
1197 // │ │ └── 111
1198 // │ ├── 12 (frame rate category set to high with strategy OverrideChildren)
1199 // │ │ ├── 121
1200 // │ │ └── 122 (frame rate set to 123.f but should be overridden by layer 12)
1201 // │ │ └── 1221
1202 // │ └── 13
1203 // └── 2
1204 setFrameRateCategory(12, ANATIVEWINDOW_FRAME_RATE_CATEGORY_HIGH);
1205 setFrameRate(122, 123.f, 0, 0);
1206 setFrameRateSelectionStrategy(12, 1 /* OverrideChildren */);
1207
1208 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1209 // verify parent 1 gets no vote
1210 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
1211 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
1212 scheduler::FrameRateCompatibility::NoVote);
1213 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
1214
1215 // verify layer 12 and all descendants (121, 122, 1221) get the requested vote
1216 EXPECT_EQ(getSnapshot({.id = 12})->frameRate.category, FrameRateCategory::High);
1217 EXPECT_EQ(getSnapshot({.id = 12})->frameRateSelectionStrategy,
1218 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1219 EXPECT_TRUE(getSnapshot({.id = 12})->changes.test(RequestedLayerState::Changes::FrameRate));
1220
1221 EXPECT_EQ(getSnapshot({.id = 121})->frameRate.category, FrameRateCategory::High);
1222 EXPECT_EQ(getSnapshot({.id = 121})->frameRateSelectionStrategy,
1223 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1224 EXPECT_TRUE(getSnapshot({.id = 121})->changes.test(RequestedLayerState::Changes::FrameRate));
1225
1226 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.category, FrameRateCategory::High);
1227 EXPECT_EQ(getSnapshot({.id = 122})->frameRateSelectionStrategy,
1228 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1229 EXPECT_TRUE(getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::FrameRate));
1230
1231 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.category, FrameRateCategory::High);
1232 EXPECT_EQ(getSnapshot({.id = 1221})->frameRateSelectionStrategy,
1233 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1234 EXPECT_TRUE(getSnapshot({.id = 1221})->changes.test(RequestedLayerState::Changes::FrameRate));
1235
1236 // ROOT
1237 // ├── 1
1238 // │ ├── 11
1239 // │ │ └── 111
1240 // │ ├── 12 (frame rate category to default with strategy default)
1241 // │ │ ├── 121
1242 // │ │ └── 122 (frame rate set to 123.f)
1243 // │ │ └── 1221
1244 // │ └── 13
1245 // └── 2
1246 setFrameRateCategory(12, ANATIVEWINDOW_FRAME_RATE_CATEGORY_DEFAULT);
1247 setFrameRateSelectionStrategy(12, 0 /* Default */);
1248 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1249 // verify parent 1 gets no vote
1250 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
1251 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
1252 scheduler::FrameRateCompatibility::NoVote);
1253 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.category, FrameRateCategory::Default);
1254 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
1255
1256 // verify layer 12 and all descendants (121, 122, 1221) get the requested vote
1257 EXPECT_FALSE(getSnapshot({.id = 12})->frameRate.vote.rate.isValid());
1258 EXPECT_EQ(getSnapshot({.id = 12})->frameRate.vote.type,
1259 scheduler::FrameRateCompatibility::NoVote);
1260 EXPECT_EQ(getSnapshot({.id = 12})->frameRate.category, FrameRateCategory::Default);
1261 EXPECT_EQ(getSnapshot({.id = 12})->frameRateSelectionStrategy,
1262 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1263 EXPECT_TRUE(getSnapshot({.id = 12})->changes.test(RequestedLayerState::Changes::FrameRate));
1264
1265 EXPECT_FALSE(getSnapshot({.id = 12})->frameRate.vote.rate.isValid());
1266 EXPECT_EQ(getSnapshot({.id = 121})->frameRateSelectionStrategy,
1267 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1268 EXPECT_EQ(getSnapshot({.id = 121})->frameRate.category, FrameRateCategory::Default);
1269 EXPECT_EQ(getSnapshot({.id = 121})->frameRate.vote.type,
1270 scheduler::FrameRateCompatibility::Default);
1271 EXPECT_TRUE(getSnapshot({.id = 121})->changes.test(RequestedLayerState::Changes::FrameRate));
1272
1273 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.rate.getValue(), 123.f);
1274 EXPECT_EQ(getSnapshot({.id = 122})->frameRateSelectionStrategy,
1275 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1276 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.category, FrameRateCategory::Default);
1277 EXPECT_TRUE(getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::FrameRate));
1278
1279 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.vote.rate.getValue(), 123.f);
1280 EXPECT_EQ(getSnapshot({.id = 1221})->frameRateSelectionStrategy,
1281 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1282 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.category, FrameRateCategory::Default);
1283 EXPECT_TRUE(getSnapshot({.id = 1221})->changes.test(RequestedLayerState::Changes::FrameRate));
1284 }
1285
TEST_F(LayerSnapshotTest,frameRateSelectionStrategyWithOverrideChildrenAndSelf)1286 TEST_F(LayerSnapshotTest, frameRateSelectionStrategyWithOverrideChildrenAndSelf) {
1287 // ROOT
1288 // ├── 1
1289 // │ ├── 11 (frame rate set to 11.f with strategy Self)
1290 // │ │ └── 111 (frame rate is not inherited)
1291 // │ ├── 12 (frame rate set to 244.f)
1292 // │ │ ├── 121
1293 // │ │ └── 122 (strategy OverrideChildren and inherits frame rate 244.f)
1294 // │ │ └── 1221 (frame rate set to 123.f but should be overridden by layer 122)
1295 // │ └── 13
1296 // └── 2
1297 setFrameRate(11, 11.f, 0, 0);
1298 setFrameRateSelectionStrategy(11, 2 /* Self */);
1299 setFrameRate(12, 244.f, 0, 0);
1300 setFrameRateSelectionStrategy(122, 1 /* OverrideChildren */);
1301 setFrameRate(1221, 123.f, 0, 0);
1302
1303 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1304 // verify parent 1 gets no vote
1305 EXPECT_FALSE(getSnapshot({.id = 1})->frameRate.vote.rate.isValid());
1306 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
1307 scheduler::FrameRateCompatibility::NoVote);
1308 EXPECT_EQ(getSnapshot({.id = 1})->frameRateSelectionStrategy,
1309 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1310 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
1311
1312 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.rate.getValue(), 11.f);
1313 EXPECT_EQ(getSnapshot({.id = 11})->frameRateSelectionStrategy,
1314 scheduler::LayerInfo::FrameRateSelectionStrategy::Self);
1315 EXPECT_TRUE(getSnapshot({.id = 11})->changes.test(RequestedLayerState::Changes::FrameRate));
1316
1317 // verify layer 11 does does not propagate its framerate to 111.
1318 EXPECT_FALSE(getSnapshot({.id = 111})->frameRate.vote.rate.isValid());
1319 EXPECT_EQ(getSnapshot({.id = 111})->frameRateSelectionStrategy,
1320 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1321 EXPECT_TRUE(getSnapshot({.id = 111})->changes.test(RequestedLayerState::Changes::FrameRate));
1322
1323 // verify layer 12 and all descendants (121, 122, 1221) get the requested vote
1324 EXPECT_EQ(getSnapshot({.id = 12})->frameRate.vote.rate.getValue(), 244.f);
1325 EXPECT_EQ(getSnapshot({.id = 12})->frameRateSelectionStrategy,
1326 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1327 EXPECT_TRUE(getSnapshot({.id = 12})->changes.test(RequestedLayerState::Changes::FrameRate));
1328
1329 EXPECT_EQ(getSnapshot({.id = 121})->frameRate.vote.rate.getValue(), 244.f);
1330 EXPECT_EQ(getSnapshot({.id = 121})->frameRateSelectionStrategy,
1331 scheduler::LayerInfo::FrameRateSelectionStrategy::Propagate);
1332 EXPECT_TRUE(getSnapshot({.id = 121})->changes.test(RequestedLayerState::Changes::FrameRate));
1333
1334 EXPECT_EQ(getSnapshot({.id = 122})->frameRate.vote.rate.getValue(), 244.f);
1335 EXPECT_EQ(getSnapshot({.id = 122})->frameRateSelectionStrategy,
1336 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1337 EXPECT_TRUE(getSnapshot({.id = 122})->changes.test(RequestedLayerState::Changes::FrameRate));
1338
1339 EXPECT_EQ(getSnapshot({.id = 1221})->frameRate.vote.rate.getValue(), 244.f);
1340 EXPECT_EQ(getSnapshot({.id = 1221})->frameRateSelectionStrategy,
1341 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1342 EXPECT_TRUE(getSnapshot({.id = 1221})->changes.test(RequestedLayerState::Changes::FrameRate));
1343
1344 // ROOT
1345 // ├── 1 (frame rate set to 1.f with strategy OverrideChildren)
1346 // │ ├── 11 (frame rate set to 11.f with strategy Self, but overridden by 1)
1347 // │ │ └── 111 (frame rate inherited from 11 due to override from 1)
1348 // ⋮ ⋮
1349 setFrameRate(1, 1.f, 0, 0);
1350 setFrameRateSelectionStrategy(1, 1 /* OverrideChildren */);
1351 setFrameRate(11, 11.f, 0, 0);
1352 setFrameRateSelectionStrategy(11, 2 /* Self */);
1353 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1354
1355 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.rate.getValue(), 1.f);
1356 EXPECT_EQ(getSnapshot({.id = 1})->frameRate.vote.type,
1357 scheduler::FrameRateCompatibility::Default);
1358 EXPECT_EQ(getSnapshot({.id = 1})->frameRateSelectionStrategy,
1359 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1360 EXPECT_TRUE(getSnapshot({.id = 1})->changes.test(RequestedLayerState::Changes::FrameRate));
1361
1362 EXPECT_EQ(getSnapshot({.id = 11})->frameRate.vote.rate.getValue(), 1.f);
1363 EXPECT_EQ(getSnapshot({.id = 11})->frameRateSelectionStrategy,
1364 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1365 EXPECT_TRUE(getSnapshot({.id = 11})->changes.test(RequestedLayerState::Changes::FrameRate));
1366
1367 // verify layer 11 does does not propagate its framerate to 111.
1368 EXPECT_EQ(getSnapshot({.id = 111})->frameRate.vote.rate.getValue(), 1.f);
1369 EXPECT_EQ(getSnapshot({.id = 111})->frameRateSelectionStrategy,
1370 scheduler::LayerInfo::FrameRateSelectionStrategy::OverrideChildren);
1371 EXPECT_TRUE(getSnapshot({.id = 111})->changes.test(RequestedLayerState::Changes::FrameRate));
1372 }
1373
TEST_F(LayerSnapshotTest,skipRoundCornersWhenProtected)1374 TEST_F(LayerSnapshotTest, skipRoundCornersWhenProtected) {
1375 setRoundedCorners(1, 42.f);
1376 setRoundedCorners(2, 42.f);
1377 setCrop(1, Rect{1000, 1000});
1378 setCrop(2, Rect{1000, 1000});
1379
1380 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1381 EXPECT_TRUE(getSnapshot({.id = 1})->roundedCorner.hasRoundedCorners());
1382 EXPECT_EQ(getSnapshot({.id = 1})->roundedCorner.radius.x, 42.f);
1383 EXPECT_TRUE(getSnapshot({.id = 2})->roundedCorner.hasRoundedCorners());
1384
1385 // add a buffer with the protected bit, check rounded corners are not set when
1386 // skipRoundCornersWhenProtected == true
1387 setBuffer(1,
1388 std::make_shared<
1389 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
1390 1ULL /* bufferId */,
1391 HAL_PIXEL_FORMAT_RGBA_8888,
1392 GRALLOC_USAGE_PROTECTED /*usage*/));
1393
1394 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
1395 .layerLifecycleManager = mLifecycleManager,
1396 .includeMetadata = false,
1397 .displays = mFrontEndDisplayInfos,
1398 .displayChanges = false,
1399 .globalShadowSettings = globalShadowSettings,
1400 .supportsBlur = true,
1401 .supportedLayerGenericMetadata = {},
1402 .genericLayerMetadataKeyMap = {},
1403 .skipRoundCornersWhenProtected = true};
1404 update(mSnapshotBuilder, args);
1405 EXPECT_FALSE(getSnapshot({.id = 1})->roundedCorner.hasRoundedCorners());
1406 // layer 2 doesn't have a buffer and should be unaffected
1407 EXPECT_TRUE(getSnapshot({.id = 2})->roundedCorner.hasRoundedCorners());
1408
1409 // remove protected bit, check rounded corners are set
1410 setBuffer(1,
1411 std::make_shared<renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
1412 2ULL /* bufferId */,
1413 HAL_PIXEL_FORMAT_RGBA_8888,
1414 0 /*usage*/));
1415 update(mSnapshotBuilder, args);
1416 EXPECT_TRUE(getSnapshot({.id = 1})->roundedCorner.hasRoundedCorners());
1417 EXPECT_EQ(getSnapshot({.id = 1})->roundedCorner.radius.x, 42.f);
1418 }
1419
TEST_F(LayerSnapshotTest,setRefreshRateIndicatorCompositionType)1420 TEST_F(LayerSnapshotTest, setRefreshRateIndicatorCompositionType) {
1421 setFlags(1, layer_state_t::eLayerIsRefreshRateIndicator,
1422 layer_state_t::eLayerIsRefreshRateIndicator);
1423 setBuffer(1,
1424 std::make_shared<renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
1425 42ULL /* bufferId */,
1426 HAL_PIXEL_FORMAT_RGBA_8888,
1427 0 /*usage*/));
1428 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1429 EXPECT_EQ(getSnapshot({.id = 1})->compositionType,
1430 aidl::android::hardware::graphics::composer3::Composition::REFRESH_RATE_INDICATOR);
1431 }
1432
TEST_F(LayerSnapshotTest,setBufferCrop)1433 TEST_F(LayerSnapshotTest, setBufferCrop) {
1434 // validate no buffer but has crop
1435 Rect crop = Rect(0, 0, 50, 50);
1436 setBufferCrop(1, crop);
1437 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1438 EXPECT_EQ(getSnapshot(1)->geomContentCrop, crop);
1439
1440 setBuffer(1,
1441 std::make_shared<renderengine::mock::FakeExternalTexture>(100U /*width*/,
1442 100U /*height*/,
1443 42ULL /* bufferId */,
1444 HAL_PIXEL_FORMAT_RGBA_8888,
1445 0 /*usage*/));
1446 // validate a buffer crop within the buffer bounds
1447 setBufferCrop(1, crop);
1448 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1449 EXPECT_EQ(getSnapshot(1)->geomContentCrop, crop);
1450
1451 // validate a buffer crop outside the buffer bounds
1452 crop = Rect(0, 0, 150, 150);
1453 setBufferCrop(1, crop);
1454 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1455 EXPECT_EQ(getSnapshot(1)->geomContentCrop, Rect(0, 0, 100, 100));
1456
1457 // validate no buffer crop
1458 setBufferCrop(1, Rect());
1459 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1460 EXPECT_EQ(getSnapshot(1)->geomContentCrop, Rect(0, 0, 100, 100));
1461 }
1462
TEST_F(LayerSnapshotTest,setCornerRadius)1463 TEST_F(LayerSnapshotTest, setCornerRadius) {
1464 static constexpr float RADIUS = 123.f;
1465 setRoundedCorners(1, RADIUS);
1466 setCrop(1, Rect{1000, 1000});
1467 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1468 EXPECT_EQ(getSnapshot({.id = 1})->roundedCorner.radius.x, RADIUS);
1469 }
1470
TEST_F(LayerSnapshotTest,ignoreCornerRadius)1471 TEST_F(LayerSnapshotTest, ignoreCornerRadius) {
1472 static constexpr float RADIUS = 123.f;
1473 setClientDrawnCornerRadius(1, RADIUS);
1474 setRoundedCorners(1, RADIUS);
1475 setCrop(1, Rect{1000, 1000});
1476 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1477 EXPECT_TRUE(getSnapshot({.id = 1})->roundedCorner.hasClientDrawnRadius());
1478 EXPECT_EQ(getSnapshot({.id = 1})->roundedCorner.radius.x, 0.f);
1479 }
1480
TEST_F(LayerSnapshotTest,childInheritsParentScaledSettings)1481 TEST_F(LayerSnapshotTest, childInheritsParentScaledSettings) {
1482 // ROOT
1483 // ├── 1 (crop rect set to contain child layer)
1484 // │ ├── 11
1485 static constexpr float RADIUS = 123.f;
1486
1487 setRoundedCorners(1, RADIUS);
1488 FloatRect parentCropRect(1, 1, 999, 999);
1489 setCrop(1, parentCropRect);
1490 // Rotate surface by 90
1491 setMatrix(11, 0.f, -1.f, 1.f, 0.f);
1492
1493 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1494
1495 ui::Transform t = getSnapshot({.id = 11})->localTransform.inverse();
1496
1497 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1498 EXPECT_EQ(getSnapshot({.id = 11})->roundedCorner.cropRect, t.transform(parentCropRect));
1499 EXPECT_EQ(getSnapshot({.id = 11})->roundedCorner.radius.x, RADIUS * t.getScaleX());
1500 EXPECT_EQ(getSnapshot({.id = 11})->roundedCorner.radius.y, RADIUS * t.getScaleY());
1501 EXPECT_EQ(getSnapshot({.id = 11})->roundedCorner.requestedRadius.x, RADIUS * t.getScaleX());
1502 EXPECT_EQ(getSnapshot({.id = 11})->roundedCorner.requestedRadius.y, RADIUS * t.getScaleY());
1503 }
1504
TEST_F(LayerSnapshotTest,childInheritsParentClientDrawnCornerRadius)1505 TEST_F(LayerSnapshotTest, childInheritsParentClientDrawnCornerRadius) {
1506 // ROOT
1507 // ├── 1 (crop rect set to contain child layers )
1508 // │ ├── 11
1509 // │ │ └── 111
1510
1511 static constexpr float RADIUS = 123.f;
1512
1513 setClientDrawnCornerRadius(1, RADIUS);
1514 setRoundedCorners(1, RADIUS);
1515 setCrop(1, Rect(1, 1, 999, 999));
1516
1517 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1518 EXPECT_TRUE(getSnapshot({.id = 1})->roundedCorner.hasClientDrawnRadius());
1519 EXPECT_TRUE(getSnapshot({.id = 11})->roundedCorner.hasRoundedCorners());
1520 EXPECT_EQ(getSnapshot({.id = 11})->roundedCorner.radius.x, RADIUS);
1521 }
1522
TEST_F(LayerSnapshotTest,childIgnoreCornerRadiusOverridesParent)1523 TEST_F(LayerSnapshotTest, childIgnoreCornerRadiusOverridesParent) {
1524 // ROOT
1525 // ├── 1 (crop rect set to contain child layers )
1526 // │ ├── 11
1527 // │ │ └── 111
1528
1529 static constexpr float RADIUS = 123.f;
1530
1531 setRoundedCorners(1, RADIUS);
1532 setCrop(1, Rect(1, 1, 999, 999));
1533
1534 setClientDrawnCornerRadius(11, RADIUS);
1535
1536 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1537 EXPECT_EQ(getSnapshot({.id = 1})->roundedCorner.radius.x, RADIUS);
1538 EXPECT_EQ(getSnapshot({.id = 11})->roundedCorner.radius.x, 0.f);
1539 EXPECT_EQ(getSnapshot({.id = 111})->roundedCorner.radius.x, RADIUS);
1540 }
1541
TEST_F(LayerSnapshotTest,setShadowRadius)1542 TEST_F(LayerSnapshotTest, setShadowRadius) {
1543 static constexpr float SHADOW_RADIUS = 123.f;
1544 setShadowRadius(1, SHADOW_RADIUS);
1545 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1546 EXPECT_EQ(getSnapshot(1)->shadowSettings.length, SHADOW_RADIUS);
1547 }
1548
TEST_F(LayerSnapshotTest,setBorderSettings)1549 TEST_F(LayerSnapshotTest, setBorderSettings) {
1550 gui::BorderSettings settings;
1551 settings.strokeWidth = 5;
1552 setBorderSettings(1, settings);
1553 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1554 EXPECT_EQ(getSnapshot(1)->borderSettings.strokeWidth, settings.strokeWidth);
1555 }
1556
TEST_F(LayerSnapshotTest,setTrustedOverlayForNonVisibleInput)1557 TEST_F(LayerSnapshotTest, setTrustedOverlayForNonVisibleInput) {
1558 hideLayer(1);
1559 setTrustedOverlay(1, gui::TrustedOverlay::ENABLED);
1560 Region touch{Rect{0, 0, 1000, 1000}};
1561 setTouchableRegion(1, touch);
1562
1563 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1564 EXPECT_TRUE(getSnapshot(1)->inputInfo.inputConfig.test(
1565 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1566 }
1567
TEST_F(LayerSnapshotTest,alphaChangesPropagateToInput)1568 TEST_F(LayerSnapshotTest, alphaChangesPropagateToInput) {
1569 Region touch{Rect{0, 0, 1000, 1000}};
1570 setTouchableRegion(1, touch);
1571 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1572
1573 setAlpha(1, 0.5f);
1574 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1575 EXPECT_EQ(getSnapshot(1)->inputInfo.alpha, 0.5f);
1576 }
1577
TEST_F(LayerSnapshotTest,isFrontBuffered)1578 TEST_F(LayerSnapshotTest, isFrontBuffered) {
1579 setBuffer(1,
1580 std::make_shared<renderengine::mock::FakeExternalTexture>(
1581 1U /*width*/, 1U /*height*/, 1ULL /* bufferId */, HAL_PIXEL_FORMAT_RGBA_8888,
1582 GRALLOC_USAGE_HW_TEXTURE | AHARDWAREBUFFER_USAGE_FRONT_BUFFER /*usage*/));
1583
1584 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1585 EXPECT_TRUE(getSnapshot(1)->isFrontBuffered());
1586
1587 setBuffer(1,
1588 std::make_shared<
1589 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
1590 1ULL /* bufferId */,
1591 HAL_PIXEL_FORMAT_RGBA_8888,
1592 GRALLOC_USAGE_HW_TEXTURE /*usage*/));
1593
1594 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1595 EXPECT_FALSE(getSnapshot(1)->isFrontBuffered());
1596 }
1597
TEST_F(LayerSnapshotTest,setSecureRootSnapshot)1598 TEST_F(LayerSnapshotTest, setSecureRootSnapshot) {
1599 setFlags(1, layer_state_t::eLayerSecure, layer_state_t::eLayerSecure);
1600 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
1601 .layerLifecycleManager = mLifecycleManager,
1602 .includeMetadata = false,
1603 .displays = mFrontEndDisplayInfos,
1604 .displayChanges = false,
1605 .globalShadowSettings = globalShadowSettings,
1606 .supportsBlur = true,
1607 .supportedLayerGenericMetadata = {},
1608 .genericLayerMetadataKeyMap = {}};
1609 args.rootSnapshot.isSecure = true;
1610 update(mSnapshotBuilder, args);
1611
1612 EXPECT_TRUE(getSnapshot(1)->isSecure);
1613 // Ensure child is also marked as secure
1614 EXPECT_TRUE(getSnapshot(11)->isSecure);
1615 }
1616
TEST_F(LayerSnapshotTest,setSensitiveForTracingConfigForSecureLayers)1617 TEST_F(LayerSnapshotTest, setSensitiveForTracingConfigForSecureLayers) {
1618 setFlags(11, layer_state_t::eLayerSecure, layer_state_t::eLayerSecure);
1619
1620 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1621
1622 EXPECT_TRUE(getSnapshot(11)->inputInfo.inputConfig.test(
1623 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1624 EXPECT_TRUE(getSnapshot(111)->inputInfo.inputConfig.test(
1625 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1626 EXPECT_FALSE(getSnapshot(1)->inputInfo.inputConfig.test(
1627 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1628 EXPECT_FALSE(getSnapshot(12)->inputInfo.inputConfig.test(
1629 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1630 EXPECT_FALSE(getSnapshot(2)->inputInfo.inputConfig.test(
1631 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1632 }
1633
TEST_F(LayerSnapshotTest,setSensitiveForTracingFromInputWindowHandle)1634 TEST_F(LayerSnapshotTest, setSensitiveForTracingFromInputWindowHandle) {
1635 setInputInfo(11, [](auto& inputInfo) {
1636 inputInfo.inputConfig |= gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY;
1637 });
1638
1639 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1640
1641 EXPECT_TRUE(getSnapshot(11)->inputInfo.inputConfig.test(
1642 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1643 EXPECT_TRUE(getSnapshot(111)->inputInfo.inputConfig.test(
1644 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1645 EXPECT_FALSE(getSnapshot(1)->inputInfo.inputConfig.test(
1646 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1647 EXPECT_FALSE(getSnapshot(12)->inputInfo.inputConfig.test(
1648 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1649 EXPECT_FALSE(getSnapshot(2)->inputInfo.inputConfig.test(
1650 gui::WindowInfo::InputConfig::SENSITIVE_FOR_PRIVACY));
1651 }
1652
1653 // b/314350323
TEST_F(LayerSnapshotTest,propagateDropInputMode)1654 TEST_F(LayerSnapshotTest, propagateDropInputMode) {
1655 setDropInputMode(1, gui::DropInputMode::ALL);
1656 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
1657 .layerLifecycleManager = mLifecycleManager,
1658 .includeMetadata = false,
1659 .displays = mFrontEndDisplayInfos,
1660 .displayChanges = false,
1661 .globalShadowSettings = globalShadowSettings,
1662 .supportsBlur = true,
1663 .supportedLayerGenericMetadata = {},
1664 .genericLayerMetadataKeyMap = {}};
1665 args.rootSnapshot.isSecure = true;
1666 update(mSnapshotBuilder, args);
1667
1668 EXPECT_EQ(getSnapshot(1)->dropInputMode, gui::DropInputMode::ALL);
1669 // Ensure child also has the correct drop input mode regardless of whether either layer has
1670 // an input channel
1671 EXPECT_EQ(getSnapshot(11)->dropInputMode, gui::DropInputMode::ALL);
1672 }
1673
TEST_F(LayerSnapshotTest,NonVisibleLayerWithInput)1674 TEST_F(LayerSnapshotTest, NonVisibleLayerWithInput) {
1675 SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::
1676 skip_invisible_windows_in_input,
1677 false);
1678 LayerHierarchyTestBase::createRootLayer(3);
1679 setColor(3, {-1._hf, -1._hf, -1._hf});
1680 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1681
1682 std::vector<QueuedTransactionState> transactions;
1683 transactions.emplace_back();
1684 transactions.back().states.push_back({});
1685 transactions.back().states.front().state.what = layer_state_t::eInputInfoChanged;
1686 transactions.back().states.front().layerId = 3;
1687 auto inputInfo = transactions.back().states.front().state.editWindowInfo();
1688 *inputInfo = {};
1689 inputInfo->token = sp<BBinder>::make();
1690 mLifecycleManager.applyTransactions(transactions);
1691
1692 update(mSnapshotBuilder);
1693
1694 bool foundInputLayer = false;
1695 mSnapshotBuilder.forEachInputSnapshot([&](const frontend::LayerSnapshot& snapshot) {
1696 if (snapshot.uniqueSequence == 3) {
1697 foundInputLayer = true;
1698 }
1699 });
1700 EXPECT_TRUE(foundInputLayer);
1701 }
1702
TEST_F(LayerSnapshotTest,NonVisibleLayerWithInputShouldNotBeIncluded)1703 TEST_F(LayerSnapshotTest, NonVisibleLayerWithInputShouldNotBeIncluded) {
1704 SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::
1705 skip_invisible_windows_in_input,
1706 true);
1707 LayerHierarchyTestBase::createRootLayer(3);
1708 setColor(3, {-1._hf, -1._hf, -1._hf});
1709 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1710
1711 std::vector<QueuedTransactionState> transactions;
1712 transactions.emplace_back();
1713 transactions.back().states.push_back({});
1714 transactions.back().states.front().state.what = layer_state_t::eInputInfoChanged;
1715 transactions.back().states.front().layerId = 3;
1716 auto inputInfo = transactions.back().states.front().state.editWindowInfo();
1717 *inputInfo = {};
1718 inputInfo->token = sp<BBinder>::make();
1719 hideLayer(3);
1720 mLifecycleManager.applyTransactions(transactions);
1721
1722 update(mSnapshotBuilder);
1723
1724 bool foundInputLayer = false;
1725 mSnapshotBuilder.forEachInputSnapshot([&](const frontend::LayerSnapshot& snapshot) {
1726 if (snapshot.uniqueSequence == 3) {
1727 EXPECT_TRUE(
1728 snapshot.inputInfo.inputConfig.test(gui::WindowInfo::InputConfig::NOT_VISIBLE));
1729 EXPECT_FALSE(snapshot.isVisible);
1730 foundInputLayer = true;
1731 }
1732 });
1733 EXPECT_FALSE(foundInputLayer);
1734 }
1735
TEST_F(LayerSnapshotTest,ForEachSnapshotsWithPredicate)1736 TEST_F(LayerSnapshotTest, ForEachSnapshotsWithPredicate) {
1737 std::vector<uint32_t> visitedUniqueSequences;
1738 mSnapshotBuilder.forEachSnapshot(
1739 [&](const std::unique_ptr<frontend::LayerSnapshot>& snapshot) {
1740 visitedUniqueSequences.push_back(snapshot->uniqueSequence);
1741 },
1742 [](const frontend::LayerSnapshot& snapshot) { return snapshot.uniqueSequence == 111; });
1743 EXPECT_EQ(visitedUniqueSequences.size(), 1u);
1744 EXPECT_EQ(visitedUniqueSequences[0], 111u);
1745 }
1746
TEST_F(LayerSnapshotTest,canOccludePresentation)1747 TEST_F(LayerSnapshotTest, canOccludePresentation) {
1748 setFlags(12, layer_state_t::eCanOccludePresentation, layer_state_t::eCanOccludePresentation);
1749 LayerSnapshotBuilder::Args args{.root = mHierarchyBuilder.getHierarchy(),
1750 .layerLifecycleManager = mLifecycleManager,
1751 .includeMetadata = false,
1752 .displays = mFrontEndDisplayInfos,
1753 .displayChanges = false,
1754 .globalShadowSettings = globalShadowSettings,
1755 .supportsBlur = true,
1756 .supportedLayerGenericMetadata = {},
1757 .genericLayerMetadataKeyMap = {}};
1758 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1759
1760 EXPECT_EQ(getSnapshot(1)->inputInfo.canOccludePresentation, false);
1761
1762 // ensure we can set the property on the window info for layer and all its children
1763 EXPECT_EQ(getSnapshot(12)->inputInfo.canOccludePresentation, true);
1764 EXPECT_EQ(getSnapshot(121)->inputInfo.canOccludePresentation, true);
1765 EXPECT_EQ(getSnapshot(1221)->inputInfo.canOccludePresentation, true);
1766 }
1767
TEST_F(LayerSnapshotTest,mirroredHierarchyIgnoresLocalTransform)1768 TEST_F(LayerSnapshotTest, mirroredHierarchyIgnoresLocalTransform) {
1769 SET_FLAG_FOR_TEST(flags::detached_mirror, true);
1770 reparentLayer(12, UNASSIGNED_LAYER_ID);
1771 setPosition(11, 2, 20);
1772 setPosition(111, 20, 200);
1773 mirrorLayer(/*layer*/ 14, /*parent*/ 1, /*layerToMirror*/ 11);
1774 std::vector<uint32_t> expected = {1, 11, 111, 13, 14, 11, 111, 2};
1775 UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
1776
1777 // mirror root has no position set
1778 EXPECT_EQ(getSnapshot({.id = 11, .mirrorRootIds = 14u})->localTransform.tx(), 0);
1779 EXPECT_EQ(getSnapshot({.id = 11, .mirrorRootIds = 14u})->localTransform.ty(), 0);
1780 // original root still has a position
1781 EXPECT_EQ(getSnapshot({.id = 11})->localTransform.tx(), 2);
1782 EXPECT_EQ(getSnapshot({.id = 11})->localTransform.ty(), 20);
1783
1784 // mirror child still has the correct position
1785 EXPECT_EQ(getSnapshot({.id = 111, .mirrorRootIds = 14u})->localTransform.tx(), 20);
1786 EXPECT_EQ(getSnapshot({.id = 111, .mirrorRootIds = 14u})->localTransform.ty(), 200);
1787 EXPECT_EQ(getSnapshot({.id = 111, .mirrorRootIds = 14u})->geomLayerTransform.tx(), 20);
1788 EXPECT_EQ(getSnapshot({.id = 111, .mirrorRootIds = 14u})->geomLayerTransform.ty(), 200);
1789
1790 // original child still has the correct position including its parent's position
1791 EXPECT_EQ(getSnapshot({.id = 111})->localTransform.tx(), 20);
1792 EXPECT_EQ(getSnapshot({.id = 111})->localTransform.ty(), 200);
1793 EXPECT_EQ(getSnapshot({.id = 111})->geomLayerTransform.tx(), 22);
1794 EXPECT_EQ(getSnapshot({.id = 111})->geomLayerTransform.ty(), 220);
1795 }
1796
TEST_F(LayerSnapshotTest,overrideParentTrustedOverlayState)1797 TEST_F(LayerSnapshotTest, overrideParentTrustedOverlayState) {
1798 SET_FLAG_FOR_TEST(flags::override_trusted_overlay, true);
1799 hideLayer(1);
1800 setTrustedOverlay(1, gui::TrustedOverlay::ENABLED);
1801
1802 Region touch{Rect{0, 0, 1000, 1000}};
1803 setTouchableRegion(1, touch);
1804 setTouchableRegion(11, touch);
1805 setTouchableRegion(111, touch);
1806
1807 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1808 EXPECT_TRUE(getSnapshot(1)->inputInfo.inputConfig.test(
1809 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1810 EXPECT_TRUE(getSnapshot(11)->inputInfo.inputConfig.test(
1811 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1812 EXPECT_TRUE(getSnapshot(111)->inputInfo.inputConfig.test(
1813 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1814
1815 // disable trusted overlay and override parent state
1816 setTrustedOverlay(11, gui::TrustedOverlay::DISABLED);
1817 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1818 EXPECT_TRUE(getSnapshot(1)->inputInfo.inputConfig.test(
1819 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1820 EXPECT_FALSE(getSnapshot(11)->inputInfo.inputConfig.test(
1821 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1822 EXPECT_FALSE(getSnapshot(111)->inputInfo.inputConfig.test(
1823 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1824
1825 // unset state and go back to default behavior of inheriting
1826 // state
1827 setTrustedOverlay(11, gui::TrustedOverlay::UNSET);
1828 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1829 EXPECT_TRUE(getSnapshot(1)->inputInfo.inputConfig.test(
1830 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1831 EXPECT_TRUE(getSnapshot(11)->inputInfo.inputConfig.test(
1832 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1833 EXPECT_TRUE(getSnapshot(111)->inputInfo.inputConfig.test(
1834 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1835 }
1836
TEST_F(LayerSnapshotTest,doNotOverrideParentTrustedOverlayState)1837 TEST_F(LayerSnapshotTest, doNotOverrideParentTrustedOverlayState) {
1838 SET_FLAG_FOR_TEST(flags::override_trusted_overlay, false);
1839 hideLayer(1);
1840 setTrustedOverlay(1, gui::TrustedOverlay::ENABLED);
1841
1842 Region touch{Rect{0, 0, 1000, 1000}};
1843 setTouchableRegion(1, touch);
1844 setTouchableRegion(11, touch);
1845 setTouchableRegion(111, touch);
1846
1847 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1848 EXPECT_TRUE(getSnapshot(1)->inputInfo.inputConfig.test(
1849 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1850 EXPECT_TRUE(getSnapshot(11)->inputInfo.inputConfig.test(
1851 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1852 EXPECT_TRUE(getSnapshot(111)->inputInfo.inputConfig.test(
1853 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1854
1855 // disable trusted overlay but flag is disabled so this behaves
1856 // as UNSET
1857 setTrustedOverlay(11, gui::TrustedOverlay::DISABLED);
1858 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1859 EXPECT_TRUE(getSnapshot(1)->inputInfo.inputConfig.test(
1860 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1861 EXPECT_TRUE(getSnapshot(11)->inputInfo.inputConfig.test(
1862 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1863 EXPECT_TRUE(getSnapshot(111)->inputInfo.inputConfig.test(
1864 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1865
1866 // unset state and go back to default behavior of inheriting
1867 // state
1868 setTrustedOverlay(11, gui::TrustedOverlay::UNSET);
1869 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1870 EXPECT_TRUE(getSnapshot(1)->inputInfo.inputConfig.test(
1871 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1872 EXPECT_TRUE(getSnapshot(11)->inputInfo.inputConfig.test(
1873 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1874 EXPECT_TRUE(getSnapshot(111)->inputInfo.inputConfig.test(
1875 gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
1876 }
1877
1878 static constexpr const FloatRect LARGE_FLOAT_RECT{std::numeric_limits<float>::min(),
1879 std::numeric_limits<float>::min(),
1880 std::numeric_limits<float>::max(),
1881 std::numeric_limits<float>::max()};
TEST_F(LayerSnapshotTest,layerVisibleByDefault)1882 TEST_F(LayerSnapshotTest, layerVisibleByDefault) {
1883 DisplayInfo info;
1884 info.info.logicalHeight = 1000000;
1885 info.info.logicalWidth = 1000000;
1886 mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
1887 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1888 EXPECT_FALSE(getSnapshot(1)->isHiddenByPolicy());
1889 }
1890
TEST_F(LayerSnapshotTest,hideLayerWithZeroMatrix)1891 TEST_F(LayerSnapshotTest, hideLayerWithZeroMatrix) {
1892 DisplayInfo info;
1893 info.info.logicalHeight = 1000000;
1894 info.info.logicalWidth = 1000000;
1895 mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
1896 setMatrix(1, 0.f, 0.f, 0.f, 0.f);
1897 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1898 EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());
1899 }
1900
TEST_F(LayerSnapshotTest,hideLayerWithInfMatrix)1901 TEST_F(LayerSnapshotTest, hideLayerWithInfMatrix) {
1902 DisplayInfo info;
1903 info.info.logicalHeight = 1000000;
1904 info.info.logicalWidth = 1000000;
1905 mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
1906 setMatrix(1, std::numeric_limits<float>::infinity(), 0.f, 0.f,
1907 std::numeric_limits<float>::infinity());
1908 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1909 EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());
1910 }
1911
TEST_F(LayerSnapshotTest,hideLayerWithNanMatrix)1912 TEST_F(LayerSnapshotTest, hideLayerWithNanMatrix) {
1913 DisplayInfo info;
1914 info.info.logicalHeight = 1000000;
1915 info.info.logicalWidth = 1000000;
1916 mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
1917 setMatrix(1, std::numeric_limits<float>::quiet_NaN(), 0.f, 0.f,
1918 std::numeric_limits<float>::quiet_NaN());
1919 UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
1920 EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());
1921 }
1922
TEST_F(LayerSnapshotTest,edgeExtensionPropagatesInHierarchy)1923 TEST_F(LayerSnapshotTest, edgeExtensionPropagatesInHierarchy) {
1924 setCrop(1, Rect(0, 0, 20, 20));
1925 setBuffer(1221,
1926 std::make_shared<renderengine::mock::FakeExternalTexture>(20 /* width */,
1927 20 /* height */,
1928 42ULL /* bufferId */,
1929 HAL_PIXEL_FORMAT_RGBA_8888,
1930 0 /*usage*/));
1931 setEdgeExtensionEffect(12, LEFT);
1932 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1933
1934 EXPECT_TRUE(getSnapshot({.id = 12})->edgeExtensionEffect.extendsEdge(LEFT));
1935 EXPECT_TRUE(getSnapshot({.id = 121})->edgeExtensionEffect.extendsEdge(LEFT));
1936 EXPECT_TRUE(getSnapshot({.id = 1221})->edgeExtensionEffect.extendsEdge(LEFT));
1937
1938 setEdgeExtensionEffect(12, RIGHT);
1939 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1940
1941 EXPECT_TRUE(getSnapshot({.id = 12})->edgeExtensionEffect.extendsEdge(RIGHT));
1942 EXPECT_TRUE(getSnapshot({.id = 121})->edgeExtensionEffect.extendsEdge(RIGHT));
1943 EXPECT_TRUE(getSnapshot({.id = 1221})->edgeExtensionEffect.extendsEdge(RIGHT));
1944
1945 setEdgeExtensionEffect(12, TOP);
1946 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1947
1948 EXPECT_TRUE(getSnapshot({.id = 12})->edgeExtensionEffect.extendsEdge(TOP));
1949 EXPECT_TRUE(getSnapshot({.id = 121})->edgeExtensionEffect.extendsEdge(TOP));
1950 EXPECT_TRUE(getSnapshot({.id = 1221})->edgeExtensionEffect.extendsEdge(TOP));
1951
1952 setEdgeExtensionEffect(12, BOTTOM);
1953 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1954
1955 EXPECT_TRUE(getSnapshot({.id = 12})->edgeExtensionEffect.extendsEdge(BOTTOM));
1956 EXPECT_TRUE(getSnapshot({.id = 121})->edgeExtensionEffect.extendsEdge(BOTTOM));
1957 EXPECT_TRUE(getSnapshot({.id = 1221})->edgeExtensionEffect.extendsEdge(BOTTOM));
1958 }
1959
TEST_F(LayerSnapshotTest,leftEdgeExtensionIncreaseBoundSizeWithinCrop)1960 TEST_F(LayerSnapshotTest, leftEdgeExtensionIncreaseBoundSizeWithinCrop) {
1961 // The left bound is extended when shifting to the right
1962 setCrop(1, Rect(0, 0, 20, 20));
1963 const int texSize = 10;
1964 setBuffer(1221,
1965 std::make_shared<renderengine::mock::FakeExternalTexture>(texSize /* width */,
1966 texSize /* height*/,
1967 42ULL /* bufferId */,
1968 HAL_PIXEL_FORMAT_RGBA_8888,
1969 0 /*usage*/));
1970 const float translation = 5.0;
1971 setPosition(12, translation, 0);
1972 setEdgeExtensionEffect(12, LEFT);
1973 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1974 EXPECT_EQ(getSnapshot({.id = 1221})->transformedBounds.right, texSize + translation);
1975 EXPECT_LT(getSnapshot({.id = 1221})->transformedBounds.left, translation);
1976 EXPECT_GE(getSnapshot({.id = 1221})->transformedBounds.left, 0.0);
1977 }
1978
TEST_F(LayerSnapshotTest,rightEdgeExtensionIncreaseBoundSizeWithinCrop)1979 TEST_F(LayerSnapshotTest, rightEdgeExtensionIncreaseBoundSizeWithinCrop) {
1980 // The right bound is extended when shifting to the left
1981 const int crop = 20;
1982 setCrop(1, Rect(0, 0, crop, crop));
1983 const int texSize = 10;
1984 setBuffer(1221,
1985 std::make_shared<renderengine::mock::FakeExternalTexture>(texSize /* width */,
1986 texSize /* height*/,
1987 42ULL /* bufferId */,
1988 HAL_PIXEL_FORMAT_RGBA_8888,
1989 0 /*usage*/));
1990 const float translation = -5.0;
1991 setPosition(12, translation, 0);
1992 setEdgeExtensionEffect(12, RIGHT);
1993 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
1994 EXPECT_EQ(getSnapshot({.id = 1221})->transformedBounds.left, 0);
1995 EXPECT_GT(getSnapshot({.id = 1221})->transformedBounds.right, texSize + translation);
1996 EXPECT_LE(getSnapshot({.id = 1221})->transformedBounds.right, (float)crop);
1997 }
1998
TEST_F(LayerSnapshotTest,topEdgeExtensionIncreaseBoundSizeWithinCrop)1999 TEST_F(LayerSnapshotTest, topEdgeExtensionIncreaseBoundSizeWithinCrop) {
2000 // The top bound is extended when shifting to the bottom
2001 setCrop(1, Rect(0, 0, 20, 20));
2002 const int texSize = 10;
2003 setBuffer(1221,
2004 std::make_shared<renderengine::mock::FakeExternalTexture>(texSize /* width */,
2005 texSize /* height*/,
2006 42ULL /* bufferId */,
2007 HAL_PIXEL_FORMAT_RGBA_8888,
2008 0 /*usage*/));
2009 const float translation = 5.0;
2010 setPosition(12, 0, translation);
2011 setEdgeExtensionEffect(12, TOP);
2012 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2013 EXPECT_EQ(getSnapshot({.id = 1221})->transformedBounds.bottom, texSize + translation);
2014 EXPECT_LT(getSnapshot({.id = 1221})->transformedBounds.top, translation);
2015 EXPECT_GE(getSnapshot({.id = 1221})->transformedBounds.top, 0.0);
2016 }
2017
TEST_F(LayerSnapshotTest,bottomEdgeExtensionIncreaseBoundSizeWithinCrop)2018 TEST_F(LayerSnapshotTest, bottomEdgeExtensionIncreaseBoundSizeWithinCrop) {
2019 // The bottom bound is extended when shifting to the top
2020 const int crop = 20;
2021 setCrop(1, Rect(0, 0, crop, crop));
2022 const int texSize = 10;
2023 setBuffer(1221,
2024 std::make_shared<renderengine::mock::FakeExternalTexture>(texSize /* width */,
2025 texSize /* height*/,
2026 42ULL /* bufferId */,
2027 HAL_PIXEL_FORMAT_RGBA_8888,
2028 0 /*usage*/));
2029 const float translation = -5.0;
2030 setPosition(12, 0, translation);
2031 setEdgeExtensionEffect(12, BOTTOM);
2032 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2033 EXPECT_EQ(getSnapshot({.id = 1221})->transformedBounds.top, 0);
2034 EXPECT_GT(getSnapshot({.id = 1221})->transformedBounds.bottom, texSize - translation);
2035 EXPECT_LE(getSnapshot({.id = 1221})->transformedBounds.bottom, (float)crop);
2036 }
2037
TEST_F(LayerSnapshotTest,multipleEdgeExtensionIncreaseBoundSizeWithinCrop)2038 TEST_F(LayerSnapshotTest, multipleEdgeExtensionIncreaseBoundSizeWithinCrop) {
2039 // The left bound is extended when shifting to the right
2040 const int crop = 20;
2041 setCrop(1, Rect(0, 0, crop, crop));
2042 const int texSize = 10;
2043 setBuffer(1221,
2044 std::make_shared<renderengine::mock::FakeExternalTexture>(texSize /* width */,
2045 texSize /* height*/,
2046 42ULL /* bufferId */,
2047 HAL_PIXEL_FORMAT_RGBA_8888,
2048 0 /*usage*/));
2049 const float translation = 5.0;
2050 setPosition(12, translation, translation);
2051 setEdgeExtensionEffect(12, LEFT | RIGHT | TOP | BOTTOM);
2052 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2053 EXPECT_GT(getSnapshot({.id = 1221})->transformedBounds.right, texSize + translation);
2054 EXPECT_LE(getSnapshot({.id = 1221})->transformedBounds.right, (float)crop);
2055 EXPECT_LT(getSnapshot({.id = 1221})->transformedBounds.left, translation);
2056 EXPECT_GE(getSnapshot({.id = 1221})->transformedBounds.left, 0.0);
2057 EXPECT_GT(getSnapshot({.id = 1221})->transformedBounds.bottom, texSize + translation);
2058 EXPECT_LE(getSnapshot({.id = 1221})->transformedBounds.bottom, (float)crop);
2059 EXPECT_LT(getSnapshot({.id = 1221})->transformedBounds.top, translation);
2060 EXPECT_GE(getSnapshot({.id = 1221})->transformedBounds.top, 0);
2061 }
2062
TEST_F(LayerSnapshotTest,shouldUpdateInputWhenNoInputInfo)2063 TEST_F(LayerSnapshotTest, shouldUpdateInputWhenNoInputInfo) {
2064 // If a layer has no buffer or no color, it doesn't have an input info
2065 setColor(111, {-1._hf, -1._hf, -1._hf});
2066 UPDATE_AND_VERIFY(mSnapshotBuilder, {1, 11, 12, 121, 122, 1221, 13, 2});
2067 EXPECT_FALSE(getSnapshot(111)->hasInputInfo());
2068
2069 setBuffer(111);
2070 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2071
2072 EXPECT_TRUE(getSnapshot(111)->hasInputInfo());
2073 EXPECT_TRUE(getSnapshot(111)->inputInfo.inputConfig.test(
2074 gui::WindowInfo::InputConfig::NO_INPUT_CHANNEL));
2075 }
2076
2077 // content dirty test
TEST_F(LayerSnapshotTest,contentDirtyWhenParentAlphaChanges)2078 TEST_F(LayerSnapshotTest, contentDirtyWhenParentAlphaChanges) {
2079 setAlpha(1, 0.5);
2080 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2081 EXPECT_TRUE(getSnapshot(1)->contentDirty);
2082 EXPECT_TRUE(getSnapshot(11)->contentDirty);
2083 EXPECT_TRUE(getSnapshot(111)->contentDirty);
2084
2085 // subsequent updates clear the dirty bit
2086 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2087 EXPECT_FALSE(getSnapshot(1)->contentDirty);
2088 EXPECT_FALSE(getSnapshot(11)->contentDirty);
2089 EXPECT_FALSE(getSnapshot(111)->contentDirty);
2090 }
2091
TEST_F(LayerSnapshotTest,contentDirtyWhenAutoRefresh)2092 TEST_F(LayerSnapshotTest, contentDirtyWhenAutoRefresh) {
2093 setAutoRefresh(1, true);
2094 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2095 EXPECT_TRUE(getSnapshot(1)->contentDirty);
2096
2097 // subsequent updates don't clear the dirty bit
2098 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2099 EXPECT_TRUE(getSnapshot(1)->contentDirty);
2100
2101 // second update after removing auto refresh will clear content dirty
2102 setAutoRefresh(1, false);
2103 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2104 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2105 EXPECT_FALSE(getSnapshot(1)->contentDirty);
2106 }
2107
TEST_F(LayerSnapshotTest,contentDirtyWhenColorChanges)2108 TEST_F(LayerSnapshotTest, contentDirtyWhenColorChanges) {
2109 setColor(1, {1, 2, 3});
2110 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2111 EXPECT_TRUE(getSnapshot(1)->contentDirty);
2112
2113 // subsequent updates clear the dirty bit
2114 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2115 EXPECT_FALSE(getSnapshot(1)->contentDirty);
2116 }
2117
TEST_F(LayerSnapshotTest,contentDirtyWhenParentGeometryChanges)2118 TEST_F(LayerSnapshotTest, contentDirtyWhenParentGeometryChanges) {
2119 setPosition(1, 2, 3);
2120 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2121 EXPECT_TRUE(getSnapshot(1)->contentDirty);
2122
2123 // subsequent updates clear the dirty bit
2124 UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
2125 EXPECT_FALSE(getSnapshot(1)->contentDirty);
2126 }
TEST_F(LayerSnapshotTest,shouldUpdatePictureProfileHandle)2127 TEST_F(LayerSnapshotTest, shouldUpdatePictureProfileHandle) {
2128 std::vector<QueuedTransactionState> transactions;
2129 transactions.emplace_back();
2130 transactions.back().states.push_back({});
2131 transactions.back().states.back().layerId = 1;
2132 transactions.back().states.back().state.layerId = 1;
2133 transactions.back().states.back().state.what = layer_state_t::ePictureProfileHandleChanged;
2134 transactions.back().states.back().state.pictureProfileHandle = PictureProfileHandle(3);
2135
2136 mLifecycleManager.applyTransactions(transactions);
2137 EXPECT_EQ(mLifecycleManager.getGlobalChanges(), RequestedLayerState::Changes::Content);
2138
2139 update(mSnapshotBuilder);
2140
2141 EXPECT_EQ(getSnapshot(1)->clientChanges, layer_state_t::ePictureProfileHandleChanged);
2142 EXPECT_EQ(getSnapshot(1)->pictureProfileHandle, PictureProfileHandle(3));
2143 }
2144
TEST_F(LayerSnapshotTest,shouldUpdatePictureProfilePriorityFromAppContentPriority)2145 TEST_F(LayerSnapshotTest, shouldUpdatePictureProfilePriorityFromAppContentPriority) {
2146 {
2147 std::vector<QueuedTransactionState> transactions;
2148 transactions.emplace_back();
2149 transactions.back().states.push_back({});
2150 transactions.back().states.back().layerId = 1;
2151 transactions.back().states.back().state.layerId = 1;
2152 transactions.back().states.back().state.what = layer_state_t::eAppContentPriorityChanged;
2153 transactions.back().states.back().state.appContentPriority = 1;
2154 transactions.back().states.push_back({});
2155 transactions.back().states.back().layerId = 2;
2156 transactions.back().states.back().state.layerId = 2;
2157 transactions.back().states.back().state.what = layer_state_t::eAppContentPriorityChanged;
2158 transactions.back().states.back().state.appContentPriority = -1;
2159
2160 mLifecycleManager.applyTransactions(transactions);
2161 EXPECT_EQ(mLifecycleManager.getGlobalChanges(), RequestedLayerState::Changes::Content);
2162
2163 update(mSnapshotBuilder);
2164
2165 EXPECT_GT(getSnapshot(1)->pictureProfilePriority, getSnapshot(2)->pictureProfilePriority);
2166 EXPECT_EQ(getSnapshot(1)->pictureProfilePriority - getSnapshot(2)->pictureProfilePriority,
2167 2);
2168 }
2169 {
2170 std::vector<QueuedTransactionState> transactions;
2171 transactions.emplace_back();
2172 transactions.back().states.push_back({});
2173 transactions.back().states.back().layerId = 1;
2174 transactions.back().states.back().state.layerId = 1;
2175 transactions.back().states.back().state.what = layer_state_t::eAppContentPriorityChanged;
2176 transactions.back().states.back().state.appContentPriority = INT_MIN;
2177 transactions.back().states.push_back({});
2178 transactions.back().states.back().layerId = 2;
2179 transactions.back().states.back().state.layerId = 2;
2180 transactions.back().states.back().state.what = layer_state_t::eAppContentPriorityChanged;
2181 transactions.back().states.back().state.appContentPriority = INT_MAX;
2182
2183 mLifecycleManager.applyTransactions(transactions);
2184 EXPECT_EQ(mLifecycleManager.getGlobalChanges(), RequestedLayerState::Changes::Content);
2185
2186 update(mSnapshotBuilder);
2187
2188 EXPECT_GT(getSnapshot(2)->pictureProfilePriority, getSnapshot(1)->pictureProfilePriority);
2189 }
2190 }
2191
2192 } // namespace android::surfaceflinger::frontend
2193