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