blob: 115a44db4adb13d2918ca27924ba293438fd006d [file] [log] [blame]
Ady Abraham60e42ea2020-03-09 19:17:31 -07001/*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#undef LOG_TAG
18#define LOG_TAG "LibSurfaceFlingerUnittests"
19
20#include <gmock/gmock.h>
21#include <gtest/gtest.h>
22#include <gui/LayerMetadata.h>
23
24// TODO(b/129481165): remove the #pragma below and fix conversion issues
25#pragma clang diagnostic push
26#pragma clang diagnostic ignored "-Wconversion"
Ady Abraham60e42ea2020-03-09 19:17:31 -070027#include "BufferStateLayer.h"
28#include "EffectLayer.h"
29#include "Layer.h"
30// TODO(b/129481165): remove the #pragma below and fix conversion issues
31#pragma clang diagnostic pop // ignored "-Wconversion"
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070032#include "FpsOps.h"
Ady Abraham60e42ea2020-03-09 19:17:31 -070033#include "TestableSurfaceFlinger.h"
34#include "mock/DisplayHardware/MockComposer.h"
Ady Abraham60e42ea2020-03-09 19:17:31 -070035#include "mock/MockEventThread.h"
Ady Abraham8cb21882020-08-26 18:22:05 -070036#include "mock/MockVsyncController.h"
Ady Abraham60e42ea2020-03-09 19:17:31 -070037
38namespace android {
39
40using testing::_;
41using testing::DoAll;
42using testing::Mock;
43using testing::Return;
44using testing::SetArgPointee;
45
46using android::Hwc2::IComposer;
47using android::Hwc2::IComposerClient;
48
49using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
50
51using FrameRate = Layer::FrameRate;
52using FrameRateCompatibility = Layer::FrameRateCompatibility;
53
54class LayerFactory {
55public:
56 virtual ~LayerFactory() = default;
57
58 virtual std::string name() = 0;
59 virtual sp<Layer> createLayer(TestableSurfaceFlinger& flinger) = 0;
60
61protected:
62 static constexpr uint32_t WIDTH = 100;
63 static constexpr uint32_t HEIGHT = 100;
64 static constexpr uint32_t LAYER_FLAGS = 0;
65};
66
Ady Abraham60e42ea2020-03-09 19:17:31 -070067class BufferStateLayerFactory : public LayerFactory {
68public:
69 std::string name() override { return "BufferStateLayer"; }
70 sp<Layer> createLayer(TestableSurfaceFlinger& flinger) override {
71 sp<Client> client;
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -080072 LayerCreationArgs args(flinger.flinger(), client, "buffer-state-layer", LAYER_FLAGS,
73 LayerMetadata());
Ady Abraham60e42ea2020-03-09 19:17:31 -070074 return new BufferStateLayer(args);
75 }
76};
77
78class EffectLayerFactory : public LayerFactory {
79public:
80 std::string name() override { return "EffectLayer"; }
81 sp<Layer> createLayer(TestableSurfaceFlinger& flinger) override {
82 sp<Client> client;
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -080083 LayerCreationArgs args(flinger.flinger(), client, "color-layer", LAYER_FLAGS,
Ady Abraham60e42ea2020-03-09 19:17:31 -070084 LayerMetadata());
85 return new EffectLayer(args);
86 }
87};
88
89std::string PrintToStringParamName(
90 const ::testing::TestParamInfo<std::shared_ptr<LayerFactory>>& info) {
91 return info.param->name();
92}
93
94/**
95 * This class tests the behaviour of Layer::SetFrameRate and Layer::GetFrameRate
96 */
97class SetFrameRateTest : public ::testing::TestWithParam<std::shared_ptr<LayerFactory>> {
98protected:
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070099 const FrameRate FRAME_RATE_VOTE1 = FrameRate(67_Hz, FrameRateCompatibility::Default);
100 const FrameRate FRAME_RATE_VOTE2 = FrameRate(14_Hz, FrameRateCompatibility::ExactOrMultiple);
101 const FrameRate FRAME_RATE_VOTE3 = FrameRate(99_Hz, FrameRateCompatibility::NoVote);
102 const FrameRate FRAME_RATE_TREE = FrameRate(Fps(), FrameRateCompatibility::NoVote);
103 const FrameRate FRAME_RATE_NO_VOTE = FrameRate(Fps(), FrameRateCompatibility::Default);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700104
105 SetFrameRateTest();
106
107 void setupScheduler();
Ady Abraham60e42ea2020-03-09 19:17:31 -0700108
109 void addChild(sp<Layer> layer, sp<Layer> child);
110 void removeChild(sp<Layer> layer, sp<Layer> child);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700111 void commitTransaction();
112
113 TestableSurfaceFlinger mFlinger;
Ady Abraham60e42ea2020-03-09 19:17:31 -0700114
115 std::vector<sp<Layer>> mLayers;
116};
117
118SetFrameRateTest::SetFrameRateTest() {
119 const ::testing::TestInfo* const test_info =
120 ::testing::UnitTest::GetInstance()->current_test_info();
121 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
122
Ady Abraham60e42ea2020-03-09 19:17:31 -0700123 setupScheduler();
Ady Abraham60e42ea2020-03-09 19:17:31 -0700124
Dominik Laskowski13948602021-03-08 20:48:28 -0800125 mFlinger.setupComposer(std::make_unique<Hwc2::mock::Composer>());
Ady Abraham60e42ea2020-03-09 19:17:31 -0700126}
Dominik Laskowski13948602021-03-08 20:48:28 -0800127
Ady Abraham60e42ea2020-03-09 19:17:31 -0700128void SetFrameRateTest::addChild(sp<Layer> layer, sp<Layer> child) {
129 layer.get()->addChild(child.get());
130}
131
132void SetFrameRateTest::removeChild(sp<Layer> layer, sp<Layer> child) {
133 layer.get()->removeChild(child.get());
134}
135
Ady Abraham60e42ea2020-03-09 19:17:31 -0700136void SetFrameRateTest::commitTransaction() {
137 for (auto layer : mLayers) {
Robert Carr6a160312021-05-17 12:08:20 -0700138 auto c = layer->getDrawingState();
Robert Carr0758e5d2021-03-11 22:15:04 -0800139 layer->commitTransaction(c);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700140 }
141}
142
143void SetFrameRateTest::setupScheduler() {
144 auto eventThread = std::make_unique<mock::EventThread>();
145 auto sfEventThread = std::make_unique<mock::EventThread>();
146
147 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
148 EXPECT_CALL(*eventThread, createEventConnection(_, _))
Ady Abraham0bb6a472020-10-12 10:22:13 -0700149 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
Ady Abraham62f216c2020-10-13 19:07:23 -0700150 ResyncCallback())));
Ady Abraham60e42ea2020-03-09 19:17:31 -0700151
152 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
153 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
Ady Abraham0bb6a472020-10-12 10:22:13 -0700154 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
Ady Abraham62f216c2020-10-13 19:07:23 -0700155 ResyncCallback())));
Ady Abraham60e42ea2020-03-09 19:17:31 -0700156
Ady Abraham8cb21882020-08-26 18:22:05 -0700157 auto vsyncController = std::make_unique<mock::VsyncController>();
158 auto vsyncTracker = std::make_unique<mock::VSyncTracker>();
Ady Abraham60e42ea2020-03-09 19:17:31 -0700159
Ady Abraham8cb21882020-08-26 18:22:05 -0700160 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
161 EXPECT_CALL(*vsyncTracker, currentPeriod())
Marin Shalamanov045b7002021-01-07 16:56:24 +0100162 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Ady Abraham8cb21882020-08-26 18:22:05 -0700163 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
164 mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800165 std::move(eventThread), std::move(sfEventThread), /*callback*/ nullptr,
166 /*hasMultipleModes*/ true);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700167}
168
Ady Abraham60e42ea2020-03-09 19:17:31 -0700169namespace {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700170
Ady Abraham60e42ea2020-03-09 19:17:31 -0700171TEST_P(SetFrameRateTest, SetAndGet) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700172 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700173
174 const auto& layerFactory = GetParam();
175
176 auto layer = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
177 layer->setFrameRate(FRAME_RATE_VOTE1);
178 commitTransaction();
179 EXPECT_EQ(FRAME_RATE_VOTE1, layer->getFrameRateForLayerTree());
180}
181
182TEST_P(SetFrameRateTest, SetAndGetParent) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700183 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700184
185 const auto& layerFactory = GetParam();
186
187 auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
188 auto child1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
189 auto child2 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
190
191 addChild(parent, child1);
192 addChild(child1, child2);
193
194 child2->setFrameRate(FRAME_RATE_VOTE1);
195 commitTransaction();
196 EXPECT_EQ(FRAME_RATE_TREE, parent->getFrameRateForLayerTree());
197 EXPECT_EQ(FRAME_RATE_TREE, child1->getFrameRateForLayerTree());
198 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
199
200 child2->setFrameRate(FRAME_RATE_NO_VOTE);
201 commitTransaction();
202 EXPECT_EQ(FRAME_RATE_NO_VOTE, parent->getFrameRateForLayerTree());
203 EXPECT_EQ(FRAME_RATE_NO_VOTE, child1->getFrameRateForLayerTree());
204 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
205}
206
207TEST_P(SetFrameRateTest, SetAndGetParentAllVote) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700208 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700209
210 const auto& layerFactory = GetParam();
211
212 auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
213 auto child1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
214 auto child2 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
215
216 addChild(parent, child1);
217 addChild(child1, child2);
218
219 child2->setFrameRate(FRAME_RATE_VOTE1);
220 child1->setFrameRate(FRAME_RATE_VOTE2);
221 parent->setFrameRate(FRAME_RATE_VOTE3);
222 commitTransaction();
223 EXPECT_EQ(FRAME_RATE_VOTE3, parent->getFrameRateForLayerTree());
224 EXPECT_EQ(FRAME_RATE_VOTE2, child1->getFrameRateForLayerTree());
225 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
226
227 child2->setFrameRate(FRAME_RATE_NO_VOTE);
228 commitTransaction();
229 EXPECT_EQ(FRAME_RATE_VOTE3, parent->getFrameRateForLayerTree());
230 EXPECT_EQ(FRAME_RATE_VOTE2, child1->getFrameRateForLayerTree());
Ady Abrahamf467f892020-07-31 16:01:53 -0700231 EXPECT_EQ(FRAME_RATE_VOTE2, child2->getFrameRateForLayerTree());
Ady Abraham60e42ea2020-03-09 19:17:31 -0700232
233 child1->setFrameRate(FRAME_RATE_NO_VOTE);
234 commitTransaction();
235 EXPECT_EQ(FRAME_RATE_VOTE3, parent->getFrameRateForLayerTree());
Ady Abrahamf467f892020-07-31 16:01:53 -0700236 EXPECT_EQ(FRAME_RATE_VOTE3, child1->getFrameRateForLayerTree());
237 EXPECT_EQ(FRAME_RATE_VOTE3, child2->getFrameRateForLayerTree());
Ady Abraham60e42ea2020-03-09 19:17:31 -0700238
239 parent->setFrameRate(FRAME_RATE_NO_VOTE);
240 commitTransaction();
241 EXPECT_EQ(FRAME_RATE_NO_VOTE, parent->getFrameRateForLayerTree());
242 EXPECT_EQ(FRAME_RATE_NO_VOTE, child1->getFrameRateForLayerTree());
243 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
244}
245
246TEST_P(SetFrameRateTest, SetAndGetChild) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700247 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700248
249 const auto& layerFactory = GetParam();
250
251 auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
252 auto child1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
253 auto child2 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
254
255 addChild(parent, child1);
256 addChild(child1, child2);
257
258 parent->setFrameRate(FRAME_RATE_VOTE1);
259 commitTransaction();
260 EXPECT_EQ(FRAME_RATE_VOTE1, parent->getFrameRateForLayerTree());
Ady Abrahamf467f892020-07-31 16:01:53 -0700261 EXPECT_EQ(FRAME_RATE_VOTE1, child1->getFrameRateForLayerTree());
262 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
Ady Abraham60e42ea2020-03-09 19:17:31 -0700263
264 parent->setFrameRate(FRAME_RATE_NO_VOTE);
265 commitTransaction();
266 EXPECT_EQ(FRAME_RATE_NO_VOTE, parent->getFrameRateForLayerTree());
267 EXPECT_EQ(FRAME_RATE_NO_VOTE, child1->getFrameRateForLayerTree());
268 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
269}
270
271TEST_P(SetFrameRateTest, SetAndGetChildAllVote) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700272 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700273
274 const auto& layerFactory = GetParam();
275
276 auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
277 auto child1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
278 auto child2 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
279
280 addChild(parent, child1);
281 addChild(child1, child2);
282
283 child2->setFrameRate(FRAME_RATE_VOTE1);
284 child1->setFrameRate(FRAME_RATE_VOTE2);
285 parent->setFrameRate(FRAME_RATE_VOTE3);
286 commitTransaction();
287 EXPECT_EQ(FRAME_RATE_VOTE3, parent->getFrameRateForLayerTree());
288 EXPECT_EQ(FRAME_RATE_VOTE2, child1->getFrameRateForLayerTree());
289 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
290
291 parent->setFrameRate(FRAME_RATE_NO_VOTE);
292 commitTransaction();
293 EXPECT_EQ(FRAME_RATE_TREE, parent->getFrameRateForLayerTree());
294 EXPECT_EQ(FRAME_RATE_VOTE2, child1->getFrameRateForLayerTree());
295 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
296
297 child1->setFrameRate(FRAME_RATE_NO_VOTE);
298 commitTransaction();
299 EXPECT_EQ(FRAME_RATE_TREE, parent->getFrameRateForLayerTree());
300 EXPECT_EQ(FRAME_RATE_TREE, child1->getFrameRateForLayerTree());
301 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
302
303 child2->setFrameRate(FRAME_RATE_NO_VOTE);
304 commitTransaction();
305 EXPECT_EQ(FRAME_RATE_NO_VOTE, parent->getFrameRateForLayerTree());
306 EXPECT_EQ(FRAME_RATE_NO_VOTE, child1->getFrameRateForLayerTree());
307 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
308}
309
310TEST_P(SetFrameRateTest, SetAndGetChildAddAfterVote) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700311 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700312
313 const auto& layerFactory = GetParam();
314
315 auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
316 auto child1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
317 auto child2 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
318
319 addChild(parent, child1);
320
321 parent->setFrameRate(FRAME_RATE_VOTE1);
322 commitTransaction();
323 EXPECT_EQ(FRAME_RATE_VOTE1, parent->getFrameRateForLayerTree());
Ady Abrahamf467f892020-07-31 16:01:53 -0700324 EXPECT_EQ(FRAME_RATE_VOTE1, child1->getFrameRateForLayerTree());
Ady Abraham60e42ea2020-03-09 19:17:31 -0700325 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
326
327 addChild(child1, child2);
328 commitTransaction();
329 EXPECT_EQ(FRAME_RATE_VOTE1, parent->getFrameRateForLayerTree());
Ady Abrahamf467f892020-07-31 16:01:53 -0700330 EXPECT_EQ(FRAME_RATE_VOTE1, child1->getFrameRateForLayerTree());
331 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
Ady Abraham60e42ea2020-03-09 19:17:31 -0700332
333 parent->setFrameRate(FRAME_RATE_NO_VOTE);
334 commitTransaction();
335 EXPECT_EQ(FRAME_RATE_NO_VOTE, parent->getFrameRateForLayerTree());
336 EXPECT_EQ(FRAME_RATE_NO_VOTE, child1->getFrameRateForLayerTree());
337 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
338}
339
340TEST_P(SetFrameRateTest, SetAndGetChildRemoveAfterVote) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700341 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700342
343 const auto& layerFactory = GetParam();
344
345 auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
346 auto child1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
347 auto child2 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
348
349 addChild(parent, child1);
350 addChild(child1, child2);
351
352 parent->setFrameRate(FRAME_RATE_VOTE1);
353 commitTransaction();
354 EXPECT_EQ(FRAME_RATE_VOTE1, parent->getFrameRateForLayerTree());
Ady Abrahamf467f892020-07-31 16:01:53 -0700355 EXPECT_EQ(FRAME_RATE_VOTE1, child1->getFrameRateForLayerTree());
356 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
Ady Abraham60e42ea2020-03-09 19:17:31 -0700357
358 removeChild(child1, child2);
359 commitTransaction();
360 EXPECT_EQ(FRAME_RATE_VOTE1, parent->getFrameRateForLayerTree());
Ady Abrahamf467f892020-07-31 16:01:53 -0700361 EXPECT_EQ(FRAME_RATE_VOTE1, child1->getFrameRateForLayerTree());
Ady Abraham60e42ea2020-03-09 19:17:31 -0700362 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
363
364 parent->setFrameRate(FRAME_RATE_NO_VOTE);
365 commitTransaction();
366 EXPECT_EQ(FRAME_RATE_NO_VOTE, parent->getFrameRateForLayerTree());
367 EXPECT_EQ(FRAME_RATE_NO_VOTE, child1->getFrameRateForLayerTree());
368 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
369}
370
371TEST_P(SetFrameRateTest, SetAndGetParentNotInTree) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700372 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700373
374 const auto& layerFactory = GetParam();
375
376 auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
377 auto child1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
378 auto child2 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
379 auto child2_1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
380
381 addChild(parent, child1);
382 addChild(child1, child2);
383 addChild(child1, child2_1);
384
385 child2->setFrameRate(FRAME_RATE_VOTE1);
386 commitTransaction();
387 EXPECT_EQ(FRAME_RATE_TREE, parent->getFrameRateForLayerTree());
388 EXPECT_EQ(FRAME_RATE_TREE, child1->getFrameRateForLayerTree());
389 EXPECT_EQ(FRAME_RATE_VOTE1, child2->getFrameRateForLayerTree());
390 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2_1->getFrameRateForLayerTree());
391
392 child2->setFrameRate(FRAME_RATE_NO_VOTE);
393 commitTransaction();
394 EXPECT_EQ(FRAME_RATE_NO_VOTE, parent->getFrameRateForLayerTree());
395 EXPECT_EQ(FRAME_RATE_NO_VOTE, child1->getFrameRateForLayerTree());
396 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
397 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2_1->getFrameRateForLayerTree());
398}
399
Ady Abraham60e42ea2020-03-09 19:17:31 -0700400INSTANTIATE_TEST_SUITE_P(PerLayerType, SetFrameRateTest,
Robert Carr80b1b1c2021-09-29 12:44:17 -0700401 testing::Values(std::make_shared<BufferStateLayerFactory>(),
Ady Abraham60e42ea2020-03-09 19:17:31 -0700402 std::make_shared<EffectLayerFactory>()),
403 PrintToStringParamName);
404
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800405TEST_F(SetFrameRateTest, ValidateFrameRate) {
Marin Shalamanovc5986772021-03-16 16:09:49 +0100406 EXPECT_TRUE(ValidateFrameRate(60.0f, ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT,
407 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
408 EXPECT_TRUE(ValidateFrameRate(60.0f, ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT,
409 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
410 EXPECT_TRUE(ValidateFrameRate(60.0f, ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT,
411 ANATIVEWINDOW_CHANGE_FRAME_RATE_ALWAYS, ""));
412 EXPECT_TRUE(ValidateFrameRate(60.0f, ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_FIXED_SOURCE,
413 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
414 EXPECT_TRUE(ValidateFrameRate(60.0f, ANATIVEWINDOW_FRAME_RATE_EXACT,
415 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, "",
416 /*privileged=*/true));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800417
Marin Shalamanovc5986772021-03-16 16:09:49 +0100418 EXPECT_FALSE(ValidateFrameRate(-1, ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT,
419 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
420 EXPECT_FALSE(ValidateFrameRate(1.0f / 0.0f, ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT,
421 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
422 EXPECT_FALSE(ValidateFrameRate(0.0f / 0.0f, ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT,
423 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800424
Marin Shalamanovc5986772021-03-16 16:09:49 +0100425 EXPECT_FALSE(ValidateFrameRate(60.0f, ANATIVEWINDOW_FRAME_RATE_EXACT,
426 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
427
428 // Invalid compatibility
429 EXPECT_FALSE(
430 ValidateFrameRate(60.0f, -1, ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
431 EXPECT_FALSE(ValidateFrameRate(60.0f, 2, ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS, ""));
432
433 // Invalid change frame rate strategy
434 EXPECT_FALSE(ValidateFrameRate(60.0f, ANATIVEWINDOW_FRAME_RATE_EXACT, -1, ""));
435 EXPECT_FALSE(ValidateFrameRate(60.0f, ANATIVEWINDOW_FRAME_RATE_EXACT, 2, ""));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800436}
437
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800438TEST_P(SetFrameRateTest, SetOnParentActivatesTree) {
439 const auto& layerFactory = GetParam();
440
441 auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
442 if (!parent->isVisible()) {
443 // This is a hack as all the test layers except EffectLayer are not visible,
444 // but since the logic is unified in Layer, it should be fine.
445 return;
446 }
447
448 auto child = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
449 addChild(parent, child);
450
451 parent->setFrameRate(FRAME_RATE_VOTE1);
452 commitTransaction();
453
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700454 auto& history = mFlinger.mutableScheduler().mutableLayerHistory();
455 history.record(parent.get(), 0, 0, LayerHistory::LayerUpdateType::Buffer);
456 history.record(child.get(), 0, 0, LayerHistory::LayerUpdateType::Buffer);
Ady Abrahambdda8f02021-04-01 16:06:11 -0700457
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700458 const auto configs = mFlinger.mutableScheduler().refreshRateConfigs();
459 const auto summary = history.summarize(*configs, 0);
460
461 ASSERT_EQ(2u, summary.size());
462 EXPECT_EQ(FRAME_RATE_VOTE1.rate, summary[0].desiredRefreshRate);
463 EXPECT_EQ(FRAME_RATE_VOTE1.rate, summary[1].desiredRefreshRate);
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800464}
465
Ady Abrahama850c182021-08-04 13:04:37 -0700466TEST_P(SetFrameRateTest, addChildForParentWithTreeVote) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700467 EXPECT_CALL(*mFlinger.scheduler(), scheduleCommit()).Times(1);
Ady Abrahama850c182021-08-04 13:04:37 -0700468
469 const auto& layerFactory = GetParam();
470
471 const auto parent = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
472 const auto child1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
473 const auto child2 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
474 const auto childOfChild1 = mLayers.emplace_back(layerFactory->createLayer(mFlinger));
475
476 addChild(parent, child1);
477 addChild(child1, childOfChild1);
478
479 childOfChild1->setFrameRate(FRAME_RATE_VOTE1);
480 commitTransaction();
481 EXPECT_EQ(FRAME_RATE_TREE, parent->getFrameRateForLayerTree());
482 EXPECT_EQ(FRAME_RATE_TREE, child1->getFrameRateForLayerTree());
483 EXPECT_EQ(FRAME_RATE_VOTE1, childOfChild1->getFrameRateForLayerTree());
484 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
485
486 addChild(parent, child2);
487 commitTransaction();
488 EXPECT_EQ(FRAME_RATE_TREE, parent->getFrameRateForLayerTree());
489 EXPECT_EQ(FRAME_RATE_TREE, child1->getFrameRateForLayerTree());
490 EXPECT_EQ(FRAME_RATE_VOTE1, childOfChild1->getFrameRateForLayerTree());
491 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
492
493 childOfChild1->setFrameRate(FRAME_RATE_NO_VOTE);
494 commitTransaction();
495 EXPECT_EQ(FRAME_RATE_NO_VOTE, parent->getFrameRateForLayerTree());
496 EXPECT_EQ(FRAME_RATE_NO_VOTE, child1->getFrameRateForLayerTree());
497 EXPECT_EQ(FRAME_RATE_NO_VOTE, childOfChild1->getFrameRateForLayerTree());
498 EXPECT_EQ(FRAME_RATE_NO_VOTE, child2->getFrameRateForLayerTree());
499}
500
Ady Abraham60e42ea2020-03-09 19:17:31 -0700501} // namespace
502} // namespace android