SF: Clean up RefreshRateConfigs tests
Finish renaming `config` to `mode`, and reduce repetition in preparation
of RefreshRateConfigs::RefreshRate removal.
Bug: 185535769
Bug: 129481165
Test: libsurfaceflinger_unittest
Change-Id: I9a87cec76387edbdfaeb31c1f24cff341489e45a
diff --git a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
index 2bafabd..2c862d3 100644
--- a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
+++ b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
@@ -14,10 +14,6 @@
* limitations under the License.
*/
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wextra"
-
#undef LOG_TAG
#define LOG_TAG "SchedulerUnittests"
@@ -33,6 +29,21 @@
using namespace std::chrono_literals;
namespace android::scheduler {
+namespace {
+
+DisplayModePtr createDisplayMode(DisplayModeId modeId, Fps refreshRate, int32_t group = 0,
+ ui::Size resolution = ui::Size()) {
+ return DisplayMode::Builder(hal::HWConfigId(modeId.value()))
+ .setId(modeId)
+ .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
+ .setVsyncPeriod(static_cast<int32_t>(refreshRate.getPeriodNsecs()))
+ .setGroup(group)
+ .setHeight(resolution.height)
+ .setWidth(resolution.width)
+ .build();
+}
+
+} // namespace
namespace hal = android::hardware::graphics::composer::hal;
@@ -40,143 +51,101 @@
using LayerVoteType = RefreshRateConfigs::LayerVoteType;
using LayerRequirement = RefreshRateConfigs::LayerRequirement;
+struct TestableRefreshRateConfigs : RefreshRateConfigs {
+ using RefreshRateConfigs::RefreshRateConfigs;
+
+ RefreshRate getMinSupportedRefreshRate() const {
+ std::lock_guard lock(mLock);
+ return *mMinSupportedRefreshRate;
+ }
+
+ RefreshRate getMaxSupportedRefreshRate() const {
+ std::lock_guard lock(mLock);
+ return *mMaxSupportedRefreshRate;
+ }
+
+ RefreshRate getMinRefreshRateByPolicy() const {
+ std::lock_guard lock(mLock);
+ return getMinRefreshRateByPolicyLocked();
+ }
+
+ const std::vector<Fps>& knownFrameRates() const { return mKnownFrameRates; }
+
+ using RefreshRateConfigs::GetBestRefreshRateInvocation;
+
+ std::optional<GetBestRefreshRateInvocation>& mutableLastBestRefreshRateInvocation() {
+ std::lock_guard lock(mLock);
+ return lastBestRefreshRateInvocation;
+ }
+};
+
class RefreshRateConfigsTest : public testing::Test {
protected:
- using GetBestRefreshRateInvocation = RefreshRateConfigs::GetBestRefreshRateInvocation;
-
RefreshRateConfigsTest();
~RefreshRateConfigsTest();
- RefreshRate createRefreshRate(DisplayModePtr displayMode) {
+ static RefreshRate asRefreshRate(DisplayModePtr displayMode) {
return {displayMode, RefreshRate::ConstructorTag(0)};
}
- Fps findClosestKnownFrameRate(const RefreshRateConfigs& refreshRateConfigs, Fps frameRate) {
- return refreshRateConfigs.findClosestKnownFrameRate(frameRate);
- }
+ static constexpr DisplayModeId kModeId60{0};
+ static constexpr DisplayModeId kModeId90{1};
+ static constexpr DisplayModeId kModeId72{2};
+ static constexpr DisplayModeId kModeId120{3};
+ static constexpr DisplayModeId kModeId30{4};
+ static constexpr DisplayModeId kModeId25{5};
+ static constexpr DisplayModeId kModeId50{6};
+ static constexpr DisplayModeId kModeId24{7};
+ static constexpr DisplayModeId kModeId24Frac{8};
+ static constexpr DisplayModeId kModeId30Frac{9};
+ static constexpr DisplayModeId kModeId60Frac{10};
- std::vector<Fps> getKnownFrameRate(const RefreshRateConfigs& refreshRateConfigs) {
- return refreshRateConfigs.mKnownFrameRates;
- }
+ static inline const DisplayModePtr kMode60 = createDisplayMode(kModeId60, 60_Hz);
+ static inline const DisplayModePtr kMode60Frac = createDisplayMode(kModeId60Frac, 59.94_Hz);
+ static inline const DisplayModePtr kMode90 = createDisplayMode(kModeId90, 90_Hz);
+ static inline const DisplayModePtr kMode90_G1 = createDisplayMode(kModeId90, 90_Hz, 1);
+ static inline const DisplayModePtr kMode90_4K =
+ createDisplayMode(kModeId90, 90_Hz, 0, {3840, 2160});
+ static inline const DisplayModePtr kMode72 = createDisplayMode(kModeId72, 72_Hz);
+ static inline const DisplayModePtr kMode72_G1 = createDisplayMode(kModeId72, 72_Hz, 1);
+ static inline const DisplayModePtr kMode120 = createDisplayMode(kModeId120, 120_Hz);
+ static inline const DisplayModePtr kMode120_G1 = createDisplayMode(kModeId120, 120_Hz, 1);
+ static inline const DisplayModePtr kMode30 = createDisplayMode(kModeId30, 30_Hz);
+ static inline const DisplayModePtr kMode30_G1 = createDisplayMode(kModeId30, 30_Hz, 1);
+ static inline const DisplayModePtr kMode30Frac = createDisplayMode(kModeId30Frac, 29.97_Hz);
+ static inline const DisplayModePtr kMode25 = createDisplayMode(kModeId25, 25_Hz);
+ static inline const DisplayModePtr kMode25_G1 = createDisplayMode(kModeId25, 25_Hz, 1);
+ static inline const DisplayModePtr kMode50 = createDisplayMode(kModeId50, 50_Hz);
+ static inline const DisplayModePtr kMode24 = createDisplayMode(kModeId24, 24_Hz);
+ static inline const DisplayModePtr kMode24Frac = createDisplayMode(kModeId24Frac, 23.976_Hz);
- RefreshRate getMinRefreshRateByPolicy(const RefreshRateConfigs& refreshRateConfigs) {
- std::lock_guard lock(refreshRateConfigs.mLock);
- return refreshRateConfigs.getMinRefreshRateByPolicyLocked();
- }
+ // Test configurations.
+ static inline const DisplayModes kModes_60 = {kMode60};
+ static inline const DisplayModes kModes_60_90 = {kMode60, kMode90};
+ static inline const DisplayModes kModes_60_90_G1 = {kMode60, kMode90_G1};
+ static inline const DisplayModes kModes_60_90_4K = {kMode60, kMode90_4K};
+ static inline const DisplayModes kModes_60_72_90 = {kMode60, kMode90, kMode72};
+ static inline const DisplayModes kModes_60_90_72_120 = {kMode60, kMode90, kMode72, kMode120};
+ static inline const DisplayModes kModes_30_60_72_90_120 = {kMode60, kMode90, kMode72, kMode120,
+ kMode30};
- RefreshRate getMinSupportedRefreshRate(const RefreshRateConfigs& refreshRateConfigs) {
- std::lock_guard lock(refreshRateConfigs.mLock);
- return *refreshRateConfigs.mMinSupportedRefreshRate;
- }
-
- RefreshRate getMaxSupportedRefreshRate(const RefreshRateConfigs& refreshRateConfigs) {
- std::lock_guard lock(refreshRateConfigs.mLock);
- return *refreshRateConfigs.mMaxSupportedRefreshRate;
- }
-
- void setLastBestRefreshRateInvocation(RefreshRateConfigs& refreshRateConfigs,
- const GetBestRefreshRateInvocation& invocation) {
- std::lock_guard lock(refreshRateConfigs.mLock);
- refreshRateConfigs.lastBestRefreshRateInvocation.emplace(
- GetBestRefreshRateInvocation(invocation));
- }
-
- std::optional<GetBestRefreshRateInvocation> getLastBestRefreshRateInvocation(
- const RefreshRateConfigs& refreshRateConfigs) {
- std::lock_guard lock(refreshRateConfigs.mLock);
- return refreshRateConfigs.lastBestRefreshRateInvocation;
- }
-
- // Test config IDs
- static inline const DisplayModeId HWC_CONFIG_ID_60 = DisplayModeId(0);
- static inline const DisplayModeId HWC_CONFIG_ID_90 = DisplayModeId(1);
- static inline const DisplayModeId HWC_CONFIG_ID_72 = DisplayModeId(2);
- static inline const DisplayModeId HWC_CONFIG_ID_120 = DisplayModeId(3);
- static inline const DisplayModeId HWC_CONFIG_ID_30 = DisplayModeId(4);
- static inline const DisplayModeId HWC_CONFIG_ID_25 = DisplayModeId(5);
- static inline const DisplayModeId HWC_CONFIG_ID_50 = DisplayModeId(6);
- static inline const DisplayModeId HWC_CONFIG_ID_24 = DisplayModeId(7);
- static inline const DisplayModeId HWC_CONFIG_ID_24_FRAC = DisplayModeId(8);
- static inline const DisplayModeId HWC_CONFIG_ID_30_FRAC = DisplayModeId(9);
- static inline const DisplayModeId HWC_CONFIG_ID_60_FRAC = DisplayModeId(10);
-
- // Test configs
- DisplayModePtr mConfig60 = createDisplayMode(HWC_CONFIG_ID_60, 0, (60_Hz).getPeriodNsecs());
- DisplayModePtr mConfig60Frac =
- createDisplayMode(HWC_CONFIG_ID_60_FRAC, 0, (59.94_Hz).getPeriodNsecs());
- DisplayModePtr mConfig90 = createDisplayMode(HWC_CONFIG_ID_90, 0, (90_Hz).getPeriodNsecs());
- DisplayModePtr mConfig90DifferentGroup =
- createDisplayMode(HWC_CONFIG_ID_90, 1, (90_Hz).getPeriodNsecs());
- DisplayModePtr mConfig90DifferentResolution =
- createDisplayMode(HWC_CONFIG_ID_90, 0, (90_Hz).getPeriodNsecs(), ui::Size(111, 222));
- DisplayModePtr mConfig72 = createDisplayMode(HWC_CONFIG_ID_72, 0, (72_Hz).getPeriodNsecs());
- DisplayModePtr mConfig72DifferentGroup =
- createDisplayMode(HWC_CONFIG_ID_72, 1, (72_Hz).getPeriodNsecs());
- DisplayModePtr mConfig120 = createDisplayMode(HWC_CONFIG_ID_120, 0, (120_Hz).getPeriodNsecs());
- DisplayModePtr mConfig120DifferentGroup =
- createDisplayMode(HWC_CONFIG_ID_120, 1, (120_Hz).getPeriodNsecs());
- DisplayModePtr mConfig30 = createDisplayMode(HWC_CONFIG_ID_30, 0, (30_Hz).getPeriodNsecs());
- DisplayModePtr mConfig30DifferentGroup =
- createDisplayMode(HWC_CONFIG_ID_30, 1, (30_Hz).getPeriodNsecs());
- DisplayModePtr mConfig30Frac =
- createDisplayMode(HWC_CONFIG_ID_30_FRAC, 0, (29.97_Hz).getPeriodNsecs());
- DisplayModePtr mConfig25 = createDisplayMode(HWC_CONFIG_ID_25, 0, (25_Hz).getPeriodNsecs());
- DisplayModePtr mConfig25DifferentGroup =
- createDisplayMode(HWC_CONFIG_ID_25, 1, (25_Hz).getPeriodNsecs());
- DisplayModePtr mConfig50 = createDisplayMode(HWC_CONFIG_ID_50, 0, (50_Hz).getPeriodNsecs());
- DisplayModePtr mConfig24 = createDisplayMode(HWC_CONFIG_ID_24, 0, (24_Hz).getPeriodNsecs());
- DisplayModePtr mConfig24Frac =
- createDisplayMode(HWC_CONFIG_ID_24_FRAC, 0, (23.976_Hz).getPeriodNsecs());
-
- // Test device configurations
- // The positions of the configs in the arrays below MUST match their IDs. For example,
- // the first config should always be 60Hz, the second 90Hz etc.
- DisplayModes m60OnlyConfigDevice = {mConfig60};
- DisplayModes m60_90Device = {mConfig60, mConfig90};
- DisplayModes m60_90DeviceWithDifferentGroups = {mConfig60, mConfig90DifferentGroup};
- DisplayModes m60_90DeviceWithDifferentResolutions = {mConfig60, mConfig90DifferentResolution};
- DisplayModes m60_72_90Device = {mConfig60, mConfig90, mConfig72};
- DisplayModes m60_90_72_120Device = {mConfig60, mConfig90, mConfig72, mConfig120};
- DisplayModes m30_60_72_90_120Device = {mConfig60, mConfig90, mConfig72, mConfig120, mConfig30};
- DisplayModes m30_60Device = {mConfig60, mConfig90DifferentGroup, mConfig72DifferentGroup,
- mConfig120DifferentGroup, mConfig30};
- DisplayModes m30_60_72_90Device = {mConfig60, mConfig90, mConfig72, mConfig120DifferentGroup,
- mConfig30};
- DisplayModes m30_60_90Device = {mConfig60, mConfig90, mConfig72DifferentGroup,
- mConfig120DifferentGroup, mConfig30};
- DisplayModes m25_30_50_60Device = {mConfig60,
- mConfig90,
- mConfig72DifferentGroup,
- mConfig120DifferentGroup,
- mConfig30DifferentGroup,
- mConfig25DifferentGroup,
- mConfig50};
- DisplayModes m60_120Device = {mConfig60, mConfig120};
+ static inline const DisplayModes kModes_30_60 = {kMode60, kMode90_G1, kMode72_G1, kMode120_G1,
+ kMode30};
+ static inline const DisplayModes kModes_30_60_72_90 = {kMode60, kMode90, kMode72, kMode120_G1,
+ kMode30};
+ static inline const DisplayModes kModes_30_60_90 = {kMode60, kMode90, kMode72_G1, kMode120_G1,
+ kMode30};
+ static inline const DisplayModes kModes_25_30_50_60 = {kMode60, kMode90, kMode72_G1,
+ kMode120_G1, kMode30_G1, kMode25_G1,
+ kMode50};
+ static inline const DisplayModes kModes_60_120 = {kMode60, kMode120};
// This is a typical TV configuration.
- DisplayModes m24_25_30_50_60WithFracDevice = {mConfig24, mConfig24Frac, mConfig25,
- mConfig30, mConfig30Frac, mConfig50,
- mConfig60, mConfig60Frac};
-
- // Expected RefreshRate objects
- RefreshRate mExpected60Config = {mConfig60, RefreshRate::ConstructorTag(0)};
- RefreshRate mExpectedAlmost60Config = {createDisplayMode(HWC_CONFIG_ID_60, 0, 16666665),
- RefreshRate::ConstructorTag(0)};
- RefreshRate mExpected90Config = {mConfig90, RefreshRate::ConstructorTag(0)};
- RefreshRate mExpected90DifferentGroupConfig = {mConfig90DifferentGroup,
- RefreshRate::ConstructorTag(0)};
- RefreshRate mExpected90DifferentResolutionConfig = {mConfig90DifferentResolution,
- RefreshRate::ConstructorTag(0)};
- RefreshRate mExpected72Config = {mConfig72, RefreshRate::ConstructorTag(0)};
- RefreshRate mExpected30Config = {mConfig30, RefreshRate::ConstructorTag(0)};
- RefreshRate mExpected120Config = {mConfig120, RefreshRate::ConstructorTag(0)};
-
- DisplayModePtr createDisplayMode(DisplayModeId modeId, int32_t group, int64_t vsyncPeriod,
- ui::Size resolution = ui::Size());
+ static inline const DisplayModes kModes_24_25_30_50_60_Frac = {kMode24, kMode24Frac, kMode25,
+ kMode30, kMode30Frac, kMode50,
+ kMode60, kMode60Frac};
};
-using Builder = DisplayMode::Builder;
-
RefreshRateConfigsTest::RefreshRateConfigsTest() {
const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();
@@ -189,348 +158,315 @@
ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
}
-DisplayModePtr RefreshRateConfigsTest::createDisplayMode(DisplayModeId modeId, int32_t group,
- int64_t vsyncPeriod, ui::Size resolution) {
- return DisplayMode::Builder(hal::HWConfigId(modeId.value()))
- .setId(modeId)
- .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
- .setVsyncPeriod(int32_t(vsyncPeriod))
- .setGroup(group)
- .setHeight(resolution.height)
- .setWidth(resolution.width)
- .build();
-}
-
namespace {
-TEST_F(RefreshRateConfigsTest, oneDeviceConfig_SwitchingSupported) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60OnlyConfigDevice,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+TEST_F(RefreshRateConfigsTest, oneMode_canSwitch) {
+ RefreshRateConfigs configs(kModes_60, kModeId60);
+ EXPECT_FALSE(configs.canSwitch());
}
TEST_F(RefreshRateConfigsTest, invalidPolicy) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60OnlyConfigDevice,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
- ASSERT_LT(refreshRateConfigs->setDisplayManagerPolicy({DisplayModeId(10), {60_Hz, 60_Hz}}), 0);
- ASSERT_LT(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {20_Hz, 40_Hz}}), 0);
+ RefreshRateConfigs configs(kModes_60, kModeId60);
+ EXPECT_LT(configs.setDisplayManagerPolicy({DisplayModeId(10), {60_Hz, 60_Hz}}), 0);
+ EXPECT_LT(configs.setDisplayManagerPolicy({kModeId60, {20_Hz, 40_Hz}}), 0);
}
-TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+TEST_F(RefreshRateConfigsTest, twoModes_storesFullRefreshRateMap) {
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
- const auto& minRate = getMinSupportedRefreshRate(*refreshRateConfigs);
- const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs);
+ const auto minRate = configs.getMinSupportedRefreshRate();
+ const auto performanceRate = configs.getMaxSupportedRefreshRate();
- ASSERT_EQ(mExpected60Config, minRate);
- ASSERT_EQ(mExpected90Config, performanceRate);
+ EXPECT_EQ(asRefreshRate(kMode60), minRate);
+ EXPECT_EQ(asRefreshRate(kMode90), performanceRate);
- const auto& minRateByPolicy = getMinRefreshRateByPolicy(*refreshRateConfigs);
- const auto& performanceRateByPolicy = refreshRateConfigs->getMaxRefreshRateByPolicy();
- ASSERT_EQ(minRateByPolicy, minRate);
- ASSERT_EQ(performanceRateByPolicy, performanceRate);
+ const auto minRateByPolicy = configs.getMinRefreshRateByPolicy();
+ const auto performanceRateByPolicy = configs.getMaxRefreshRateByPolicy();
+
+ EXPECT_EQ(minRateByPolicy, minRate);
+ EXPECT_EQ(performanceRateByPolicy, performanceRate);
}
-TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap_differentGroups) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+TEST_F(RefreshRateConfigsTest, twoModes_storesFullRefreshRateMap_differentGroups) {
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
- const auto& minRate = getMinRefreshRateByPolicy(*refreshRateConfigs);
- const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs);
- const auto& minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs);
- const auto& performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy();
+ const auto minRate = configs.getMinRefreshRateByPolicy();
+ const auto performanceRate = configs.getMaxSupportedRefreshRate();
+ const auto minRate60 = configs.getMinRefreshRateByPolicy();
+ const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
- ASSERT_EQ(mExpected60Config, minRate);
- ASSERT_EQ(mExpected60Config, minRate60);
- ASSERT_EQ(mExpected60Config, performanceRate60);
+ EXPECT_EQ(asRefreshRate(kMode60), minRate);
+ EXPECT_EQ(asRefreshRate(kMode60), minRate60);
+ EXPECT_EQ(asRefreshRate(kMode60), performanceRate60);
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {60_Hz, 90_Hz}}), 0);
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}), 0);
+ configs.setCurrentModeId(kModeId90);
- const auto& minRate90 = getMinRefreshRateByPolicy(*refreshRateConfigs);
- const auto& performanceRate90 = refreshRateConfigs->getMaxRefreshRateByPolicy();
+ const auto minRate90 = configs.getMinRefreshRateByPolicy();
+ const auto performanceRate90 = configs.getMaxRefreshRateByPolicy();
- ASSERT_EQ(mExpected90DifferentGroupConfig, performanceRate);
- ASSERT_EQ(mExpected90DifferentGroupConfig, minRate90);
- ASSERT_EQ(mExpected90DifferentGroupConfig, performanceRate90);
+ EXPECT_EQ(asRefreshRate(kMode90_G1), performanceRate);
+ EXPECT_EQ(asRefreshRate(kMode90_G1), minRate90);
+ EXPECT_EQ(asRefreshRate(kMode90_G1), performanceRate90);
}
-TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap_differentResolutions) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentResolutions,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+TEST_F(RefreshRateConfigsTest, twoModes_storesFullRefreshRateMap_differentResolutions) {
+ TestableRefreshRateConfigs configs(kModes_60_90_4K, kModeId60);
- const auto& minRate = getMinRefreshRateByPolicy(*refreshRateConfigs);
- const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs);
- const auto& minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs);
- const auto& performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy();
+ const auto minRate = configs.getMinRefreshRateByPolicy();
+ const auto performanceRate = configs.getMaxSupportedRefreshRate();
+ const auto minRate60 = configs.getMinRefreshRateByPolicy();
+ const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
- ASSERT_EQ(mExpected60Config, minRate);
- ASSERT_EQ(mExpected60Config, minRate60);
- ASSERT_EQ(mExpected60Config, performanceRate60);
+ EXPECT_EQ(asRefreshRate(kMode60), minRate);
+ EXPECT_EQ(asRefreshRate(kMode60), minRate60);
+ EXPECT_EQ(asRefreshRate(kMode60), performanceRate60);
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {60_Hz, 90_Hz}}), 0);
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}), 0);
+ configs.setCurrentModeId(kModeId90);
- const auto& minRate90 = getMinRefreshRateByPolicy(*refreshRateConfigs);
- const auto& performanceRate90 = refreshRateConfigs->getMaxRefreshRateByPolicy();
+ const auto minRate90 = configs.getMinRefreshRateByPolicy();
+ const auto performanceRate90 = configs.getMaxRefreshRateByPolicy();
- ASSERT_EQ(mExpected90DifferentResolutionConfig, performanceRate);
- ASSERT_EQ(mExpected90DifferentResolutionConfig, minRate90);
- ASSERT_EQ(mExpected90DifferentResolutionConfig, performanceRate90);
+ EXPECT_EQ(asRefreshRate(kMode90_4K), performanceRate);
+ EXPECT_EQ(asRefreshRate(kMode90_4K), minRate90);
+ EXPECT_EQ(asRefreshRate(kMode90_4K), performanceRate90);
}
-TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_policyChange) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+TEST_F(RefreshRateConfigsTest, twoModes_policyChange) {
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
- auto minRate = getMinRefreshRateByPolicy(*refreshRateConfigs);
- auto performanceRate = refreshRateConfigs->getMaxRefreshRateByPolicy();
+ const auto minRate = configs.getMinRefreshRateByPolicy();
+ const auto performanceRate = configs.getMaxRefreshRateByPolicy();
- ASSERT_EQ(mExpected60Config, minRate);
- ASSERT_EQ(mExpected90Config, performanceRate);
+ EXPECT_EQ(asRefreshRate(kMode60), minRate);
+ EXPECT_EQ(asRefreshRate(kMode90), performanceRate);
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60_Hz, 60_Hz}}), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
- auto minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs);
- auto performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy();
- ASSERT_EQ(mExpected60Config, minRate60);
- ASSERT_EQ(mExpected60Config, performanceRate60);
+ const auto minRate60 = configs.getMinRefreshRateByPolicy();
+ const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
+
+ EXPECT_EQ(asRefreshRate(kMode60), minRate60);
+ EXPECT_EQ(asRefreshRate(kMode60), performanceRate60);
}
-TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getCurrentRefreshRate) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+TEST_F(RefreshRateConfigsTest, twoModes_getCurrentRefreshRate) {
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
{
- auto current = refreshRateConfigs->getCurrentRefreshRate();
- EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_60);
+ const auto current = configs.getCurrentRefreshRate();
+ EXPECT_EQ(current.getModeId(), kModeId60);
}
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
+ configs.setCurrentModeId(kModeId90);
{
- auto current = refreshRateConfigs->getCurrentRefreshRate();
- EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_90);
+ const auto current = configs.getCurrentRefreshRate();
+ EXPECT_EQ(current.getModeId(), kModeId90);
}
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {90_Hz, 90_Hz}}), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}), 0);
{
- auto current = refreshRateConfigs->getCurrentRefreshRate();
- EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_90);
+ const auto current = configs.getCurrentRefreshRate();
+ EXPECT_EQ(current.getModeId(), kModeId90);
}
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_noLayers) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_72_90Device, /*currentConfigId=*/
- HWC_CONFIG_ID_72);
+ {
+ RefreshRateConfigs configs(kModes_60_72_90, kModeId72);
- // If there are no layers we select the default frame rate, which is the max of the primary
- // range.
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate({}, {}));
+ // If there are no layers we select the default frame rate, which is the max of the primary
+ // range.
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate({}, {}));
- ASSERT_EQ(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60_Hz, 60_Hz}}),
- NO_ERROR);
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate({}, {}));
-
- // We select max even when this will cause a non-seamless switch.
- refreshRateConfigs = std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
- ASSERT_EQ(refreshRateConfigs->setDisplayManagerPolicy(
- {HWC_CONFIG_ID_90, /*allowGroupSwitching*/ true, {0_Hz, 90_Hz}}),
- NO_ERROR);
- EXPECT_EQ(mExpected90DifferentGroupConfig, refreshRateConfigs->getBestRefreshRate({}, {}));
+ EXPECT_EQ(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), NO_ERROR);
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate({}, {}));
+ }
+ {
+ // We select max even when this will cause a non-seamless switch.
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ constexpr bool kAllowGroupSwitching = true;
+ EXPECT_EQ(configs.setDisplayManagerPolicy({kModeId90, kAllowGroupSwitching, {0_Hz, 90_Hz}}),
+ NO_ERROR);
+ EXPECT_EQ(asRefreshRate(kMode90_G1), configs.getBestRefreshRate({}, {}));
+ }
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_90) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
lr.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.name = "";
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60_Hz, 60_Hz}}), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {90_Hz, 90_Hz}}), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}), 0);
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {0_Hz, 120_Hz}}), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {0_Hz, 120_Hz}}), 0);
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_multipleThreshold_60_90) {
- RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 90};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60, config);
+ RefreshRateConfigs configs(kModes_60_90, kModeId60, {.frameRateMultipleThreshold = 90});
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
lr.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_72_90) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_72_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_72_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90_120) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -540,25 +476,23 @@
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 48_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 48_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -570,7 +504,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -578,7 +512,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -586,7 +520,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "60Hz ExplicitDefault";
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -594,7 +528,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -602,7 +536,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -610,7 +544,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
@@ -618,7 +552,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -626,7 +560,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -634,14 +568,12 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.name = "90Hz ExplicitExactOrMultiple";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes_multipleThreshold) {
- RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 120};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60, config);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60,
+ {.frameRateMultipleThreshold = 120});
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -653,7 +585,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -661,7 +593,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -669,7 +601,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "60Hz ExplicitDefault";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -677,7 +609,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -685,7 +617,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -693,7 +625,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
@@ -701,7 +633,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -709,7 +641,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -717,92 +649,86 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.name = "90Hz ExplicitExactOrMultiple";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_30_60, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(mExpected30Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(mExpected30Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_30_60_72_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(mExpected30Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
lr.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(mExpected30Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 24_Hz;
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
lr.name = "24Hz ExplicitExactOrMultiple";
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_PriorityTest) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_30_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -810,45 +736,43 @@
lr1.vote = LayerVoteType::Min;
lr2.vote = LayerVoteType::Max;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::Min;
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::Min;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::Max;
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::Max;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::Heuristic;
lr1.desiredRefreshRate = 15_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::Heuristic;
lr1.desiredRefreshRate = 30_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -856,17 +780,14 @@
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
lr.desiredRefreshRate = Fps::fromValue(fps);
- const auto refreshRate = refreshRateConfigs->getBestRefreshRate(layers, {});
- EXPECT_EQ(mExpected60Config, refreshRate)
+ const auto refreshRate = configs.getBestRefreshRate(layers, {});
+ EXPECT_EQ(asRefreshRate(kMode60), refreshRate)
<< lr.desiredRefreshRate << " chooses " << refreshRate.getName();
}
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo_multipleThreshold_60_120) {
- RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 120};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60, config);
+ RefreshRateConfigs configs(kModes_60_120, kModeId60, {.frameRateMultipleThreshold = 120});
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -874,16 +795,14 @@
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
lr.desiredRefreshRate = Fps::fromValue(fps);
- const auto refreshRate = refreshRateConfigs->getBestRefreshRate(layers, {});
- EXPECT_EQ(mExpected60Config, refreshRate)
+ const auto refreshRate = configs.getBestRefreshRate(layers, {});
+ EXPECT_EQ(asRefreshRate(kMode60), refreshRate)
<< lr.desiredRefreshRate << " chooses " << refreshRate.getName();
}
}
-TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getBestRefreshRate_Explicit) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+TEST_F(RefreshRateConfigsTest, twoModes_getBestRefreshRate_Explicit) {
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -893,33 +812,34 @@
lr1.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::ExplicitDefault;
lr1.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::Heuristic;
lr1.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, testInPolicy) {
- ASSERT_TRUE(mExpectedAlmost60Config.inPolicy(60.000004_Hz, 60.000004_Hz));
- ASSERT_TRUE(mExpectedAlmost60Config.inPolicy(59_Hz, 60.1_Hz));
- ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(75_Hz, 90_Hz));
- ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(60.0011_Hz, 90_Hz));
- ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(50_Hz, 59.998_Hz));
+ const auto refreshRate =
+ asRefreshRate(createDisplayMode(kModeId60, Fps::fromPeriodNsecs(16'666'665)));
+
+ EXPECT_TRUE(refreshRate.inPolicy(60.000004_Hz, 60.000004_Hz));
+ EXPECT_TRUE(refreshRate.inPolicy(59_Hz, 60.1_Hz));
+ EXPECT_FALSE(refreshRate.inPolicy(75_Hz, 90_Hz));
+ EXPECT_FALSE(refreshRate.inPolicy(60.0011_Hz, 90_Hz));
+ EXPECT_FALSE(refreshRate.inPolicy(50_Hz, 59.998_Hz));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_75HzContent) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -927,16 +847,14 @@
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
for (float fps = 75.0f; fps < 100.0f; fps += 0.1f) {
lr.desiredRefreshRate = Fps::fromValue(fps);
- const auto refreshRate = refreshRateConfigs->getBestRefreshRate(layers, {});
- EXPECT_EQ(mExpected90Config, refreshRate)
+ const auto refreshRate = configs.getBestRefreshRate(layers, {});
+ EXPECT_EQ(asRefreshRate(kMode90), refreshRate)
<< lr.desiredRefreshRate << " chooses " << refreshRate.getName();
}
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_Multiples) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -948,7 +866,7 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
@@ -956,14 +874,14 @@
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::Max;
lr2.name = "Max";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 30_Hz;
@@ -971,20 +889,18 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 30_Hz;
lr1.name = "30Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::Max;
lr2.name = "Max";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -995,28 +911,28 @@
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::NoVote;
lr2.name = "NoVote";
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::NoVote;
lr2.name = "NoVote";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::Max;
lr2.name = "Max";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::Max;
lr2.name = "Max";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
// The other layer starts to provide buffers
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -1025,20 +941,18 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, touchConsidered) {
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
+
RefreshRateConfigs::GlobalSignals consideredSignals;
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ configs.getBestRefreshRate({}, {}, &consideredSignals);
+ EXPECT_FALSE(consideredSignals.touch);
- refreshRateConfigs->getBestRefreshRate({}, {}, &consideredSignals);
- EXPECT_EQ(false, consideredSignals.touch);
-
- refreshRateConfigs->getBestRefreshRate({}, {.touch = true}, &consideredSignals);
- EXPECT_EQ(true, consideredSignals.touch);
+ configs.getBestRefreshRate({}, {.touch = true}, &consideredSignals);
+ EXPECT_TRUE(consideredSignals.touch);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -1050,8 +964,8 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.name = "60Hz Heuristic";
- refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
- EXPECT_EQ(true, consideredSignals.touch);
+ configs.getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
+ EXPECT_TRUE(consideredSignals.touch);
lr1.vote = LayerVoteType::ExplicitDefault;
lr1.desiredRefreshRate = 60_Hz;
@@ -1059,8 +973,8 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.name = "60Hz Heuristic";
- refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
- EXPECT_EQ(false, consideredSignals.touch);
+ configs.getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
+ EXPECT_FALSE(consideredSignals.touch);
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
@@ -1068,8 +982,8 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.name = "60Hz Heuristic";
- refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
- EXPECT_EQ(true, consideredSignals.touch);
+ configs.getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
+ EXPECT_TRUE(consideredSignals.touch);
lr1.vote = LayerVoteType::ExplicitDefault;
lr1.desiredRefreshRate = 60_Hz;
@@ -1077,14 +991,12 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.name = "60Hz Heuristic";
- refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
- EXPECT_EQ(false, consideredSignals.touch);
+ configs.getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
+ EXPECT_FALSE(consideredSignals.touch);
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitDefault) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90_72_120Device, /*currentConfigId=*/
- HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90_72_120, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -1116,7 +1028,7 @@
ss << "ExplicitDefault " << desired;
lr.name = ss.str();
- const auto refreshRate = refreshRateConfigs->getBestRefreshRate(layers, {});
+ const auto refreshRate = configs.getBestRefreshRate(layers, {});
EXPECT_EQ(refreshRate.getFps(), expected);
}
}
@@ -1128,39 +1040,34 @@
// Test that 23.976 will choose 24 if 23.976 is not supported
{
- android::DisplayModes modes = {mConfig24, mConfig25, mConfig30,
- mConfig30Frac, mConfig60, mConfig60Frac};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(modes, /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs({kMode24, kMode25, kMode30, kMode30Frac, kMode60, kMode60Frac},
+ kModeId60);
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
lr.desiredRefreshRate = 23.976_Hz;
lr.name = "ExplicitExactOrMultiple 23.976 Hz";
- EXPECT_EQ(HWC_CONFIG_ID_24, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers, {}).getModeId());
}
// Test that 24 will choose 23.976 if 24 is not supported
{
- android::DisplayModes modes = {mConfig24Frac, mConfig25, mConfig30,
- mConfig30Frac, mConfig60, mConfig60Frac};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(modes, /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs({kMode24Frac, kMode25, kMode30, kMode30Frac, kMode60,
+ kMode60Frac},
+ kModeId60);
+
lr.desiredRefreshRate = 24_Hz;
lr.name = "ExplicitExactOrMultiple 24 Hz";
- EXPECT_EQ(HWC_CONFIG_ID_24_FRAC,
- refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId24Frac, configs.getBestRefreshRate(layers, {}).getModeId());
}
// Test that 29.97 will prefer 59.94 over 60 and 30
{
- android::DisplayModes modes = {mConfig24, mConfig24Frac, mConfig25,
- mConfig30, mConfig60, mConfig60Frac};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(modes, /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs({kMode24, kMode24Frac, kMode25, kMode30, kMode60, kMode60Frac},
+ kModeId60);
+
lr.desiredRefreshRate = 29.97_Hz;
lr.name = "ExplicitExactOrMultiple 29.97 Hz";
- EXPECT_EQ(HWC_CONFIG_ID_60_FRAC,
- refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60Frac, configs.getBestRefreshRate(layers, {}).getModeId());
}
}
@@ -1170,9 +1077,7 @@
// Test that voting for supported refresh rate will select this refresh rate
{
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m24_25_30_50_60WithFracDevice,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_24_25_30_50_60_Frac, kModeId60);
for (auto desired : {23.976_Hz, 24_Hz, 25_Hz, 29.97_Hz, 30_Hz, 50_Hz, 59.94_Hz, 60_Hz}) {
lr.vote = LayerVoteType::ExplicitExact;
@@ -1181,45 +1086,39 @@
ss << "ExplicitExact " << desired;
lr.name = ss.str();
- auto selectedRefreshRate = refreshRateConfigs->getBestRefreshRate(layers, {});
+ auto selectedRefreshRate = configs.getBestRefreshRate(layers, {});
EXPECT_EQ(selectedRefreshRate.getFps(), lr.desiredRefreshRate);
}
}
// Test that 23.976 will choose 24 if 23.976 is not supported
{
- android::DisplayModes modes = {mConfig24, mConfig25, mConfig30,
- mConfig30Frac, mConfig60, mConfig60Frac};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(modes, /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs({kMode24, kMode25, kMode30, kMode30Frac, kMode60, kMode60Frac},
+ kModeId60);
+
lr.vote = LayerVoteType::ExplicitExact;
lr.desiredRefreshRate = 23.976_Hz;
lr.name = "ExplicitExact 23.976 Hz";
- EXPECT_EQ(HWC_CONFIG_ID_24, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers, {}).getModeId());
}
// Test that 24 will choose 23.976 if 24 is not supported
{
- android::DisplayModes modes = {mConfig24Frac, mConfig25, mConfig30,
- mConfig30Frac, mConfig60, mConfig60Frac};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(modes, /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs({kMode24Frac, kMode25, kMode30, kMode30Frac, kMode60,
+ kMode60Frac},
+ kModeId60);
+
lr.desiredRefreshRate = 24_Hz;
lr.name = "ExplicitExact 24 Hz";
- EXPECT_EQ(HWC_CONFIG_ID_24_FRAC,
- refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId24Frac, configs.getBestRefreshRate(layers, {}).getModeId());
}
}
TEST_F(RefreshRateConfigsTest,
getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresTouchFlag) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_90);
+ RefreshRateConfigs configs(kModes_60_90, kModeId90);
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
- {HWC_CONFIG_ID_90, {90_Hz, 90_Hz}, {60_Hz, 90_Hz}}),
- 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -1229,21 +1128,17 @@
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz ExplicitDefault";
lr.focused = true;
- EXPECT_EQ(mExpected60Config,
- refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = true},
- &consideredSignals));
- EXPECT_EQ(false, consideredSignals.touch);
+ EXPECT_EQ(asRefreshRate(kMode60),
+ configs.getBestRefreshRate(layers, {.touch = true, .idle = true},
+ &consideredSignals));
+ EXPECT_FALSE(consideredSignals.touch);
}
TEST_F(RefreshRateConfigsTest,
getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresIdleFlag) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
- {HWC_CONFIG_ID_60, {60_Hz, 60_Hz}, {60_Hz, 90_Hz}}),
- 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}, {60_Hz, 90_Hz}}), 0);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -1252,23 +1147,18 @@
lr.desiredRefreshRate = 90_Hz;
lr.name = "90Hz ExplicitDefault";
lr.focused = true;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.idle = true}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.idle = true}));
}
TEST_F(RefreshRateConfigsTest,
getBestRefreshRate_withDisplayManagerRequestingSingleRate_onlySwitchesRatesForExplicitFocusedLayers) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_90);
+ RefreshRateConfigs configs(kModes_60_90, kModeId90);
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
- {HWC_CONFIG_ID_90, {90_Hz, 90_Hz}, {60_Hz, 90_Hz}}),
- 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
RefreshRateConfigs::GlobalSignals consideredSignals;
- EXPECT_EQ(mExpected90Config,
- refreshRateConfigs->getBestRefreshRate({}, {}, &consideredSignals));
- EXPECT_EQ(false, consideredSignals.touch);
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate({}, {}, &consideredSignals));
+ EXPECT_FALSE(consideredSignals.touch);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -1277,52 +1167,50 @@
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz ExplicitExactOrMultiple";
lr.focused = false;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.focused = true;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::ExplicitDefault;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz ExplicitDefault";
lr.focused = false;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.focused = true;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Heuristic;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
lr.focused = false;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.focused = true;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Max;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Max";
lr.focused = false;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.focused = true;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.vote = LayerVoteType::Min;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Min";
lr.focused = false;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
lr.focused = true;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, groupSwitchingNotAllowed) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
// The default policy doesn't allow group switching. Verify that no
// group switches are performed.
@@ -1334,17 +1222,15 @@
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- ASSERT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayer) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& layer = layers[0];
@@ -1353,17 +1239,16 @@
layer.seamlessness = Seamlessness::SeamedAndSeamless;
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- ASSERT_EQ(HWC_CONFIG_ID_90, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamless) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+
RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
// Verify that we won't change the group if seamless switch is required.
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
@@ -1373,19 +1258,18 @@
layer.seamlessness = Seamlessness::OnlySeamless;
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- ASSERT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamlessDefaultFps) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
- RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
- policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
+ RefreshRateConfigs::Policy policy;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
+ policy.allowGroupSwitching = true;
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
+
+ configs.setCurrentModeId(kModeId90);
// Verify that we won't do a seamless switch if we request the same mode as the default
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
@@ -1395,19 +1279,18 @@
layer.seamlessness = Seamlessness::OnlySeamless;
layer.name = "60Hz ExplicitDefault";
layer.focused = true;
- ASSERT_EQ(HWC_CONFIG_ID_90, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerDefaultSeamlessness) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
- RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
- policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
+ RefreshRateConfigs::Policy policy;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
+ policy.allowGroupSwitching = true;
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
+
+ configs.setCurrentModeId(kModeId90);
// Verify that if the current config is in another group and there are no layers with
// seamlessness=SeamedAndSeamless we'll go back to the default group.
@@ -1420,19 +1303,18 @@
layer.name = "60Hz ExplicitDefault";
layer.focused = true;
- ASSERT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersOnlySeamlessAndSeamed) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
- RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
- policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
+ RefreshRateConfigs::Policy policy;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
+ policy.allowGroupSwitching = true;
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
+
+ configs.setCurrentModeId(kModeId90);
// If there's a layer with seamlessness=SeamedAndSeamless, another layer with
// seamlessness=OnlySeamless can't change the mode group.
@@ -1450,19 +1332,18 @@
layers[1].name = "90Hz ExplicitDefault";
layers[1].focused = false;
- ASSERT_EQ(HWC_CONFIG_ID_90, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultFocusedAndSeamed) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
- RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
- policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
+ RefreshRateConfigs::Policy policy;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
+ policy.allowGroupSwitching = true;
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
+
+ configs.setCurrentModeId(kModeId90);
// If there's a focused layer with seamlessness=SeamedAndSeamless, another layer with
// seamlessness=Default can't change the mode group back to the group of the default
@@ -1484,19 +1365,18 @@
layers[1].vote = LayerVoteType::ExplicitDefault;
layers[1].name = "90Hz ExplicitDefault";
- ASSERT_EQ(HWC_CONFIG_ID_90, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
- RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
- policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
+ RefreshRateConfigs::Policy policy;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
+ policy.allowGroupSwitching = true;
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
+
+ configs.setCurrentModeId(kModeId90);
// Layer with seamlessness=Default can change the mode group if there's a not
// focused layer with seamlessness=SeamedAndSeamless. This happens for example,
@@ -1515,19 +1395,17 @@
layers[1].vote = LayerVoteType::ExplicitDefault;
layers[1].name = "90Hz ExplicitDefault";
- ASSERT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, nonSeamlessVotePrefersSeamlessSwitches) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_30_60, kModeId60);
// Allow group switching.
RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& layer = layers[0];
@@ -1537,22 +1415,20 @@
layer.name = "60Hz ExplicitExactOrMultiple";
layer.focused = true;
- ASSERT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_120);
- ASSERT_EQ(HWC_CONFIG_ID_120, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ configs.setCurrentModeId(kModeId120);
+ EXPECT_EQ(kModeId120, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, nonSeamlessExactAndSeamlessMultipleLayers) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m25_30_50_60Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_25_30_50_60, kModeId60);
// Allow group switching.
RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
std::vector<LayerRequirement> layers = {{.name = "60Hz ExplicitDefault",
.vote = LayerVoteType::ExplicitDefault,
@@ -1567,37 +1443,33 @@
.weight = 1.f,
.focused = true}};
- ASSERT_EQ(HWC_CONFIG_ID_50, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId50, configs.getBestRefreshRate(layers, {}).getModeId());
auto& seamedLayer = layers[0];
seamedLayer.desiredRefreshRate = 30_Hz;
seamedLayer.name = "30Hz ExplicitDefault";
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_30);
+ configs.setCurrentModeId(kModeId30);
- ASSERT_EQ(HWC_CONFIG_ID_25, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId25, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, minLayersDontTrigerSeamedSwitch) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
- /*currentConfigId=*/HWC_CONFIG_ID_90);
+ RefreshRateConfigs configs(kModes_60_90_G1, kModeId90);
// Allow group switching.
RefreshRateConfigs::Policy policy;
- policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
+ policy.defaultMode = configs.getCurrentPolicy().defaultMode;
policy.allowGroupSwitching = true;
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
std::vector<LayerRequirement> layers = {
{.name = "Min", .vote = LayerVoteType::Min, .weight = 1.f, .focused = true}};
- ASSERT_EQ(HWC_CONFIG_ID_90, refreshRateConfigs->getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
}
TEST_F(RefreshRateConfigsTest, primaryVsAppRequestPolicy) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_30_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
layers[0].name = "Test layer";
@@ -1613,50 +1485,45 @@
layers[0].vote = voteType;
layers[0].desiredRefreshRate = fps;
layers[0].focused = args.focused;
- return refreshRateConfigs->getBestRefreshRate(layers, {.touch = args.touch}).getModeId();
+ return configs.getBestRefreshRate(layers, {.touch = args.touch}).getModeId();
};
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
- {HWC_CONFIG_ID_60, {30_Hz, 60_Hz}, {30_Hz, 90_Hz}}),
- 0);
- EXPECT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate({}, {}).getModeId());
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_30, getFrameRate(LayerVoteType::Min, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Heuristic, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_90, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz));
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {30_Hz, 60_Hz}, {30_Hz, 90_Hz}}), 0);
+
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate({}, {}).getModeId());
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
+ EXPECT_EQ(kModeId30, getFrameRate(LayerVoteType::Min, 90_Hz));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Heuristic, 90_Hz));
+ EXPECT_EQ(kModeId90, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz));
// Unfocused layers are not allowed to override primary config.
- EXPECT_EQ(HWC_CONFIG_ID_60,
- getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz, {.focused = false}));
- EXPECT_EQ(HWC_CONFIG_ID_60,
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz, {.focused = false}));
+ EXPECT_EQ(kModeId60,
getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz, {.focused = false}));
// Touch boost should be restricted to the primary range.
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, 90_Hz, {.touch = true}));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz, {.touch = true}));
+
// When we're higher than the primary range max due to a layer frame rate setting, touch boost
// shouldn't drag us back down to the primary range max.
- EXPECT_EQ(HWC_CONFIG_ID_90,
- getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz, {.touch = true}));
- EXPECT_EQ(HWC_CONFIG_ID_60,
+ EXPECT_EQ(kModeId90, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz, {.touch = true}));
+ EXPECT_EQ(kModeId60,
getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz, {.touch = true}));
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
- {HWC_CONFIG_ID_60, {60_Hz, 60_Hz}, {60_Hz, 60_Hz}}),
- 0);
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Min, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Heuristic, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz));
- EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz));
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}, {60_Hz, 60_Hz}}), 0);
+
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Min, 90_Hz));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Heuristic, 90_Hz));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz));
+ EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz));
}
TEST_F(RefreshRateConfigsTest, idle) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
layers[0].name = "Test layer";
@@ -1666,80 +1533,70 @@
layers[0].desiredRefreshRate = 90_Hz;
RefreshRateConfigs::GlobalSignals consideredSignals;
const auto configId =
- refreshRateConfigs
- ->getBestRefreshRate(layers, {.touch = touchActive, .idle = true},
- &consideredSignals)
+ configs.getBestRefreshRate(layers, {.touch = touchActive, .idle = true},
+ &consideredSignals)
.getModeId();
+
// Refresh rate will be chosen by either touch state or idle state
EXPECT_EQ(!touchActive, consideredSignals.idle);
return configId;
};
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
- {HWC_CONFIG_ID_60, {60_Hz, 90_Hz}, {60_Hz, 90_Hz}}),
- 0);
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
// Idle should be lower priority than touch boost.
- EXPECT_EQ(HWC_CONFIG_ID_90, getIdleFrameRate(LayerVoteType::NoVote, /*touchActive=*/true));
- EXPECT_EQ(HWC_CONFIG_ID_90, getIdleFrameRate(LayerVoteType::Min, /*touchActive=*/true));
- EXPECT_EQ(HWC_CONFIG_ID_90, getIdleFrameRate(LayerVoteType::Max, /*touchActive=*/true));
- EXPECT_EQ(HWC_CONFIG_ID_90, getIdleFrameRate(LayerVoteType::Heuristic, /*touchActive=*/true));
- EXPECT_EQ(HWC_CONFIG_ID_90,
- getIdleFrameRate(LayerVoteType::ExplicitDefault, /*touchActive=*/true));
- EXPECT_EQ(HWC_CONFIG_ID_90,
- getIdleFrameRate(LayerVoteType::ExplicitExactOrMultiple, /*touchActive=*/true));
+ {
+ constexpr bool kTouchActive = true;
+ EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::NoVote, kTouchActive));
+ EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::Min, kTouchActive));
+ EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::Max, kTouchActive));
+ EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::Heuristic, kTouchActive));
+ EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::ExplicitDefault, kTouchActive));
+ EXPECT_EQ(kModeId90,
+ getIdleFrameRate(LayerVoteType::ExplicitExactOrMultiple, kTouchActive));
+ }
// With no layers, idle should still be lower priority than touch boost.
- EXPECT_EQ(HWC_CONFIG_ID_90,
- refreshRateConfigs->getBestRefreshRate({}, {.touch = true, .idle = true})
- .getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate({}, {.touch = true, .idle = true}).getModeId());
// Idle should be higher precedence than other layer frame rate considerations.
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
- EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::NoVote, /*touchActive=*/false));
- EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::Min, /*touchActive=*/false));
- EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::Max, /*touchActive=*/false));
- EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::Heuristic, /*touchActive=*/false));
- EXPECT_EQ(HWC_CONFIG_ID_60,
- getIdleFrameRate(LayerVoteType::ExplicitDefault, /*touchActive=*/false));
- EXPECT_EQ(HWC_CONFIG_ID_60,
- getIdleFrameRate(LayerVoteType::ExplicitExactOrMultiple, /*touchActive=*/false));
+ configs.setCurrentModeId(kModeId90);
+
+ {
+ constexpr bool kTouchActive = false;
+ EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::NoVote, kTouchActive));
+ EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::Min, kTouchActive));
+ EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::Max, kTouchActive));
+ EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::Heuristic, kTouchActive));
+ EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::ExplicitDefault, kTouchActive));
+ EXPECT_EQ(kModeId60,
+ getIdleFrameRate(LayerVoteType::ExplicitExactOrMultiple, kTouchActive));
+ }
// Idle should be applied rather than the current config when there are no layers.
- EXPECT_EQ(HWC_CONFIG_ID_60,
- refreshRateConfigs->getBestRefreshRate({}, {.idle = true}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate({}, {.idle = true}).getModeId());
}
TEST_F(RefreshRateConfigsTest, findClosestKnownFrameRate) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
for (float fps = 1.0f; fps <= 120.0f; fps += 0.1f) {
- const auto knownFrameRate =
- findClosestKnownFrameRate(*refreshRateConfigs, Fps::fromValue(fps));
- Fps expectedFrameRate;
- if (fps < 26.91f) {
- expectedFrameRate = 24_Hz;
- } else if (fps < 37.51f) {
- expectedFrameRate = 30_Hz;
- } else if (fps < 52.51f) {
- expectedFrameRate = 45_Hz;
- } else if (fps < 66.01f) {
- expectedFrameRate = 60_Hz;
- } else if (fps < 81.01f) {
- expectedFrameRate = 72_Hz;
- } else {
- expectedFrameRate = 90_Hz;
- }
+ const auto knownFrameRate = configs.findClosestKnownFrameRate(Fps::fromValue(fps));
+ const Fps expectedFrameRate = [fps] {
+ if (fps < 26.91f) return 24_Hz;
+ if (fps < 37.51f) return 30_Hz;
+ if (fps < 52.51f) return 45_Hz;
+ if (fps < 66.01f) return 60_Hz;
+ if (fps < 81.01f) return 72_Hz;
+ return 90_Hz;
+ }();
+
EXPECT_EQ(expectedFrameRate, knownFrameRate);
}
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_KnownFrameRate) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
struct Expectation {
Fps fps;
@@ -1747,13 +1604,14 @@
};
const std::initializer_list<Expectation> knownFrameRatesExpectations = {
- {24_Hz, mExpected60Config}, {30_Hz, mExpected60Config}, {45_Hz, mExpected90Config},
- {60_Hz, mExpected60Config}, {72_Hz, mExpected90Config}, {90_Hz, mExpected90Config},
+ {24_Hz, asRefreshRate(kMode60)}, {30_Hz, asRefreshRate(kMode60)},
+ {45_Hz, asRefreshRate(kMode90)}, {60_Hz, asRefreshRate(kMode60)},
+ {72_Hz, asRefreshRate(kMode90)}, {90_Hz, asRefreshRate(kMode90)},
};
// Make sure the test tests all the known frame rate
- const auto knownFrameRateList = getKnownFrameRate(*refreshRateConfigs);
- const bool equal = std::equal(knownFrameRateList.begin(), knownFrameRateList.end(),
+ const auto& knownFrameRates = configs.knownFrameRates();
+ const bool equal = std::equal(knownFrameRates.begin(), knownFrameRates.end(),
knownFrameRatesExpectations.begin(),
[](Fps fps, const Expectation& expected) {
return isApproxEqual(fps, expected.fps);
@@ -1766,14 +1624,12 @@
for (const auto& [fps, refreshRate] : knownFrameRatesExpectations) {
layer.desiredRefreshRate = fps;
- EXPECT_EQ(refreshRate, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(refreshRate, configs.getBestRefreshRate(layers, {}));
}
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExact) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
auto& explicitExactLayer = layers[0];
@@ -1787,28 +1643,26 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(mExpected30Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected30Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
explicitExactLayer.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
explicitExactLayer.desiredRefreshRate = 72_Hz;
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
explicitExactLayer.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
explicitExactLayer.desiredRefreshRate = 120_Hz;
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactEnableFrameRateOverride) {
- RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60, config);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60,
+ {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
auto& explicitExactLayer = layers[0];
@@ -1822,56 +1676,47 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
explicitExactLayer.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
explicitExactLayer.desiredRefreshRate = 72_Hz;
- EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
explicitExactLayer.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
explicitExactLayer.desiredRefreshRate = 120_Hz;
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ReadsCached) {
+ using GetBestRefreshRateInvocation = TestableRefreshRateConfigs::GetBestRefreshRateInvocation;
using GlobalSignals = RefreshRateConfigs::GlobalSignals;
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
+ TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
- setLastBestRefreshRateInvocation(*refreshRateConfigs,
- GetBestRefreshRateInvocation{.globalSignals = {.touch = true,
- .idle = true},
- .outSignalsConsidered =
- {.touch = true},
- .resultingBestRefreshRate =
- createRefreshRate(
- mConfig90)});
+ configs.mutableLastBestRefreshRateInvocation() =
+ GetBestRefreshRateInvocation{.globalSignals = {.touch = true, .idle = true},
+ .outSignalsConsidered = {.touch = true},
+ .resultingBestRefreshRate = asRefreshRate(kMode90)};
- EXPECT_EQ(createRefreshRate(mConfig90),
- refreshRateConfigs->getBestRefreshRate({}, {.touch = true, .idle = true}));
+ EXPECT_EQ(asRefreshRate(kMode90),
+ configs.getBestRefreshRate({}, {.touch = true, .idle = true}));
const GlobalSignals cachedSignalsConsidered{.touch = true};
- setLastBestRefreshRateInvocation(*refreshRateConfigs,
- GetBestRefreshRateInvocation{.globalSignals = {.touch = true,
- .idle = true},
- .outSignalsConsidered =
- cachedSignalsConsidered,
- .resultingBestRefreshRate =
- createRefreshRate(
- mConfig30)});
+
+ configs.mutableLastBestRefreshRateInvocation() =
+ GetBestRefreshRateInvocation{.globalSignals = {.touch = true, .idle = true},
+ .outSignalsConsidered = cachedSignalsConsidered,
+ .resultingBestRefreshRate = asRefreshRate(kMode30)};
GlobalSignals signalsConsidered;
- EXPECT_EQ(createRefreshRate(mConfig30),
- refreshRateConfigs->getBestRefreshRate({}, {.touch = true, .idle = true},
- &signalsConsidered));
+ EXPECT_EQ(asRefreshRate(kMode30),
+ configs.getBestRefreshRate({}, {.touch = true, .idle = true}, &signalsConsidered));
EXPECT_EQ(cachedSignalsConsidered, signalsConsidered);
}
@@ -1879,35 +1724,29 @@
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_WritesCache) {
using GlobalSignals = RefreshRateConfigs::GlobalSignals;
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60);
- ASSERT_FALSE(getLastBestRefreshRateInvocation(*refreshRateConfigs).has_value());
+ TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
+
+ EXPECT_FALSE(configs.mutableLastBestRefreshRateInvocation());
GlobalSignals globalSignals{.touch = true, .idle = true};
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
- const auto lastResult =
- refreshRateConfigs->getBestRefreshRate(layers, globalSignals,
- /* outSignalsConsidered */ nullptr);
+ const auto lastResult = configs.getBestRefreshRate(layers, globalSignals,
+ /* outSignalsConsidered */ nullptr);
- const auto lastInvocation = getLastBestRefreshRateInvocation(*refreshRateConfigs);
-
- ASSERT_TRUE(lastInvocation.has_value());
- ASSERT_EQ(layers, lastInvocation->layerRequirements);
- ASSERT_EQ(globalSignals, lastInvocation->globalSignals);
- ASSERT_EQ(lastResult, lastInvocation->resultingBestRefreshRate);
+ const auto& lastInvocation = configs.mutableLastBestRefreshRateInvocation();
+ ASSERT_TRUE(lastInvocation);
+ EXPECT_EQ(layers, lastInvocation->layerRequirements);
+ EXPECT_EQ(globalSignals, lastInvocation->globalSignals);
+ EXPECT_EQ(lastResult, lastInvocation->resultingBestRefreshRate);
// outSignalsConsidered needs to be populated even tho earlier we gave nullptr
// to getBestRefreshRate()
- GlobalSignals detaultSignals;
- ASSERT_FALSE(detaultSignals == lastInvocation->outSignalsConsidered);
+ GlobalSignals defaultSignals;
+ EXPECT_FALSE(defaultSignals == lastInvocation->outSignalsConsidered);
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactTouchBoost) {
- RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_60, config);
+ RefreshRateConfigs configs(kModes_60_120, kModeId60, {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
auto& explicitExactLayer = layers[0];
@@ -1921,20 +1760,18 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.vote = LayerVoteType::NoVote;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {.touch = true}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_FractionalRefreshRates_ExactAndDefault) {
- RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m24_25_30_50_60WithFracDevice,
- /*currentConfigId=*/HWC_CONFIG_ID_60, config);
+ RefreshRateConfigs configs(kModes_24_25_30_50_60_Frac, kModeId60,
+ {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.weight = 0.5f}, {.weight = 0.5f}};
auto& explicitDefaultLayer = layers[0];
@@ -1948,32 +1785,27 @@
explicitDefaultLayer.name = "ExplicitDefault";
explicitDefaultLayer.desiredRefreshRate = 59.94_Hz;
- EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
}
// b/190578904
-TEST_F(RefreshRateConfigsTest, getBestRefreshRate_deviceWithCloseRefreshRates) {
+TEST_F(RefreshRateConfigsTest, getBestRefreshRate_withCloseRefreshRates) {
constexpr int kMinRefreshRate = 10;
constexpr int kMaxRefreshRate = 240;
DisplayModes displayModes;
for (int fps = kMinRefreshRate; fps < kMaxRefreshRate; fps++) {
- constexpr int32_t kGroup = 0;
- const auto refreshRate = Fps::fromValue(static_cast<float>(fps));
displayModes.push_back(
- createDisplayMode(DisplayModeId(fps), kGroup, refreshRate.getPeriodNsecs()));
+ createDisplayMode(DisplayModeId(fps), Fps::fromValue(static_cast<float>(fps))));
}
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(displayModes,
- /*currentConfigId=*/displayModes[0]->getId());
+ const RefreshRateConfigs configs(displayModes, displayModes[0]->getId());
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
const auto testRefreshRate = [&](Fps fps, LayerVoteType vote) {
layers[0].desiredRefreshRate = fps;
layers[0].vote = vote;
- EXPECT_EQ(fps.getIntValue(),
- refreshRateConfigs->getBestRefreshRate(layers, {}).getFps().getIntValue())
+ EXPECT_EQ(fps.getIntValue(), configs.getBestRefreshRate(layers, {}).getFps().getIntValue())
<< "Failed for " << ftl::enum_string(vote);
};
@@ -1989,25 +1821,23 @@
// b/190578904
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_conflictingVotes) {
const DisplayModes displayModes = {
- createDisplayMode(DisplayModeId(0), 0, (43_Hz).getPeriodNsecs()),
- createDisplayMode(DisplayModeId(1), 0, (53_Hz).getPeriodNsecs()),
- createDisplayMode(DisplayModeId(2), 0, (55_Hz).getPeriodNsecs()),
- createDisplayMode(DisplayModeId(3), 0, (60_Hz).getPeriodNsecs()),
+ createDisplayMode(DisplayModeId(0), 43_Hz),
+ createDisplayMode(DisplayModeId(1), 53_Hz),
+ createDisplayMode(DisplayModeId(2), 55_Hz),
+ createDisplayMode(DisplayModeId(3), 60_Hz),
};
const RefreshRateConfigs::GlobalSignals globalSignals = {.touch = false, .idle = false};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(displayModes,
- /*currentConfigId=*/displayModes[0]->getId());
+ const RefreshRateConfigs configs(displayModes, displayModes[0]->getId());
- const auto layers = std::vector<LayerRequirement>{
- LayerRequirement{
+ const std::vector<LayerRequirement> layers = {
+ {
.vote = LayerVoteType::ExplicitDefault,
.desiredRefreshRate = 43_Hz,
.seamlessness = Seamlessness::SeamedAndSeamless,
.weight = 0.41f,
},
- LayerRequirement{
+ {
.vote = LayerVoteType::ExplicitExactOrMultiple,
.desiredRefreshRate = 53_Hz,
.seamlessness = Seamlessness::SeamedAndSeamless,
@@ -2015,89 +1845,83 @@
},
};
- EXPECT_EQ(53_Hz, refreshRateConfigs->getBestRefreshRate(layers, globalSignals).getFps());
+ EXPECT_EQ(53_Hz, configs.getBestRefreshRate(layers, globalSignals).getFps());
}
TEST_F(RefreshRateConfigsTest, testComparisonOperator) {
- EXPECT_TRUE(mExpected60Config < mExpected90Config);
- EXPECT_FALSE(mExpected60Config < mExpected60Config);
- EXPECT_FALSE(mExpected90Config < mExpected90Config);
+ EXPECT_TRUE(asRefreshRate(kMode60) < asRefreshRate(kMode90));
+ EXPECT_FALSE(asRefreshRate(kMode60) < asRefreshRate(kMode60));
+ EXPECT_FALSE(asRefreshRate(kMode90) < asRefreshRate(kMode90));
}
TEST_F(RefreshRateConfigsTest, testKernelIdleTimerAction) {
- using KernelIdleTimerAction = scheduler::RefreshRateConfigs::KernelIdleTimerAction;
+ using KernelIdleTimerAction = RefreshRateConfigs::KernelIdleTimerAction;
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_90Device,
- /*currentConfigId=*/HWC_CONFIG_ID_90);
+ RefreshRateConfigs configs(kModes_60_90, kModeId90);
+
// SetPolicy(60, 90), current 90Hz => TurnOn.
- EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction());
+ EXPECT_EQ(KernelIdleTimerAction::TurnOn, configs.getIdleTimerAction());
// SetPolicy(60, 90), current 60Hz => TurnOn.
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60_Hz, 90_Hz}}), 0);
- EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction());
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 90_Hz}}), 0);
+ EXPECT_EQ(KernelIdleTimerAction::TurnOn, configs.getIdleTimerAction());
// SetPolicy(60, 60), current 60Hz => TurnOff
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60_Hz, 60_Hz}}), 0);
- EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction());
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
+ EXPECT_EQ(KernelIdleTimerAction::TurnOff, configs.getIdleTimerAction());
// SetPolicy(90, 90), current 90Hz => TurnOff.
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {90_Hz, 90_Hz}}), 0);
- EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction());
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}), 0);
+ EXPECT_EQ(KernelIdleTimerAction::TurnOff, configs.getIdleTimerAction());
}
TEST_F(RefreshRateConfigsTest, testKernelIdleTimerActionFor120Hz) {
- using KernelIdleTimerAction = scheduler::RefreshRateConfigs::KernelIdleTimerAction;
+ using KernelIdleTimerAction = RefreshRateConfigs::KernelIdleTimerAction;
- // Tests with 120Hz
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m60_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_120);
+ RefreshRateConfigs configs(kModes_60_120, kModeId120);
+
// SetPolicy(0, 60), current 60Hz => TurnOn.
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {0_Hz, 60_Hz}}), 0);
- EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction());
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {0_Hz, 60_Hz}}), 0);
+ EXPECT_EQ(KernelIdleTimerAction::TurnOn, configs.getIdleTimerAction());
// SetPolicy(60, 60), current 60Hz => TurnOff.
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60_Hz, 60_Hz}}), 0);
- EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction());
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
+ EXPECT_EQ(KernelIdleTimerAction::TurnOff, configs.getIdleTimerAction());
// SetPolicy(60, 120), current 60Hz => TurnOn.
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60_Hz, 120_Hz}}), 0);
- EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction());
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 120_Hz}}), 0);
+ EXPECT_EQ(KernelIdleTimerAction::TurnOn, configs.getIdleTimerAction());
// SetPolicy(120, 120), current 120Hz => TurnOff.
- ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_120, {120_Hz, 120_Hz}}),
- 0);
- EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction());
+ EXPECT_GE(configs.setDisplayManagerPolicy({kModeId120, {120_Hz, 120_Hz}}), 0);
+ EXPECT_EQ(KernelIdleTimerAction::TurnOff, configs.getIdleTimerAction());
}
TEST_F(RefreshRateConfigsTest, getFrameRateDivider) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
- /*currentConfigId=*/HWC_CONFIG_ID_30);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId30);
const auto frameRate = 30_Hz;
- Fps displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
+ Fps displayRefreshRate = configs.getCurrentRefreshRate().getFps();
EXPECT_EQ(1, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_60);
- displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
+ configs.setCurrentModeId(kModeId60);
+ displayRefreshRate = configs.getCurrentRefreshRate().getFps();
EXPECT_EQ(2, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_72);
- displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
+ configs.setCurrentModeId(kModeId72);
+ displayRefreshRate = configs.getCurrentRefreshRate().getFps();
EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
- displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
+ configs.setCurrentModeId(kModeId90);
+ displayRefreshRate = configs.getCurrentRefreshRate().getFps();
EXPECT_EQ(3, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_120);
- displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
+ configs.setCurrentModeId(kModeId120);
+ displayRefreshRate = configs.getCurrentRefreshRate().getFps();
EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
- refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
- displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
+ configs.setCurrentModeId(kModeId90);
+ displayRefreshRate = configs.getCurrentRefreshRate().getFps();
EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, 22.5_Hz));
EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivider(24_Hz, 25_Hz));
@@ -2133,57 +1957,52 @@
}
TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_noLayers) {
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/
- HWC_CONFIG_ID_120);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId120);
- ASSERT_TRUE(refreshRateConfigs->getFrameRateOverrides({}, 120_Hz, {}).empty());
+ EXPECT_TRUE(configs.getFrameRateOverrides({}, 120_Hz, {}).empty());
}
TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_60on120) {
- RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/
- HWC_CONFIG_ID_120, config);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId120,
+ {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
layers[0].name = "Test layer";
layers[0].ownerUid = 1234;
layers[0].desiredRefreshRate = 60_Hz;
layers[0].vote = LayerVoteType::ExplicitDefault;
- auto frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_EQ(1, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
+
+ auto frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_EQ(1u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_EQ(1, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_EQ(1u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
layers[0].vote = LayerVoteType::NoVote;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_TRUE(frameRateOverrides.empty());
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_TRUE(frameRateOverrides.empty());
layers[0].vote = LayerVoteType::Min;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_TRUE(frameRateOverrides.empty());
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_TRUE(frameRateOverrides.empty());
layers[0].vote = LayerVoteType::Max;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_TRUE(frameRateOverrides.empty());
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_TRUE(frameRateOverrides.empty());
layers[0].vote = LayerVoteType::Heuristic;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_TRUE(frameRateOverrides.empty());
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_TRUE(frameRateOverrides.empty());
}
TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_twoUids) {
- RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/
- HWC_CONFIG_ID_120, config);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId120,
+ {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f},
{.ownerUid = 5678, .weight = 1.f}};
@@ -2195,69 +2014,64 @@
layers[1].name = "Test layer 5678";
layers[1].desiredRefreshRate = 30_Hz;
layers[1].vote = LayerVoteType::ExplicitDefault;
- auto frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
+ auto frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_EQ(2, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
- ASSERT_EQ(1, frameRateOverrides.count(5678));
- ASSERT_EQ(30_Hz, frameRateOverrides.at(5678));
+ EXPECT_EQ(2u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
+ ASSERT_EQ(1u, frameRateOverrides.count(5678));
+ EXPECT_EQ(30_Hz, frameRateOverrides.at(5678));
layers[1].vote = LayerVoteType::Heuristic;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_EQ(1, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_EQ(1u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
layers[1].ownerUid = 1234;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_TRUE(frameRateOverrides.empty());
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_TRUE(frameRateOverrides.empty());
}
TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_touch) {
- RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
- auto refreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/
- HWC_CONFIG_ID_120, config);
+ RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId120,
+ {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f}};
layers[0].name = "Test layer";
layers[0].desiredRefreshRate = 60_Hz;
layers[0].vote = LayerVoteType::ExplicitDefault;
- auto frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_EQ(1, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
+ auto frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_EQ(1u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {.touch = true});
- ASSERT_EQ(1, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
+ EXPECT_EQ(1u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
layers[0].vote = LayerVoteType::ExplicitExact;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_EQ(1, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_EQ(1u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {.touch = true});
- ASSERT_EQ(1, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
+ EXPECT_EQ(1u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {});
- ASSERT_EQ(1, frameRateOverrides.size());
- ASSERT_EQ(1, frameRateOverrides.count(1234));
- ASSERT_EQ(60_Hz, frameRateOverrides.at(1234));
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
+ EXPECT_EQ(1u, frameRateOverrides.size());
+ ASSERT_EQ(1u, frameRateOverrides.count(1234));
+ EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
- frameRateOverrides = refreshRateConfigs->getFrameRateOverrides(layers, 120_Hz, {.touch = true});
- ASSERT_TRUE(frameRateOverrides.empty());
+ frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
+ EXPECT_TRUE(frameRateOverrides.empty());
}
} // namespace
} // namespace android::scheduler
-
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wextra"