1 /*
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 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wextra"
20 
21 #undef LOG_TAG
22 #define LOG_TAG "LayerHistoryTest"
23 
24 #include <Layer.h>
25 #include <com_android_graphics_surfaceflinger_flags.h>
26 #include <gmock/gmock.h>
27 #include <gtest/gtest.h>
28 #include <log/log.h>
29 
30 #include <common/test/FlagUtils.h>
31 #include "FpsOps.h"
32 #include "Scheduler/LayerHistory.h"
33 #include "Scheduler/LayerInfo.h"
34 #include "TestableScheduler.h"
35 #include "TestableSurfaceFlinger.h"
36 #include "mock/DisplayHardware/MockDisplayMode.h"
37 #include "mock/MockLayer.h"
38 #include "mock/MockSchedulerCallback.h"
39 
40 using testing::_;
41 using testing::Return;
42 using testing::ReturnRef;
43 
44 namespace android::scheduler {
45 
46 using MockLayer = android::mock::MockLayer;
47 
48 using android::mock::createDisplayMode;
49 using android::mock::createVrrDisplayMode;
50 
51 // WARNING: LEGACY TESTS FOR LEGACY FRONT END
52 // Update LayerHistoryIntegrationTest instead
53 class LayerHistoryTest : public testing::Test {
54 protected:
55     static constexpr auto PRESENT_TIME_HISTORY_SIZE = LayerInfo::HISTORY_SIZE;
56     static constexpr auto MAX_FREQUENT_LAYER_PERIOD_NS = LayerInfo::kMaxPeriodForFrequentLayerNs;
57     static constexpr auto FREQUENT_LAYER_WINDOW_SIZE = LayerInfo::kFrequentLayerWindowSize;
58     static constexpr auto PRESENT_TIME_HISTORY_DURATION = LayerInfo::HISTORY_DURATION;
59 
60     static constexpr Fps LO_FPS = 30_Hz;
61     static constexpr auto LO_FPS_PERIOD = LO_FPS.getPeriodNsecs();
62 
63     static constexpr Fps HI_FPS = 90_Hz;
64     static constexpr auto HI_FPS_PERIOD = HI_FPS.getPeriodNsecs();
65 
LayerHistoryTest()66     LayerHistoryTest() { mFlinger.resetScheduler(mScheduler); }
67 
history()68     LayerHistory& history() { return mScheduler->mutableLayerHistory(); }
history() const69     const LayerHistory& history() const { return mScheduler->mutableLayerHistory(); }
70 
summarizeLayerHistory(nsecs_t now)71     LayerHistory::Summary summarizeLayerHistory(nsecs_t now) {
72         // LayerHistory::summarize makes no guarantee of the order of the elements in the summary
73         // however, for testing only, a stable order is required, therefore we sort the list here.
74         // Any tests requiring ordered results must create layers with names.
75         auto summary = history().summarize(*mScheduler->refreshRateSelector(), now);
76         std::sort(summary.begin(), summary.end(),
77                   [](const RefreshRateSelector::LayerRequirement& lhs,
78                      const RefreshRateSelector::LayerRequirement& rhs) -> bool {
79                       return lhs.name < rhs.name;
80                   });
81         return summary;
82     }
83 
layerCount() const84     size_t layerCount() const { return mScheduler->layerHistorySize(); }
activeLayerCount() const85     size_t activeLayerCount() const NO_THREAD_SAFETY_ANALYSIS {
86         return history().mActiveLayerInfos.size();
87     }
88 
frequentLayerCount(nsecs_t now) const89     auto frequentLayerCount(nsecs_t now) const NO_THREAD_SAFETY_ANALYSIS {
90         const auto& infos = history().mActiveLayerInfos;
91         return std::count_if(infos.begin(), infos.end(), [now](const auto& pair) {
92             return pair.second.second->isFrequent(now).isFrequent;
93         });
94     }
95 
animatingLayerCount(nsecs_t now) const96     auto animatingLayerCount(nsecs_t now) const NO_THREAD_SAFETY_ANALYSIS {
97         const auto& infos = history().mActiveLayerInfos;
98         return std::count_if(infos.begin(), infos.end(), [now](const auto& pair) {
99             return pair.second.second->isAnimating(now);
100         });
101     }
102 
clearLayerHistoryCount(nsecs_t now) const103     auto clearLayerHistoryCount(nsecs_t now) const NO_THREAD_SAFETY_ANALYSIS {
104         const auto& infos = history().mActiveLayerInfos;
105         return std::count_if(infos.begin(), infos.end(), [now](const auto& pair) {
106             return pair.second.second->isFrequent(now).clearHistory;
107         });
108     }
109 
setDefaultLayerVote(Layer * layer,LayerHistory::LayerVoteType vote)110     void setDefaultLayerVote(Layer* layer,
111                              LayerHistory::LayerVoteType vote) NO_THREAD_SAFETY_ANALYSIS {
112         auto [found, layerPair] = history().findLayer(layer->getSequence());
113         if (found != LayerHistory::LayerStatus::NotFound) {
114             layerPair->second->setDefaultLayerVote(vote);
115         }
116     }
117 
createLayer()118     auto createLayer() { return sp<MockLayer>::make(mFlinger.flinger()); }
createLayer(std::string name)119     auto createLayer(std::string name) {
120         return sp<MockLayer>::make(mFlinger.flinger(), std::move(name));
121     }
createLayer(std::string name,uint32_t uid)122     auto createLayer(std::string name, uint32_t uid) {
123         return sp<MockLayer>::make(mFlinger.flinger(), std::move(name), std::move(uid));
124     }
125 
recordFramesAndExpect(const sp<MockLayer> & layer,nsecs_t & time,Fps frameRate,Fps desiredRefreshRate,int numFrames)126     void recordFramesAndExpect(const sp<MockLayer>& layer, nsecs_t& time, Fps frameRate,
127                                Fps desiredRefreshRate, int numFrames) {
128         LayerHistory::Summary summary;
129         for (int i = 0; i < numFrames; i++) {
130             history().record(layer->getSequence(), layer->getLayerProps(), time, time,
131                              LayerHistory::LayerUpdateType::Buffer);
132             time += frameRate.getPeriodNsecs();
133 
134             summary = summarizeLayerHistory(time);
135         }
136 
137         ASSERT_EQ(1, summary.size());
138         ASSERT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
139         ASSERT_EQ(desiredRefreshRate, summary[0].desiredRefreshRate);
140     }
141 
142     static constexpr auto kVrrModeId = DisplayModeId(2);
143     std::shared_ptr<RefreshRateSelector> mSelector = std::make_shared<RefreshRateSelector>(
144             makeModes(createDisplayMode(DisplayModeId(0), LO_FPS),
145                       createDisplayMode(DisplayModeId(1), HI_FPS),
146                       createVrrDisplayMode(kVrrModeId, HI_FPS,
147                                            hal::VrrConfig{.minFrameIntervalNs =
148                                                                   HI_FPS.getPeriodNsecs()})),
149             DisplayModeId(0));
150 
151     mock::SchedulerCallback mSchedulerCallback;
152     TestableSurfaceFlinger mFlinger;
153     TestableScheduler* mScheduler = new TestableScheduler(mSelector, mFlinger, mSchedulerCallback);
154 };
155 
156 namespace {
157 
158 using namespace com::android::graphics::surfaceflinger;
159 
TEST_F(LayerHistoryTest,singleLayerNoVoteDefaultCompatibility)160 TEST_F(LayerHistoryTest, singleLayerNoVoteDefaultCompatibility) {
161     const auto layer = createLayer();
162     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
163     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
164     EXPECT_CALL(*layer, getDefaultFrameRateCompatibility())
165             .WillOnce(Return(FrameRateCompatibility::NoVote));
166 
167     EXPECT_EQ(1, layerCount());
168     EXPECT_EQ(0, activeLayerCount());
169 
170     nsecs_t time = systemTime();
171 
172     // No layers returned if no layers are active.
173     EXPECT_TRUE(summarizeLayerHistory(time).empty());
174     EXPECT_EQ(0, activeLayerCount());
175 
176     history().record(layer->getSequence(), layer->getLayerProps(), 0, time,
177                      LayerHistory::LayerUpdateType::Buffer);
178     history().setDefaultFrameRateCompatibility(layer->getSequence(),
179 
180                                                layer->getDefaultFrameRateCompatibility(),
181                                                true /* contentDetectionEnabled */);
182 
183     EXPECT_TRUE(summarizeLayerHistory(time).empty());
184     EXPECT_EQ(1, activeLayerCount());
185 }
186 
TEST_F(LayerHistoryTest,singleLayerMinVoteDefaultCompatibility)187 TEST_F(LayerHistoryTest, singleLayerMinVoteDefaultCompatibility) {
188     const auto layer = createLayer();
189     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
190     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
191     EXPECT_CALL(*layer, getDefaultFrameRateCompatibility())
192             .WillOnce(Return(FrameRateCompatibility::Min));
193 
194     EXPECT_EQ(1, layerCount());
195     EXPECT_EQ(0, activeLayerCount());
196 
197     nsecs_t time = systemTime();
198 
199     EXPECT_TRUE(summarizeLayerHistory(time).empty());
200     EXPECT_EQ(0, activeLayerCount());
201 
202     history().record(layer->getSequence(), layer->getLayerProps(), 0, time,
203                      LayerHistory::LayerUpdateType::Buffer);
204     history().setDefaultFrameRateCompatibility(layer->getSequence(),
205                                                layer->getDefaultFrameRateCompatibility(),
206                                                true /* contentDetectionEnabled */);
207 
208     auto summary = summarizeLayerHistory(time);
209     ASSERT_EQ(1, summarizeLayerHistory(time).size());
210 
211     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
212     EXPECT_EQ(1, activeLayerCount());
213 }
214 
TEST_F(LayerHistoryTest,oneLayer)215 TEST_F(LayerHistoryTest, oneLayer) {
216     const auto layer = createLayer();
217     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
218     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
219 
220     // history().registerLayer(layer, LayerHistory::LayerVoteType::Max);
221 
222     EXPECT_EQ(1, layerCount());
223     EXPECT_EQ(0, activeLayerCount());
224 
225     nsecs_t time = systemTime();
226 
227     // No layers returned if no layers are active.
228     EXPECT_TRUE(summarizeLayerHistory(time).empty());
229     EXPECT_EQ(0, activeLayerCount());
230 
231     // Max returned if active layers have insufficient history.
232     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE - 1; i++) {
233         history().record(layer->getSequence(), layer->getLayerProps(), 0, time,
234                          LayerHistory::LayerUpdateType::Buffer);
235         ASSERT_EQ(1, summarizeLayerHistory(time).size());
236         EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
237         EXPECT_EQ(1, activeLayerCount());
238         time += LO_FPS_PERIOD;
239     }
240 
241     // Max is returned since we have enough history but there is no timestamp votes.
242     for (int i = 0; i < 10; i++) {
243         history().record(layer->getSequence(), layer->getLayerProps(), 0, time,
244                          LayerHistory::LayerUpdateType::Buffer);
245         ASSERT_EQ(1, summarizeLayerHistory(time).size());
246         EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
247         EXPECT_EQ(1, activeLayerCount());
248         time += LO_FPS_PERIOD;
249     }
250 }
251 
TEST_F(LayerHistoryTest,gameFrameRateOverrideMapping)252 TEST_F(LayerHistoryTest, gameFrameRateOverrideMapping) {
253     SET_FLAG_FOR_TEST(flags::game_default_frame_rate, true);
254 
255     history().updateGameDefaultFrameRateOverride(FrameRateOverride({0, 60.0f}));
256 
257     auto overridePair = history().getGameFrameRateOverride(0);
258     EXPECT_EQ(0_Hz, overridePair.first);
259     EXPECT_EQ(60_Hz, overridePair.second);
260 
261     history().updateGameModeFrameRateOverride(FrameRateOverride({0, 40.0f}));
262     history().updateGameModeFrameRateOverride(FrameRateOverride({1, 120.0f}));
263 
264     overridePair = history().getGameFrameRateOverride(0);
265     EXPECT_EQ(40_Hz, overridePair.first);
266     EXPECT_EQ(60_Hz, overridePair.second);
267 
268     overridePair = history().getGameFrameRateOverride(1);
269     EXPECT_EQ(120_Hz, overridePair.first);
270     EXPECT_EQ(0_Hz, overridePair.second);
271 
272     history().updateGameDefaultFrameRateOverride(FrameRateOverride({0, 0.0f}));
273     history().updateGameModeFrameRateOverride(FrameRateOverride({1, 0.0f}));
274 
275     overridePair = history().getGameFrameRateOverride(0);
276     EXPECT_EQ(40_Hz, overridePair.first);
277     EXPECT_EQ(0_Hz, overridePair.second);
278 
279     overridePair = history().getGameFrameRateOverride(1);
280     EXPECT_EQ(0_Hz, overridePair.first);
281     EXPECT_EQ(0_Hz, overridePair.second);
282 }
283 
TEST_F(LayerHistoryTest,oneLayerGameFrameRateOverride)284 TEST_F(LayerHistoryTest, oneLayerGameFrameRateOverride) {
285     SET_FLAG_FOR_TEST(flags::game_default_frame_rate, true);
286 
287     const uid_t uid = 0;
288     const Fps gameDefaultFrameRate = Fps::fromValue(30.0f);
289     const Fps gameModeFrameRate = Fps::fromValue(60.0f);
290     const auto layer = createLayer("GameFrameRateLayer", uid);
291     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
292     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
293     EXPECT_CALL(*layer, getOwnerUid()).WillRepeatedly(Return(uid));
294 
295     EXPECT_EQ(1, layerCount());
296     EXPECT_EQ(0, activeLayerCount());
297 
298     // update game default frame rate override
299     history().updateGameDefaultFrameRateOverride(
300             FrameRateOverride({uid, gameDefaultFrameRate.getValue()}));
301 
302     nsecs_t time = systemTime();
303     LayerHistory::Summary summary;
304     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
305         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
306                          LayerHistory::LayerUpdateType::Buffer);
307         time += gameDefaultFrameRate.getPeriodNsecs();
308 
309         summary = summarizeLayerHistory(time);
310     }
311 
312     ASSERT_EQ(1, summary.size());
313     ASSERT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summary[0].vote);
314     ASSERT_EQ(30.0_Hz, summary[0].desiredRefreshRate);
315 
316     // test against setFrameRate vote
317     const Fps setFrameRate = Fps::fromValue(120.0f);
318     EXPECT_CALL(*layer, getFrameRateForLayerTree())
319             .WillRepeatedly(
320                     Return(Layer::FrameRate(setFrameRate, Layer::FrameRateCompatibility::Default)));
321 
322     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
323         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
324                          LayerHistory::LayerUpdateType::Buffer);
325         time += setFrameRate.getPeriodNsecs();
326 
327         summary = summarizeLayerHistory(time);
328     }
329 
330     ASSERT_EQ(1, summary.size());
331     ASSERT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summary[0].vote);
332     ASSERT_EQ(120.0_Hz, summary[0].desiredRefreshRate);
333 
334     // update game mode frame rate override
335     history().updateGameModeFrameRateOverride(
336             FrameRateOverride({uid, gameModeFrameRate.getValue()}));
337 
338     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
339         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
340                          LayerHistory::LayerUpdateType::Buffer);
341         time += gameModeFrameRate.getPeriodNsecs();
342 
343         summary = summarizeLayerHistory(time);
344     }
345 
346     ASSERT_EQ(1, summary.size());
347     ASSERT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summary[0].vote);
348     ASSERT_EQ(60.0_Hz, summary[0].desiredRefreshRate);
349 }
350 
TEST_F(LayerHistoryTest,oneInvisibleLayer)351 TEST_F(LayerHistoryTest, oneInvisibleLayer) {
352     const auto layer = createLayer();
353     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
354     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
355 
356     EXPECT_EQ(1, layerCount());
357     EXPECT_EQ(0, activeLayerCount());
358 
359     nsecs_t time = systemTime();
360 
361     history().record(layer->getSequence(), layer->getLayerProps(), 0, time,
362                      LayerHistory::LayerUpdateType::Buffer);
363     auto summary = summarizeLayerHistory(time);
364     ASSERT_EQ(1, summarizeLayerHistory(time).size());
365     // Layer is still considered inactive so we expect to get Min
366     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
367     EXPECT_EQ(1, activeLayerCount());
368 
369     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(false));
370     history().record(layer->getSequence(), layer->getLayerProps(), 0, time,
371                      LayerHistory::LayerUpdateType::Buffer);
372 
373     summary = summarizeLayerHistory(time);
374     EXPECT_TRUE(summarizeLayerHistory(time).empty());
375     EXPECT_EQ(0, activeLayerCount());
376 }
377 
TEST_F(LayerHistoryTest,explicitTimestamp)378 TEST_F(LayerHistoryTest, explicitTimestamp) {
379     const auto layer = createLayer();
380     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
381     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
382 
383     EXPECT_EQ(1, layerCount());
384     EXPECT_EQ(0, activeLayerCount());
385 
386     nsecs_t time = systemTime();
387     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
388         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
389                          LayerHistory::LayerUpdateType::Buffer);
390         time += LO_FPS_PERIOD;
391     }
392 
393     ASSERT_EQ(1, summarizeLayerHistory(time).size());
394     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summarizeLayerHistory(time)[0].vote);
395     EXPECT_EQ(LO_FPS, summarizeLayerHistory(time)[0].desiredRefreshRate);
396     EXPECT_EQ(1, activeLayerCount());
397     EXPECT_EQ(1, frequentLayerCount(time));
398 }
399 
TEST_F(LayerHistoryTest,oneLayerNoVote)400 TEST_F(LayerHistoryTest, oneLayerNoVote) {
401     const auto layer = createLayer();
402     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
403     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
404 
405     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::NoVote);
406 
407     EXPECT_EQ(1, layerCount());
408     EXPECT_EQ(0, activeLayerCount());
409 
410     nsecs_t time = systemTime();
411     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
412         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
413                          LayerHistory::LayerUpdateType::Buffer);
414         time += HI_FPS_PERIOD;
415     }
416 
417     ASSERT_TRUE(summarizeLayerHistory(time).empty());
418     EXPECT_EQ(1, activeLayerCount());
419     EXPECT_EQ(1, frequentLayerCount(time));
420 
421     // layer became inactive
422     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
423     ASSERT_TRUE(summarizeLayerHistory(time).empty());
424     EXPECT_EQ(0, activeLayerCount());
425     EXPECT_EQ(0, frequentLayerCount(time));
426 }
427 
TEST_F(LayerHistoryTest,oneLayerMinVote)428 TEST_F(LayerHistoryTest, oneLayerMinVote) {
429     const auto layer = createLayer();
430     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
431     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
432 
433     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Min);
434 
435     EXPECT_EQ(1, layerCount());
436     EXPECT_EQ(0, activeLayerCount());
437 
438     nsecs_t time = systemTime();
439     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
440         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
441                          LayerHistory::LayerUpdateType::Buffer);
442         time += HI_FPS_PERIOD;
443     }
444 
445     ASSERT_EQ(1, summarizeLayerHistory(time).size());
446     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
447     EXPECT_EQ(1, activeLayerCount());
448     EXPECT_EQ(1, frequentLayerCount(time));
449 
450     // layer became inactive
451     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
452     ASSERT_TRUE(summarizeLayerHistory(time).empty());
453     EXPECT_EQ(0, activeLayerCount());
454     EXPECT_EQ(0, frequentLayerCount(time));
455 }
456 
TEST_F(LayerHistoryTest,oneLayerMaxVote)457 TEST_F(LayerHistoryTest, oneLayerMaxVote) {
458     const auto layer = createLayer();
459     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
460     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
461 
462     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Max);
463 
464     EXPECT_EQ(1, layerCount());
465     EXPECT_EQ(0, activeLayerCount());
466 
467     nsecs_t time = systemTime();
468     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
469         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
470                          LayerHistory::LayerUpdateType::Buffer);
471         time += LO_FPS_PERIOD;
472     }
473 
474     ASSERT_EQ(1, summarizeLayerHistory(time).size());
475     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
476     EXPECT_EQ(1, activeLayerCount());
477     EXPECT_EQ(1, frequentLayerCount(time));
478 
479     // layer became inactive
480     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
481     ASSERT_TRUE(summarizeLayerHistory(time).empty());
482     EXPECT_EQ(0, activeLayerCount());
483     EXPECT_EQ(0, frequentLayerCount(time));
484 }
485 
TEST_F(LayerHistoryTest,oneLayerExplicitVote)486 TEST_F(LayerHistoryTest, oneLayerExplicitVote) {
487     auto layer = createLayer();
488     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
489     EXPECT_CALL(*layer, getFrameRateForLayerTree())
490             .WillRepeatedly(
491                     Return(Layer::FrameRate(73.4_Hz, Layer::FrameRateCompatibility::Default)));
492 
493     EXPECT_EQ(1, layerCount());
494     EXPECT_EQ(0, activeLayerCount());
495 
496     nsecs_t time = systemTime();
497     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
498         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
499                          LayerHistory::LayerUpdateType::Buffer);
500         time += HI_FPS_PERIOD;
501     }
502 
503     ASSERT_EQ(1, summarizeLayerHistory(time).size());
504     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summarizeLayerHistory(time)[0].vote);
505     EXPECT_EQ(73.4_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
506     EXPECT_EQ(1, activeLayerCount());
507     EXPECT_EQ(1, frequentLayerCount(time));
508 
509     // layer became infrequent, but the vote stays
510     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Heuristic);
511     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
512     ASSERT_EQ(1, summarizeLayerHistory(time).size());
513     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summarizeLayerHistory(time)[0].vote);
514     EXPECT_EQ(73.4_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
515     EXPECT_EQ(1, activeLayerCount());
516     EXPECT_EQ(0, frequentLayerCount(time));
517 }
518 
TEST_F(LayerHistoryTest,oneLayerExplicitExactVote)519 TEST_F(LayerHistoryTest, oneLayerExplicitExactVote) {
520     auto layer = createLayer();
521     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
522     EXPECT_CALL(*layer, getFrameRateForLayerTree())
523             .WillRepeatedly(Return(
524                     Layer::FrameRate(73.4_Hz, Layer::FrameRateCompatibility::ExactOrMultiple)));
525 
526     EXPECT_EQ(1, layerCount());
527     EXPECT_EQ(0, activeLayerCount());
528 
529     nsecs_t time = systemTime();
530     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
531         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
532                          LayerHistory::LayerUpdateType::Buffer);
533         time += HI_FPS_PERIOD;
534     }
535 
536     ASSERT_EQ(1, summarizeLayerHistory(time).size());
537     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitExactOrMultiple,
538               summarizeLayerHistory(time)[0].vote);
539     EXPECT_EQ(73.4_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
540     EXPECT_EQ(1, activeLayerCount());
541     EXPECT_EQ(1, frequentLayerCount(time));
542 
543     // layer became infrequent, but the vote stays
544     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Heuristic);
545     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
546     ASSERT_EQ(1, summarizeLayerHistory(time).size());
547     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitExactOrMultiple,
548               summarizeLayerHistory(time)[0].vote);
549     EXPECT_EQ(73.4_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
550     EXPECT_EQ(1, activeLayerCount());
551     EXPECT_EQ(0, frequentLayerCount(time));
552 }
553 
TEST_F(LayerHistoryTest,oneLayerExplicitGte_vrr)554 TEST_F(LayerHistoryTest, oneLayerExplicitGte_vrr) {
555     // Set the test to be on a vrr mode.
556     SET_FLAG_FOR_TEST(flags::vrr_config, true);
557     mSelector->setActiveMode(kVrrModeId, HI_FPS);
558 
559     auto layer = createLayer();
560     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
561     EXPECT_CALL(*layer, getFrameRateForLayerTree())
562             .WillRepeatedly(Return(Layer::FrameRate(33_Hz, Layer::FrameRateCompatibility::Gte,
563                                                     Seamlessness::OnlySeamless,
564                                                     FrameRateCategory::Default)));
565 
566     EXPECT_EQ(1, layerCount());
567     EXPECT_EQ(0, activeLayerCount());
568 
569     nsecs_t time = systemTime();
570     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
571         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
572                          LayerHistory::LayerUpdateType::Buffer);
573         time += HI_FPS_PERIOD;
574     }
575 
576     ASSERT_EQ(1, summarizeLayerHistory(time).size());
577     EXPECT_EQ(1, activeLayerCount());
578     EXPECT_EQ(1, frequentLayerCount(time));
579     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitGte, summarizeLayerHistory(time)[0].vote);
580     EXPECT_EQ(33_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
581     EXPECT_EQ(FrameRateCategory::Default, summarizeLayerHistory(time)[0].frameRateCategory);
582 
583     // layer became inactive, but the vote stays
584     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Heuristic);
585     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
586     ASSERT_EQ(1, summarizeLayerHistory(time).size());
587     EXPECT_EQ(1, activeLayerCount());
588     EXPECT_EQ(0, frequentLayerCount(time));
589     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitGte, summarizeLayerHistory(time)[0].vote);
590     EXPECT_EQ(33_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
591     EXPECT_EQ(FrameRateCategory::Default, summarizeLayerHistory(time)[0].frameRateCategory);
592 }
593 
594 // Test for MRR device with VRR features enabled.
TEST_F(LayerHistoryTest,oneLayerExplicitGte_nonVrr)595 TEST_F(LayerHistoryTest, oneLayerExplicitGte_nonVrr) {
596     SET_FLAG_FOR_TEST(flags::frame_rate_category_mrr, true);
597     // The vrr_config flag is explicitly not set false because this test for an MRR device
598     // should still work in a VRR-capable world.
599 
600     auto layer = createLayer();
601     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
602     EXPECT_CALL(*layer, getFrameRateForLayerTree())
603             .WillRepeatedly(Return(Layer::FrameRate(33_Hz, Layer::FrameRateCompatibility::Gte,
604                                                     Seamlessness::OnlySeamless,
605                                                     FrameRateCategory::Default)));
606 
607     EXPECT_EQ(1, layerCount());
608     EXPECT_EQ(0, activeLayerCount());
609 
610     nsecs_t time = systemTime();
611     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
612         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
613                          LayerHistory::LayerUpdateType::Buffer);
614         time += HI_FPS_PERIOD;
615     }
616 
617     ASSERT_EQ(1, summarizeLayerHistory(time).size());
618     EXPECT_EQ(1, activeLayerCount());
619     EXPECT_EQ(1, frequentLayerCount(time));
620     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
621     EXPECT_EQ(0_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
622     EXPECT_EQ(FrameRateCategory::Default, summarizeLayerHistory(time)[0].frameRateCategory);
623 
624     // layer became infrequent, but the vote stays
625     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Heuristic);
626     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
627     ASSERT_EQ(1, summarizeLayerHistory(time).size());
628     EXPECT_EQ(1, activeLayerCount());
629     EXPECT_EQ(0, frequentLayerCount(time));
630     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
631     EXPECT_EQ(0_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
632     EXPECT_EQ(FrameRateCategory::Default, summarizeLayerHistory(time)[0].frameRateCategory);
633 }
634 
TEST_F(LayerHistoryTest,oneLayerExplicitVoteWithCategory_vrrFeatureOff)635 TEST_F(LayerHistoryTest, oneLayerExplicitVoteWithCategory_vrrFeatureOff) {
636     SET_FLAG_FOR_TEST(flags::frame_rate_category_mrr, false);
637 
638     auto layer = createLayer();
639     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
640     EXPECT_CALL(*layer, getFrameRateForLayerTree())
641             .WillRepeatedly(
642                     Return(Layer::FrameRate(73.4_Hz, Layer::FrameRateCompatibility::Default,
643                                             Seamlessness::OnlySeamless, FrameRateCategory::High)));
644 
645     // Set default to Min so it is obvious that the vote reset triggered.
646     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Min);
647 
648     EXPECT_EQ(1, layerCount());
649     EXPECT_EQ(0, activeLayerCount());
650 
651     nsecs_t time = systemTime();
652     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
653         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
654                          LayerHistory::LayerUpdateType::Buffer);
655         time += HI_FPS_PERIOD;
656     }
657 
658     // There is only 1 LayerRequirement due to the disabled flag frame_rate_category_mrr.
659     ASSERT_EQ(1, summarizeLayerHistory(time).size());
660     EXPECT_EQ(1, activeLayerCount());
661     EXPECT_EQ(1, frequentLayerCount(time));
662     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
663     EXPECT_EQ(0_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
664     EXPECT_EQ(FrameRateCategory::Default, summarizeLayerHistory(time)[0].frameRateCategory);
665 }
666 
TEST_F(LayerHistoryTest,oneLayerExplicitCategory)667 TEST_F(LayerHistoryTest, oneLayerExplicitCategory) {
668     SET_FLAG_FOR_TEST(flags::frame_rate_category_mrr, true);
669 
670     auto layer = createLayer();
671     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
672     EXPECT_CALL(*layer, getFrameRateForLayerTree())
673             .WillRepeatedly(
674                     Return(Layer::FrameRate(0_Hz, Layer::FrameRateCompatibility::Default,
675                                             Seamlessness::OnlySeamless, FrameRateCategory::High)));
676 
677     EXPECT_EQ(1, layerCount());
678     EXPECT_EQ(0, activeLayerCount());
679 
680     nsecs_t time = systemTime();
681     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
682         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
683                          LayerHistory::LayerUpdateType::Buffer);
684         time += HI_FPS_PERIOD;
685     }
686 
687     ASSERT_EQ(1, summarizeLayerHistory(time).size());
688     EXPECT_EQ(1, activeLayerCount());
689     EXPECT_EQ(1, frequentLayerCount(time));
690     // First LayerRequirement is the frame rate specification
691     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitCategory, summarizeLayerHistory(time)[0].vote);
692     EXPECT_EQ(0_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
693     EXPECT_EQ(FrameRateCategory::High, summarizeLayerHistory(time)[0].frameRateCategory);
694 
695     // layer became infrequent, but the vote stays
696     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Heuristic);
697     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
698     ASSERT_EQ(1, summarizeLayerHistory(time).size());
699     EXPECT_EQ(1, activeLayerCount());
700     EXPECT_EQ(0, frequentLayerCount(time));
701     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitCategory, summarizeLayerHistory(time)[0].vote);
702     EXPECT_EQ(0_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
703     EXPECT_EQ(FrameRateCategory::High, summarizeLayerHistory(time)[0].frameRateCategory);
704 }
705 
706 // This test case should be the same as oneLayerNoVote except instead of layer vote is NoVote,
707 // the category is NoPreference.
TEST_F(LayerHistoryTest,oneLayerCategoryNoPreference)708 TEST_F(LayerHistoryTest, oneLayerCategoryNoPreference) {
709     SET_FLAG_FOR_TEST(flags::frame_rate_category_mrr, true);
710 
711     auto layer = createLayer();
712     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
713     EXPECT_CALL(*layer, getFrameRateForLayerTree())
714             .WillRepeatedly(Return(Layer::FrameRate(0_Hz, Layer::FrameRateCompatibility::Default,
715                                                     Seamlessness::OnlySeamless,
716                                                     FrameRateCategory::NoPreference)));
717 
718     EXPECT_EQ(1, layerCount());
719     EXPECT_EQ(0, activeLayerCount());
720 
721     nsecs_t time = systemTime();
722     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
723         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
724                          LayerHistory::LayerUpdateType::Buffer);
725         time += HI_FPS_PERIOD;
726     }
727 
728     EXPECT_EQ(1, summarizeLayerHistory(time).size());
729     EXPECT_EQ(1, activeLayerCount());
730     EXPECT_EQ(1, frequentLayerCount(time));
731 
732     // layer became infrequent
733     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
734     EXPECT_EQ(1, summarizeLayerHistory(time).size());
735     EXPECT_EQ(1, activeLayerCount());
736     EXPECT_EQ(0, frequentLayerCount(time));
737 }
738 
TEST_F(LayerHistoryTest,oneLayerExplicitVoteWithCategory)739 TEST_F(LayerHistoryTest, oneLayerExplicitVoteWithCategory) {
740     SET_FLAG_FOR_TEST(flags::frame_rate_category_mrr, true);
741 
742     auto layer = createLayer();
743     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
744     EXPECT_CALL(*layer, getFrameRateForLayerTree())
745             .WillRepeatedly(
746                     Return(Layer::FrameRate(73.4_Hz, Layer::FrameRateCompatibility::Default,
747                                             Seamlessness::OnlySeamless, FrameRateCategory::High)));
748 
749     EXPECT_EQ(1, layerCount());
750     EXPECT_EQ(0, activeLayerCount());
751 
752     nsecs_t time = systemTime();
753     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
754         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
755                          LayerHistory::LayerUpdateType::Buffer);
756         time += HI_FPS_PERIOD;
757     }
758 
759     // There are 2 LayerRequirement's due to the frame rate category.
760     ASSERT_EQ(2, summarizeLayerHistory(time).size());
761     EXPECT_EQ(1, activeLayerCount());
762     EXPECT_EQ(1, frequentLayerCount(time));
763     // First LayerRequirement is the layer's category specification
764     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitCategory, summarizeLayerHistory(time)[0].vote);
765     EXPECT_EQ(0_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
766     EXPECT_EQ(FrameRateCategory::High, summarizeLayerHistory(time)[0].frameRateCategory);
767 
768     // Second LayerRequirement is the frame rate specification
769     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summarizeLayerHistory(time)[1].vote);
770     EXPECT_EQ(73.4_Hz, summarizeLayerHistory(time)[1].desiredRefreshRate);
771     EXPECT_EQ(FrameRateCategory::Default, summarizeLayerHistory(time)[1].frameRateCategory);
772 
773     // layer became infrequent, but the vote stays
774     setDefaultLayerVote(layer.get(), LayerHistory::LayerVoteType::Heuristic);
775     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
776     ASSERT_EQ(2, summarizeLayerHistory(time).size());
777     EXPECT_EQ(1, activeLayerCount());
778     EXPECT_EQ(0, frequentLayerCount(time));
779     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitCategory, summarizeLayerHistory(time)[0].vote);
780     EXPECT_EQ(0_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
781     EXPECT_EQ(FrameRateCategory::High, summarizeLayerHistory(time)[0].frameRateCategory);
782 }
783 
TEST_F(LayerHistoryTest,oneLayerExplicitVoteWithCategoryNotVisibleDoesNotVote)784 TEST_F(LayerHistoryTest, oneLayerExplicitVoteWithCategoryNotVisibleDoesNotVote) {
785     SET_FLAG_FOR_TEST(flags::misc1, true);
786 
787     auto layer = createLayer();
788     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(false));
789     EXPECT_CALL(*layer, getFrameRateForLayerTree())
790             .WillRepeatedly(
791                     Return(Layer::FrameRate(12.34_Hz, Layer::FrameRateCompatibility::Default,
792                                             Seamlessness::OnlySeamless, FrameRateCategory::High)));
793 
794     EXPECT_EQ(1, layerCount());
795     EXPECT_EQ(0, activeLayerCount());
796 
797     nsecs_t time = systemTime();
798     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
799         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
800                          LayerHistory::LayerUpdateType::Buffer);
801         time += HI_FPS_PERIOD;
802     }
803 
804     // Layer is not visible, so the layer is moved to inactive, infrequent, and it will not have
805     // votes to consider for refresh rate selection.
806     ASSERT_EQ(0, summarizeLayerHistory(time).size());
807     EXPECT_EQ(0, activeLayerCount());
808     EXPECT_EQ(0, frequentLayerCount(time));
809 }
810 
TEST_F(LayerHistoryTest,multipleLayers)811 TEST_F(LayerHistoryTest, multipleLayers) {
812     auto layer1 = createLayer("A");
813     auto layer2 = createLayer("B");
814     auto layer3 = createLayer("C");
815 
816     EXPECT_CALL(*layer1, isVisible()).WillRepeatedly(Return(true));
817     EXPECT_CALL(*layer1, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
818 
819     EXPECT_CALL(*layer2, isVisible()).WillRepeatedly(Return(true));
820     EXPECT_CALL(*layer2, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
821 
822     EXPECT_CALL(*layer3, isVisible()).WillRepeatedly(Return(true));
823     EXPECT_CALL(*layer3, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
824 
825     nsecs_t time = systemTime();
826 
827     EXPECT_EQ(3, layerCount());
828     EXPECT_EQ(0, activeLayerCount());
829     EXPECT_EQ(0, frequentLayerCount(time));
830 
831     LayerHistory::Summary summary;
832 
833     // layer1 is active but infrequent.
834     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
835         history().record(layer1->getSequence(), layer1->getLayerProps(), time, time,
836                          LayerHistory::LayerUpdateType::Buffer);
837         time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
838         summary = summarizeLayerHistory(time);
839     }
840 
841     ASSERT_EQ(1, summary.size());
842     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summary[0].vote);
843     EXPECT_EQ(1, activeLayerCount());
844     EXPECT_EQ(0, frequentLayerCount(time));
845 
846     // layer2 is frequent and has high refresh rate.
847     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
848         history().record(layer2->getSequence(), layer2->getLayerProps(), time, time,
849                          LayerHistory::LayerUpdateType::Buffer);
850         time += HI_FPS_PERIOD;
851         summary = summarizeLayerHistory(time);
852     }
853 
854     // layer1 is still active but infrequent.
855     history().record(layer1->getSequence(), layer1->getLayerProps(), time, time,
856                      LayerHistory::LayerUpdateType::Buffer);
857 
858     ASSERT_EQ(2, summary.size());
859     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summary[0].vote);
860     ASSERT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[1].vote);
861     EXPECT_EQ(HI_FPS, summarizeLayerHistory(time)[1].desiredRefreshRate);
862 
863     EXPECT_EQ(2, activeLayerCount());
864     EXPECT_EQ(1, frequentLayerCount(time));
865 
866     // layer1 is no longer active.
867     // layer2 is frequent and has low refresh rate.
868     for (int i = 0; i < 2 * PRESENT_TIME_HISTORY_SIZE; i++) {
869         history().record(layer2->getSequence(), layer2->getLayerProps(), time, time,
870                          LayerHistory::LayerUpdateType::Buffer);
871         time += LO_FPS_PERIOD;
872         summary = summarizeLayerHistory(time);
873     }
874 
875     ASSERT_EQ(1, summary.size());
876     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
877     EXPECT_EQ(LO_FPS, summary[0].desiredRefreshRate);
878     EXPECT_EQ(1, activeLayerCount());
879     EXPECT_EQ(1, frequentLayerCount(time));
880 
881     // layer2 still has low refresh rate.
882     // layer3 has high refresh rate but not enough history.
883     constexpr int RATIO = LO_FPS_PERIOD / HI_FPS_PERIOD;
884     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE - 1; i++) {
885         if (i % RATIO == 0) {
886             history().record(layer2->getSequence(), layer2->getLayerProps(), time, time,
887                              LayerHistory::LayerUpdateType::Buffer);
888         }
889 
890         history().record(layer3->getSequence(), layer3->getLayerProps(), time, time,
891                          LayerHistory::LayerUpdateType::Buffer);
892         time += HI_FPS_PERIOD;
893         summary = summarizeLayerHistory(time);
894     }
895 
896     ASSERT_EQ(2, summary.size());
897     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
898     EXPECT_EQ(LO_FPS, summary[0].desiredRefreshRate);
899     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summary[1].vote);
900     EXPECT_EQ(2, activeLayerCount());
901     EXPECT_EQ(2, frequentLayerCount(time));
902 
903     // layer3 becomes recently active.
904     history().record(layer3->getSequence(), layer3->getLayerProps(), time, time,
905                      LayerHistory::LayerUpdateType::Buffer);
906     summary = summarizeLayerHistory(time);
907     ASSERT_EQ(2, summary.size());
908     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
909     EXPECT_EQ(LO_FPS, summary[0].desiredRefreshRate);
910     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[1].vote);
911     EXPECT_EQ(HI_FPS, summary[1].desiredRefreshRate);
912     EXPECT_EQ(2, activeLayerCount());
913     EXPECT_EQ(2, frequentLayerCount(time));
914 
915     // layer1 expires.
916     layer1.clear();
917     summary = summarizeLayerHistory(time);
918     ASSERT_EQ(2, summary.size());
919     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
920     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
921     EXPECT_EQ(LO_FPS, summary[0].desiredRefreshRate);
922     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[1].vote);
923     EXPECT_EQ(HI_FPS, summary[1].desiredRefreshRate);
924     EXPECT_EQ(2, layerCount());
925     EXPECT_EQ(2, activeLayerCount());
926     EXPECT_EQ(2, frequentLayerCount(time));
927 
928     // layer2 still has low refresh rate.
929     // layer3 becomes inactive.
930     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
931         history().record(layer2->getSequence(), layer2->getLayerProps(), time, time,
932                          LayerHistory::LayerUpdateType::Buffer);
933         time += LO_FPS_PERIOD;
934         summary = summarizeLayerHistory(time);
935     }
936 
937     ASSERT_EQ(1, summary.size());
938     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
939     EXPECT_EQ(LO_FPS, summary[0].desiredRefreshRate);
940     EXPECT_EQ(1, activeLayerCount());
941     EXPECT_EQ(1, frequentLayerCount(time));
942 
943     // layer2 expires.
944     layer2.clear();
945     summary = summarizeLayerHistory(time);
946     EXPECT_TRUE(summary.empty());
947     EXPECT_EQ(1, layerCount());
948     EXPECT_EQ(0, activeLayerCount());
949     EXPECT_EQ(0, frequentLayerCount(time));
950 
951     // layer3 becomes active and has high refresh rate.
952     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE + FREQUENT_LAYER_WINDOW_SIZE + 1; i++) {
953         history().record(layer3->getSequence(), layer3->getLayerProps(), time, time,
954                          LayerHistory::LayerUpdateType::Buffer);
955         time += HI_FPS_PERIOD;
956         summary = summarizeLayerHistory(time);
957     }
958 
959     ASSERT_EQ(1, summary.size());
960     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
961     EXPECT_EQ(HI_FPS, summary[0].desiredRefreshRate);
962     EXPECT_EQ(1, layerCount());
963     EXPECT_EQ(1, activeLayerCount());
964     EXPECT_EQ(1, frequentLayerCount(time));
965 
966     // layer3 expires.
967     layer3.clear();
968     summary = summarizeLayerHistory(time);
969     EXPECT_TRUE(summary.empty());
970     EXPECT_EQ(0, layerCount());
971     EXPECT_EQ(0, activeLayerCount());
972     EXPECT_EQ(0, frequentLayerCount(time));
973 }
974 
TEST_F(LayerHistoryTest,inactiveLayers)975 TEST_F(LayerHistoryTest, inactiveLayers) {
976     auto layer = createLayer();
977 
978     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
979     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
980 
981     nsecs_t time = systemTime();
982 
983     // the very first updates makes the layer frequent
984     for (int i = 0; i < FREQUENT_LAYER_WINDOW_SIZE - 1; i++) {
985         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
986                          LayerHistory::LayerUpdateType::Buffer);
987         time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
988 
989         EXPECT_EQ(1, layerCount());
990         ASSERT_EQ(1, summarizeLayerHistory(time).size());
991         EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
992         EXPECT_EQ(1, activeLayerCount());
993         EXPECT_EQ(1, frequentLayerCount(time));
994     }
995 
996     // the next update with the MAX_FREQUENT_LAYER_PERIOD_NS will get us to infrequent
997     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
998                      LayerHistory::LayerUpdateType::Buffer);
999     time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
1000 
1001     EXPECT_EQ(1, layerCount());
1002     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1003     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
1004     EXPECT_EQ(1, activeLayerCount());
1005     EXPECT_EQ(0, frequentLayerCount(time));
1006 
1007     // advance the time for the previous frame to be inactive
1008     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
1009 
1010     // Now even if we post a quick few frame we should stay infrequent
1011     for (int i = 0; i < FREQUENT_LAYER_WINDOW_SIZE - 1; i++) {
1012         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1013                          LayerHistory::LayerUpdateType::Buffer);
1014         time += HI_FPS_PERIOD;
1015 
1016         EXPECT_EQ(1, layerCount());
1017         ASSERT_EQ(1, summarizeLayerHistory(time).size());
1018         EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
1019         EXPECT_EQ(1, activeLayerCount());
1020         EXPECT_EQ(0, frequentLayerCount(time));
1021     }
1022 
1023     // More quick frames will get us to frequent again
1024     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1025                      LayerHistory::LayerUpdateType::Buffer);
1026     time += HI_FPS_PERIOD;
1027 
1028     EXPECT_EQ(1, layerCount());
1029     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1030     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1031     EXPECT_EQ(1, activeLayerCount());
1032     EXPECT_EQ(1, frequentLayerCount(time));
1033 }
1034 
TEST_F(LayerHistoryTest,invisibleExplicitLayer)1035 TEST_F(LayerHistoryTest, invisibleExplicitLayer) {
1036     SET_FLAG_FOR_TEST(flags::misc1, false);
1037 
1038     auto explicitVisiblelayer = createLayer();
1039     auto explicitInvisiblelayer = createLayer();
1040 
1041     EXPECT_CALL(*explicitVisiblelayer, isVisible()).WillRepeatedly(Return(true));
1042     EXPECT_CALL(*explicitVisiblelayer, getFrameRateForLayerTree())
1043             .WillRepeatedly(Return(
1044                     Layer::FrameRate(60_Hz, Layer::FrameRateCompatibility::ExactOrMultiple)));
1045 
1046     EXPECT_CALL(*explicitInvisiblelayer, isVisible()).WillRepeatedly(Return(false));
1047     EXPECT_CALL(*explicitInvisiblelayer, getFrameRateForLayerTree())
1048             .WillRepeatedly(Return(
1049                     Layer::FrameRate(90_Hz, Layer::FrameRateCompatibility::ExactOrMultiple)));
1050 
1051     nsecs_t time = systemTime();
1052 
1053     // Post a buffer to the layers to make them active
1054     history().record(explicitVisiblelayer->getSequence(), explicitVisiblelayer->getLayerProps(),
1055                      time, time, LayerHistory::LayerUpdateType::Buffer);
1056     history().record(explicitInvisiblelayer->getSequence(), explicitInvisiblelayer->getLayerProps(),
1057                      time, time, LayerHistory::LayerUpdateType::Buffer);
1058 
1059     EXPECT_EQ(2, layerCount());
1060     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1061     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitExactOrMultiple,
1062               summarizeLayerHistory(time)[0].vote);
1063     EXPECT_EQ(60_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
1064     EXPECT_EQ(2, activeLayerCount());
1065     EXPECT_EQ(2, frequentLayerCount(time));
1066 }
1067 
TEST_F(LayerHistoryTest,invisibleExplicitLayerDoesNotVote)1068 TEST_F(LayerHistoryTest, invisibleExplicitLayerDoesNotVote) {
1069     SET_FLAG_FOR_TEST(flags::misc1, true);
1070 
1071     auto explicitVisiblelayer = createLayer();
1072     auto explicitInvisiblelayer = createLayer();
1073 
1074     EXPECT_CALL(*explicitVisiblelayer, isVisible()).WillRepeatedly(Return(true));
1075     EXPECT_CALL(*explicitVisiblelayer, getFrameRateForLayerTree())
1076             .WillRepeatedly(Return(
1077                     Layer::FrameRate(60_Hz, Layer::FrameRateCompatibility::ExactOrMultiple)));
1078 
1079     EXPECT_CALL(*explicitInvisiblelayer, isVisible()).WillRepeatedly(Return(false));
1080     EXPECT_CALL(*explicitInvisiblelayer, getFrameRateForLayerTree())
1081             .WillRepeatedly(Return(
1082                     Layer::FrameRate(90_Hz, Layer::FrameRateCompatibility::ExactOrMultiple)));
1083 
1084     nsecs_t time = systemTime();
1085 
1086     // Post a buffer to the layers to make them active
1087     history().record(explicitVisiblelayer->getSequence(), explicitVisiblelayer->getLayerProps(),
1088                      time, time, LayerHistory::LayerUpdateType::Buffer);
1089     history().record(explicitInvisiblelayer->getSequence(), explicitInvisiblelayer->getLayerProps(),
1090                      time, time, LayerHistory::LayerUpdateType::Buffer);
1091 
1092     EXPECT_EQ(2, layerCount());
1093     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1094     EXPECT_EQ(LayerHistory::LayerVoteType::ExplicitExactOrMultiple,
1095               summarizeLayerHistory(time)[0].vote);
1096     EXPECT_EQ(60_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
1097     EXPECT_EQ(1, activeLayerCount());
1098     EXPECT_EQ(1, frequentLayerCount(time));
1099 }
1100 
TEST_F(LayerHistoryTest,infrequentAnimatingLayer)1101 TEST_F(LayerHistoryTest, infrequentAnimatingLayer) {
1102     auto layer = createLayer();
1103 
1104     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1105     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1106 
1107     nsecs_t time = systemTime();
1108 
1109     EXPECT_EQ(1, layerCount());
1110     EXPECT_EQ(0, activeLayerCount());
1111     EXPECT_EQ(0, frequentLayerCount(time));
1112     EXPECT_EQ(0, animatingLayerCount(time));
1113 
1114     // layer is active but infrequent.
1115     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
1116         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1117                          LayerHistory::LayerUpdateType::Buffer);
1118         time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
1119     }
1120 
1121     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1122     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
1123     EXPECT_EQ(1, activeLayerCount());
1124     EXPECT_EQ(0, frequentLayerCount(time));
1125     EXPECT_EQ(0, animatingLayerCount(time));
1126 
1127     // another update with the same cadence keep in infrequent
1128     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1129                      LayerHistory::LayerUpdateType::Buffer);
1130     time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
1131 
1132     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1133     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
1134     EXPECT_EQ(1, activeLayerCount());
1135     EXPECT_EQ(0, frequentLayerCount(time));
1136     EXPECT_EQ(0, animatingLayerCount(time));
1137 
1138     // an update as animation will immediately vote for Max
1139     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1140                      LayerHistory::LayerUpdateType::AnimationTX);
1141     time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
1142 
1143     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1144     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1145     EXPECT_EQ(1, activeLayerCount());
1146     EXPECT_EQ(0, frequentLayerCount(time));
1147     EXPECT_EQ(1, animatingLayerCount(time));
1148 }
1149 
TEST_F(LayerHistoryTest,frontBufferedLayerVotesMax)1150 TEST_F(LayerHistoryTest, frontBufferedLayerVotesMax) {
1151     SET_FLAG_FOR_TEST(flags::vrr_config, true);
1152     auto layer = createLayer();
1153 
1154     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1155     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1156     EXPECT_CALL(*layer, isFrontBuffered()).WillRepeatedly(Return(true));
1157 
1158     nsecs_t time = systemTime();
1159 
1160     EXPECT_EQ(1, layerCount());
1161     EXPECT_EQ(0, activeLayerCount());
1162     EXPECT_EQ(0, frequentLayerCount(time));
1163     EXPECT_EQ(0, animatingLayerCount(time));
1164 
1165     // layer is active but infrequent.
1166     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
1167         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1168                          LayerHistory::LayerUpdateType::Buffer);
1169         time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
1170     }
1171 
1172     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1173     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1174     EXPECT_EQ(1, activeLayerCount());
1175     EXPECT_EQ(0, frequentLayerCount(time));
1176     EXPECT_EQ(0, animatingLayerCount(time));
1177 
1178     // Layer still active due to front buffering, but it's infrequent.
1179     time += MAX_ACTIVE_LAYER_PERIOD_NS.count();
1180     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1181     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1182     EXPECT_EQ(1, activeLayerCount());
1183     EXPECT_EQ(0, frequentLayerCount(time));
1184     EXPECT_EQ(0, animatingLayerCount(time));
1185 }
1186 
TEST_F(LayerHistoryTest,frequentLayerBecomingInfrequentAndBack)1187 TEST_F(LayerHistoryTest, frequentLayerBecomingInfrequentAndBack) {
1188     auto layer = createLayer();
1189 
1190     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1191     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1192 
1193     nsecs_t time = systemTime();
1194 
1195     EXPECT_EQ(1, layerCount());
1196     EXPECT_EQ(0, activeLayerCount());
1197     EXPECT_EQ(0, frequentLayerCount(time));
1198     EXPECT_EQ(0, animatingLayerCount(time));
1199 
1200     // Fill up the window with frequent updates
1201     for (int i = 0; i < FREQUENT_LAYER_WINDOW_SIZE; i++) {
1202         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1203                          LayerHistory::LayerUpdateType::Buffer);
1204         time += (60_Hz).getPeriodNsecs();
1205 
1206         EXPECT_EQ(1, layerCount());
1207         ASSERT_EQ(1, summarizeLayerHistory(time).size());
1208         EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1209         EXPECT_EQ(1, activeLayerCount());
1210         EXPECT_EQ(1, frequentLayerCount(time));
1211     }
1212 
1213     // posting a buffer after long inactivity should retain the layer as active
1214     time += std::chrono::nanoseconds(3s).count();
1215     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1216                      LayerHistory::LayerUpdateType::Buffer);
1217     EXPECT_EQ(0, clearLayerHistoryCount(time));
1218     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1219     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summarizeLayerHistory(time)[0].vote);
1220     EXPECT_EQ(60_Hz, summarizeLayerHistory(time)[0].desiredRefreshRate);
1221     EXPECT_EQ(1, activeLayerCount());
1222     EXPECT_EQ(1, frequentLayerCount(time));
1223     EXPECT_EQ(0, animatingLayerCount(time));
1224 
1225     // posting more infrequent buffer should make the layer infrequent
1226     time += (MAX_FREQUENT_LAYER_PERIOD_NS + 1ms).count();
1227     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1228                      LayerHistory::LayerUpdateType::Buffer);
1229     time += (MAX_FREQUENT_LAYER_PERIOD_NS + 1ms).count();
1230     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1231                      LayerHistory::LayerUpdateType::Buffer);
1232     EXPECT_EQ(0, clearLayerHistoryCount(time));
1233     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1234     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
1235     EXPECT_EQ(1, activeLayerCount());
1236     EXPECT_EQ(0, frequentLayerCount(time));
1237     EXPECT_EQ(0, animatingLayerCount(time));
1238 
1239     // posting another buffer should keep the layer infrequent
1240     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1241                      LayerHistory::LayerUpdateType::Buffer);
1242     EXPECT_EQ(0, clearLayerHistoryCount(time));
1243     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1244     EXPECT_EQ(LayerHistory::LayerVoteType::Min, summarizeLayerHistory(time)[0].vote);
1245     EXPECT_EQ(1, activeLayerCount());
1246     EXPECT_EQ(0, frequentLayerCount(time));
1247     EXPECT_EQ(0, animatingLayerCount(time));
1248 
1249     // posting more buffers would mean starting of an animation, so making the layer frequent
1250     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1251                      LayerHistory::LayerUpdateType::Buffer);
1252     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1253                      LayerHistory::LayerUpdateType::Buffer);
1254     EXPECT_EQ(1, clearLayerHistoryCount(time));
1255     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1256     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1257     EXPECT_EQ(1, activeLayerCount());
1258     EXPECT_EQ(1, frequentLayerCount(time));
1259     EXPECT_EQ(0, animatingLayerCount(time));
1260 
1261     // posting a buffer after long inactivity should retain the layer as active
1262     time += std::chrono::nanoseconds(3s).count();
1263     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1264                      LayerHistory::LayerUpdateType::Buffer);
1265     EXPECT_EQ(0, clearLayerHistoryCount(time));
1266     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1267     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1268     EXPECT_EQ(1, activeLayerCount());
1269     EXPECT_EQ(1, frequentLayerCount(time));
1270     EXPECT_EQ(0, animatingLayerCount(time));
1271 
1272     // posting another buffer should keep the layer frequent
1273     time += (60_Hz).getPeriodNsecs();
1274     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1275                      LayerHistory::LayerUpdateType::Buffer);
1276     EXPECT_EQ(0, clearLayerHistoryCount(time));
1277     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1278     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1279     EXPECT_EQ(1, activeLayerCount());
1280     EXPECT_EQ(1, frequentLayerCount(time));
1281     EXPECT_EQ(0, animatingLayerCount(time));
1282 }
1283 
TEST_F(LayerHistoryTest,inconclusiveLayerBecomingFrequent)1284 TEST_F(LayerHistoryTest, inconclusiveLayerBecomingFrequent) {
1285     auto layer = createLayer();
1286 
1287     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1288     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1289 
1290     nsecs_t time = systemTime();
1291 
1292     EXPECT_EQ(1, layerCount());
1293     EXPECT_EQ(0, activeLayerCount());
1294     EXPECT_EQ(0, frequentLayerCount(time));
1295     EXPECT_EQ(0, animatingLayerCount(time));
1296 
1297     // Fill up the window with frequent updates
1298     for (int i = 0; i < FREQUENT_LAYER_WINDOW_SIZE; i++) {
1299         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1300                          LayerHistory::LayerUpdateType::Buffer);
1301         time += (60_Hz).getPeriodNsecs();
1302 
1303         EXPECT_EQ(1, layerCount());
1304         ASSERT_EQ(1, summarizeLayerHistory(time).size());
1305         EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1306         EXPECT_EQ(1, activeLayerCount());
1307         EXPECT_EQ(1, frequentLayerCount(time));
1308     }
1309 
1310     // posting infrequent buffers after long inactivity should make the layer
1311     // inconclusive but frequent.
1312     time += std::chrono::nanoseconds(3s).count();
1313     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1314                      LayerHistory::LayerUpdateType::Buffer);
1315     time += (MAX_FREQUENT_LAYER_PERIOD_NS + 1ms).count();
1316     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1317                      LayerHistory::LayerUpdateType::Buffer);
1318     EXPECT_EQ(0, clearLayerHistoryCount(time));
1319     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1320     EXPECT_EQ(LayerHistory::LayerVoteType::Heuristic, summarizeLayerHistory(time)[0].vote);
1321     EXPECT_EQ(1, activeLayerCount());
1322     EXPECT_EQ(1, frequentLayerCount(time));
1323     EXPECT_EQ(0, animatingLayerCount(time));
1324 
1325     // posting more buffers should make the layer frequent and switch the refresh rate to max
1326     // by clearing the history
1327     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1328                      LayerHistory::LayerUpdateType::Buffer);
1329     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1330                      LayerHistory::LayerUpdateType::Buffer);
1331     history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1332                      LayerHistory::LayerUpdateType::Buffer);
1333     EXPECT_EQ(1, clearLayerHistoryCount(time));
1334     ASSERT_EQ(1, summarizeLayerHistory(time).size());
1335     EXPECT_EQ(LayerHistory::LayerVoteType::Max, summarizeLayerHistory(time)[0].vote);
1336     EXPECT_EQ(1, activeLayerCount());
1337     EXPECT_EQ(1, frequentLayerCount(time));
1338     EXPECT_EQ(0, animatingLayerCount(time));
1339 }
1340 
TEST_F(LayerHistoryTest,getFramerate)1341 TEST_F(LayerHistoryTest, getFramerate) {
1342     auto layer = createLayer();
1343 
1344     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1345     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1346 
1347     nsecs_t time = systemTime();
1348 
1349     EXPECT_EQ(1, layerCount());
1350     EXPECT_EQ(0, activeLayerCount());
1351     EXPECT_EQ(0, frequentLayerCount(time));
1352     EXPECT_EQ(0, animatingLayerCount(time));
1353 
1354     // layer is active but infrequent.
1355     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
1356         history().record(layer->getSequence(), layer->getLayerProps(), time, time,
1357                          LayerHistory::LayerUpdateType::Buffer);
1358         time += MAX_FREQUENT_LAYER_PERIOD_NS.count();
1359     }
1360 
1361     float expectedFramerate = 1e9f / MAX_FREQUENT_LAYER_PERIOD_NS.count();
1362     EXPECT_FLOAT_EQ(expectedFramerate, history().getLayerFramerate(time, layer->getSequence()));
1363 }
1364 
TEST_F(LayerHistoryTest,heuristicLayer60Hz)1365 TEST_F(LayerHistoryTest, heuristicLayer60Hz) {
1366     const auto layer = createLayer();
1367     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1368     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1369 
1370     nsecs_t time = systemTime();
1371     for (float fps = 54.0f; fps < 65.0f; fps += 0.1f) {
1372         recordFramesAndExpect(layer, time, Fps::fromValue(fps), 60_Hz, PRESENT_TIME_HISTORY_SIZE);
1373     }
1374 }
1375 
TEST_F(LayerHistoryTest,heuristicLayer60_30Hz)1376 TEST_F(LayerHistoryTest, heuristicLayer60_30Hz) {
1377     const auto layer = createLayer();
1378     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1379     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1380 
1381     nsecs_t time = systemTime();
1382     recordFramesAndExpect(layer, time, 60_Hz, 60_Hz, PRESENT_TIME_HISTORY_SIZE);
1383 
1384     recordFramesAndExpect(layer, time, 60_Hz, 60_Hz, PRESENT_TIME_HISTORY_SIZE);
1385     recordFramesAndExpect(layer, time, 30_Hz, 60_Hz, PRESENT_TIME_HISTORY_SIZE);
1386     recordFramesAndExpect(layer, time, 30_Hz, 30_Hz, PRESENT_TIME_HISTORY_SIZE);
1387     recordFramesAndExpect(layer, time, 60_Hz, 30_Hz, PRESENT_TIME_HISTORY_SIZE);
1388     recordFramesAndExpect(layer, time, 60_Hz, 60_Hz, PRESENT_TIME_HISTORY_SIZE);
1389 }
1390 
TEST_F(LayerHistoryTest,heuristicLayerNotOscillating)1391 TEST_F(LayerHistoryTest, heuristicLayerNotOscillating) {
1392     SET_FLAG_FOR_TEST(flags::use_known_refresh_rate_for_fps_consistency, false);
1393 
1394     const auto layer = createLayer();
1395     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1396     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1397 
1398     nsecs_t time = systemTime();
1399 
1400     recordFramesAndExpect(layer, time, 27.1_Hz, 30_Hz, PRESENT_TIME_HISTORY_SIZE);
1401     recordFramesAndExpect(layer, time, 26.9_Hz, 30_Hz, PRESENT_TIME_HISTORY_SIZE);
1402     recordFramesAndExpect(layer, time, 26_Hz, 24_Hz, PRESENT_TIME_HISTORY_SIZE);
1403     recordFramesAndExpect(layer, time, 26.9_Hz, 24_Hz, PRESENT_TIME_HISTORY_SIZE);
1404     recordFramesAndExpect(layer, time, 27.1_Hz, 30_Hz, PRESENT_TIME_HISTORY_SIZE);
1405 }
1406 
TEST_F(LayerHistoryTest,heuristicLayerNotOscillating_useKnownRefreshRate)1407 TEST_F(LayerHistoryTest, heuristicLayerNotOscillating_useKnownRefreshRate) {
1408     SET_FLAG_FOR_TEST(flags::use_known_refresh_rate_for_fps_consistency, true);
1409 
1410     const auto layer = createLayer();
1411     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1412     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1413 
1414     nsecs_t time = systemTime();
1415 
1416     recordFramesAndExpect(layer, time, 27.1_Hz, 30_Hz, PRESENT_TIME_HISTORY_SIZE);
1417     recordFramesAndExpect(layer, time, 26.9_Hz, 30_Hz, PRESENT_TIME_HISTORY_SIZE);
1418     recordFramesAndExpect(layer, time, 26_Hz, 24_Hz, PRESENT_TIME_HISTORY_SIZE);
1419     recordFramesAndExpect(layer, time, 26.9_Hz, 24_Hz, PRESENT_TIME_HISTORY_SIZE);
1420     recordFramesAndExpect(layer, time, 27.1_Hz, 24_Hz, PRESENT_TIME_HISTORY_SIZE);
1421     recordFramesAndExpect(layer, time, 27.1_Hz, 30_Hz, PRESENT_TIME_HISTORY_SIZE);
1422 }
1423 
TEST_F(LayerHistoryTest,smallDirtyLayer)1424 TEST_F(LayerHistoryTest, smallDirtyLayer) {
1425     auto layer = createLayer();
1426 
1427     EXPECT_CALL(*layer, isVisible()).WillRepeatedly(Return(true));
1428     EXPECT_CALL(*layer, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1429 
1430     nsecs_t time = systemTime();
1431 
1432     EXPECT_EQ(1, layerCount());
1433     EXPECT_EQ(0, activeLayerCount());
1434     EXPECT_EQ(0, frequentLayerCount(time));
1435 
1436     LayerHistory::Summary summary;
1437 
1438     // layer is active but infrequent.
1439     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE; i++) {
1440         auto props = layer->getLayerProps();
1441         if (i % 3 == 0) {
1442             props.isSmallDirty = false;
1443         } else {
1444             props.isSmallDirty = true;
1445         }
1446 
1447         history().record(layer->getSequence(), props, time, time,
1448                          LayerHistory::LayerUpdateType::Buffer);
1449         time += HI_FPS_PERIOD;
1450         summary = summarizeLayerHistory(time);
1451     }
1452 
1453     ASSERT_EQ(1, summary.size());
1454     ASSERT_EQ(LayerHistory::LayerVoteType::Heuristic, summary[0].vote);
1455     EXPECT_GE(HI_FPS, summary[0].desiredRefreshRate);
1456 }
1457 
TEST_F(LayerHistoryTest,smallDirtyInMultiLayer)1458 TEST_F(LayerHistoryTest, smallDirtyInMultiLayer) {
1459     auto layer1 = createLayer("UI");
1460     auto layer2 = createLayer("Video");
1461 
1462     EXPECT_CALL(*layer1, isVisible()).WillRepeatedly(Return(true));
1463     EXPECT_CALL(*layer1, getFrameRateForLayerTree()).WillRepeatedly(Return(Layer::FrameRate()));
1464 
1465     EXPECT_CALL(*layer2, isVisible()).WillRepeatedly(Return(true));
1466     EXPECT_CALL(*layer2, getFrameRateForLayerTree())
1467             .WillRepeatedly(
1468                     Return(Layer::FrameRate(30_Hz, Layer::FrameRateCompatibility::Default)));
1469 
1470     nsecs_t time = systemTime();
1471 
1472     EXPECT_EQ(2, layerCount());
1473     EXPECT_EQ(0, activeLayerCount());
1474     EXPECT_EQ(0, frequentLayerCount(time));
1475 
1476     LayerHistory::Summary summary;
1477 
1478     // layer1 is updating small dirty.
1479     for (int i = 0; i < PRESENT_TIME_HISTORY_SIZE + FREQUENT_LAYER_WINDOW_SIZE + 1; i++) {
1480         auto props = layer1->getLayerProps();
1481         props.isSmallDirty = true;
1482         history().record(layer1->getSequence(), props, 0 /*presentTime*/, time,
1483                          LayerHistory::LayerUpdateType::Buffer);
1484         history().record(layer2->getSequence(), layer2->getLayerProps(), time, time,
1485                          LayerHistory::LayerUpdateType::Buffer);
1486         time += HI_FPS_PERIOD;
1487         summary = summarizeLayerHistory(time);
1488     }
1489 
1490     ASSERT_EQ(1, summary.size());
1491     ASSERT_EQ(LayerHistory::LayerVoteType::ExplicitDefault, summary[0].vote);
1492     ASSERT_EQ(30_Hz, summary[0].desiredRefreshRate);
1493 }
1494 
1495 class LayerHistoryTestParameterized : public LayerHistoryTest,
1496                                       public testing::WithParamInterface<std::chrono::nanoseconds> {
1497 };
1498 
TEST_P(LayerHistoryTestParameterized,HeuristicLayerWithInfrequentLayer)1499 TEST_P(LayerHistoryTestParameterized, HeuristicLayerWithInfrequentLayer) {
1500     std::chrono::nanoseconds infrequentUpdateDelta = GetParam();
1501     auto heuristicLayer = createLayer("HeuristicLayer");
1502 
1503     EXPECT_CALL(*heuristicLayer, isVisible()).WillRepeatedly(Return(true));
1504     EXPECT_CALL(*heuristicLayer, getFrameRateForLayerTree())
1505             .WillRepeatedly(Return(Layer::FrameRate()));
1506 
1507     auto infrequentLayer = createLayer("InfrequentLayer");
1508     EXPECT_CALL(*infrequentLayer, isVisible()).WillRepeatedly(Return(true));
1509     EXPECT_CALL(*infrequentLayer, getFrameRateForLayerTree())
1510             .WillRepeatedly(Return(Layer::FrameRate()));
1511 
1512     const nsecs_t startTime = systemTime();
1513 
1514     const std::chrono::nanoseconds heuristicUpdateDelta = 41'666'667ns;
1515     history().record(heuristicLayer->getSequence(), heuristicLayer->getLayerProps(), startTime,
1516                      startTime, LayerHistory::LayerUpdateType::Buffer);
1517     history().record(infrequentLayer->getSequence(), heuristicLayer->getLayerProps(), startTime,
1518                      startTime, LayerHistory::LayerUpdateType::Buffer);
1519 
1520     nsecs_t time = startTime;
1521     nsecs_t lastInfrequentUpdate = startTime;
1522     const int totalInfrequentLayerUpdates = FREQUENT_LAYER_WINDOW_SIZE * 5;
1523     int infrequentLayerUpdates = 0;
1524     while (infrequentLayerUpdates <= totalInfrequentLayerUpdates) {
1525         time += heuristicUpdateDelta.count();
1526         history().record(heuristicLayer->getSequence(), heuristicLayer->getLayerProps(), time, time,
1527                          LayerHistory::LayerUpdateType::Buffer);
1528 
1529         if (time - lastInfrequentUpdate >= infrequentUpdateDelta.count()) {
1530             ALOGI("submitting infrequent frame [%d/%d]", infrequentLayerUpdates,
1531                   totalInfrequentLayerUpdates);
1532             lastInfrequentUpdate = time;
1533             history().record(infrequentLayer->getSequence(), infrequentLayer->getLayerProps(), time,
1534                              time, LayerHistory::LayerUpdateType::Buffer);
1535             infrequentLayerUpdates++;
1536         }
1537 
1538         if (time - startTime > PRESENT_TIME_HISTORY_DURATION.count()) {
1539             ASSERT_NE(0, summarizeLayerHistory(time).size());
1540             ASSERT_GE(2, summarizeLayerHistory(time).size());
1541 
1542             bool max = false;
1543             bool min = false;
1544             Fps heuristic;
1545             for (const auto& layer : summarizeLayerHistory(time)) {
1546                 if (layer.vote == LayerHistory::LayerVoteType::Heuristic) {
1547                     heuristic = layer.desiredRefreshRate;
1548                 } else if (layer.vote == LayerHistory::LayerVoteType::Max) {
1549                     max = true;
1550                 } else if (layer.vote == LayerHistory::LayerVoteType::Min) {
1551                     min = true;
1552                 }
1553             }
1554 
1555             if (infrequentLayerUpdates > FREQUENT_LAYER_WINDOW_SIZE) {
1556                 EXPECT_EQ(24_Hz, heuristic);
1557                 EXPECT_FALSE(max);
1558                 if (summarizeLayerHistory(time).size() == 2) {
1559                     EXPECT_TRUE(min);
1560                 }
1561             }
1562         }
1563     }
1564 }
1565 
1566 INSTANTIATE_TEST_CASE_P(LeapYearTests, LayerHistoryTestParameterized,
1567                         ::testing::Values(1s, 2s, 3s, 4s, 5s));
1568 
1569 } // namespace
1570 } // namespace android::scheduler
1571 
1572 // TODO(b/129481165): remove the #pragma below and fix conversion issues
1573 #pragma clang diagnostic pop // ignored "-Wextra"
1574