SF: Unify data types for display modes
Remove the RefreshRateConfigs::RefreshRate wrapper around DisplayMode.
Store DisplayModes as a SmallMap, so that RefreshRateConfigs uses the
same data structure for lookup by ID. Use iterators into that map for
all bookkeeping in RefreshRateConfigs.
Bug: 182939859
Bug: 185535769
Test: libsurfaceflinger_unittest
Change-Id: I7708fa997089802c45d906b17b7a073f5c82105e
diff --git a/services/surfaceflinger/tests/unittests/DisplayDevice_InitiateModeChange.cpp b/services/surfaceflinger/tests/unittests/DisplayDevice_InitiateModeChange.cpp
index 40a9b1a..93af225 100644
--- a/services/surfaceflinger/tests/unittests/DisplayDevice_InitiateModeChange.cpp
+++ b/services/surfaceflinger/tests/unittests/DisplayDevice_InitiateModeChange.cpp
@@ -44,68 +44,42 @@
mFlinger.onComposerHalHotplug(PrimaryDisplayVariant::HWC_DISPLAY_ID, Connection::CONNECTED);
mDisplay = PrimaryDisplayVariant::makeFakeExistingDisplayInjector(this)
- .setDisplayModes({kDisplayMode60, kDisplayMode90, kDisplayMode120},
- kDisplayModeId60)
+ .setDisplayModes(makeModes(kMode60, kMode90, kMode120), kModeId60)
.inject();
}
protected:
sp<DisplayDevice> mDisplay;
- const DisplayModeId kDisplayModeId60 = DisplayModeId(0);
- const DisplayModePtr kDisplayMode60 =
- DisplayMode::Builder(hal::HWConfigId(kDisplayModeId60.value()))
- .setId(kDisplayModeId60)
- .setPhysicalDisplayId(PrimaryDisplayVariant::DISPLAY_ID::get())
- .setVsyncPeriod(int32_t(16'666'667))
- .setGroup(0)
- .setHeight(1000)
- .setWidth(1000)
- .build();
+ static constexpr DisplayModeId kModeId60{0};
+ static constexpr DisplayModeId kModeId90{1};
+ static constexpr DisplayModeId kModeId120{2};
- const DisplayModeId kDisplayModeId90 = DisplayModeId(1);
- const DisplayModePtr kDisplayMode90 =
- DisplayMode::Builder(hal::HWConfigId(kDisplayModeId90.value()))
- .setId(kDisplayModeId90)
- .setPhysicalDisplayId(PrimaryDisplayVariant::DISPLAY_ID::get())
- .setVsyncPeriod(int32_t(11'111'111))
- .setGroup(0)
- .setHeight(1000)
- .setWidth(1000)
- .build();
-
- const DisplayModeId kDisplayModeId120 = DisplayModeId(2);
- const DisplayModePtr kDisplayMode120 =
- DisplayMode::Builder(hal::HWConfigId(kDisplayModeId120.value()))
- .setId(kDisplayModeId120)
- .setPhysicalDisplayId(PrimaryDisplayVariant::DISPLAY_ID::get())
- .setVsyncPeriod(int32_t(8'333'333))
- .setGroup(0)
- .setHeight(1000)
- .setWidth(1000)
- .build();
+ static inline const DisplayModePtr kMode60 = createDisplayMode(kModeId60, 60_Hz);
+ static inline const DisplayModePtr kMode90 = createDisplayMode(kModeId90, 90_Hz);
+ static inline const DisplayModePtr kMode120 = createDisplayMode(kModeId120, 120_Hz);
};
TEST_F(InitiateModeChangeTest, setDesiredActiveMode_setCurrentMode) {
- EXPECT_FALSE(mDisplay->setDesiredActiveMode({kDisplayMode60, Event::None}));
+ EXPECT_FALSE(mDisplay->setDesiredActiveMode({kMode60, Event::None}));
EXPECT_EQ(std::nullopt, mDisplay->getDesiredActiveMode());
}
TEST_F(InitiateModeChangeTest, setDesiredActiveMode_setNewMode) {
- EXPECT_TRUE(mDisplay->setDesiredActiveMode({kDisplayMode90, Event::None}));
+ EXPECT_TRUE(mDisplay->setDesiredActiveMode({kMode90, Event::None}));
ASSERT_NE(std::nullopt, mDisplay->getDesiredActiveMode());
- EXPECT_EQ(kDisplayMode90, mDisplay->getDesiredActiveMode()->mode);
+ EXPECT_EQ(kMode90, mDisplay->getDesiredActiveMode()->mode);
EXPECT_EQ(Event::None, mDisplay->getDesiredActiveMode()->event);
// Setting another mode should be cached but return false
- EXPECT_FALSE(mDisplay->setDesiredActiveMode({kDisplayMode120, Event::None}));
+ EXPECT_FALSE(mDisplay->setDesiredActiveMode({kMode120, Event::None}));
ASSERT_NE(std::nullopt, mDisplay->getDesiredActiveMode());
- EXPECT_EQ(kDisplayMode120, mDisplay->getDesiredActiveMode()->mode);
+ EXPECT_EQ(kMode120, mDisplay->getDesiredActiveMode()->mode);
EXPECT_EQ(Event::None, mDisplay->getDesiredActiveMode()->event);
}
TEST_F(InitiateModeChangeTest, clearDesiredActiveModeState) {
- EXPECT_TRUE(mDisplay->setDesiredActiveMode({kDisplayMode90, Event::None}));
+ EXPECT_TRUE(mDisplay->setDesiredActiveMode({kMode90, Event::None}));
ASSERT_NE(std::nullopt, mDisplay->getDesiredActiveMode());
mDisplay->clearDesiredActiveModeState();
@@ -113,9 +87,9 @@
}
TEST_F(InitiateModeChangeTest, initiateModeChange) NO_THREAD_SAFETY_ANALYSIS {
- EXPECT_TRUE(mDisplay->setDesiredActiveMode({kDisplayMode90, Event::None}));
+ EXPECT_TRUE(mDisplay->setDesiredActiveMode({kMode90, Event::None}));
ASSERT_NE(std::nullopt, mDisplay->getDesiredActiveMode());
- EXPECT_EQ(kDisplayMode90, mDisplay->getDesiredActiveMode()->mode);
+ EXPECT_EQ(kMode90, mDisplay->getDesiredActiveMode()->mode);
EXPECT_EQ(Event::None, mDisplay->getDesiredActiveMode()->event);
hal::VsyncPeriodChangeConstraints constraints{
@@ -126,7 +100,7 @@
EXPECT_EQ(OK,
mDisplay->initiateModeChange(*mDisplay->getDesiredActiveMode(), constraints,
&timeline));
- EXPECT_EQ(kDisplayMode90, mDisplay->getUpcomingActiveMode().mode);
+ EXPECT_EQ(kMode90, mDisplay->getUpcomingActiveMode().mode);
EXPECT_EQ(Event::None, mDisplay->getUpcomingActiveMode().event);
mDisplay->clearDesiredActiveModeState();
@@ -135,9 +109,9 @@
TEST_F(InitiateModeChangeTest, getUpcomingActiveMode_desiredActiveModeChanged)
NO_THREAD_SAFETY_ANALYSIS {
- EXPECT_TRUE(mDisplay->setDesiredActiveMode({kDisplayMode90, Event::None}));
+ EXPECT_TRUE(mDisplay->setDesiredActiveMode({kMode90, Event::None}));
ASSERT_NE(std::nullopt, mDisplay->getDesiredActiveMode());
- EXPECT_EQ(kDisplayMode90, mDisplay->getDesiredActiveMode()->mode);
+ EXPECT_EQ(kMode90, mDisplay->getDesiredActiveMode()->mode);
EXPECT_EQ(Event::None, mDisplay->getDesiredActiveMode()->event);
hal::VsyncPeriodChangeConstraints constraints{
@@ -148,21 +122,21 @@
EXPECT_EQ(OK,
mDisplay->initiateModeChange(*mDisplay->getDesiredActiveMode(), constraints,
&timeline));
- EXPECT_EQ(kDisplayMode90, mDisplay->getUpcomingActiveMode().mode);
+ EXPECT_EQ(kMode90, mDisplay->getUpcomingActiveMode().mode);
EXPECT_EQ(Event::None, mDisplay->getUpcomingActiveMode().event);
- EXPECT_FALSE(mDisplay->setDesiredActiveMode({kDisplayMode120, Event::None}));
+ EXPECT_FALSE(mDisplay->setDesiredActiveMode({kMode120, Event::None}));
ASSERT_NE(std::nullopt, mDisplay->getDesiredActiveMode());
- EXPECT_EQ(kDisplayMode120, mDisplay->getDesiredActiveMode()->mode);
+ EXPECT_EQ(kMode120, mDisplay->getDesiredActiveMode()->mode);
EXPECT_EQ(Event::None, mDisplay->getDesiredActiveMode()->event);
- EXPECT_EQ(kDisplayMode90, mDisplay->getUpcomingActiveMode().mode);
+ EXPECT_EQ(kMode90, mDisplay->getUpcomingActiveMode().mode);
EXPECT_EQ(Event::None, mDisplay->getUpcomingActiveMode().event);
EXPECT_EQ(OK,
mDisplay->initiateModeChange(*mDisplay->getDesiredActiveMode(), constraints,
&timeline));
- EXPECT_EQ(kDisplayMode120, mDisplay->getUpcomingActiveMode().mode);
+ EXPECT_EQ(kMode120, mDisplay->getUpcomingActiveMode().mode);
EXPECT_EQ(Event::None, mDisplay->getUpcomingActiveMode().event);
mDisplay->clearDesiredActiveModeState();
diff --git a/services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h b/services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h
index 54b8bcb..565c244 100644
--- a/services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h
+++ b/services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h
@@ -45,6 +45,7 @@
#include "TestableScheduler.h"
#include "TestableSurfaceFlinger.h"
#include "mock/DisplayHardware/MockComposer.h"
+#include "mock/DisplayHardware/MockDisplayMode.h"
#include "mock/DisplayHardware/MockPowerAdvisor.h"
#include "mock/MockEventThread.h"
#include "mock/MockNativeWindowSurface.h"
@@ -235,9 +236,9 @@
using CONNECTION_TYPE = DisplayConnectionTypeGetter<DisplayIdType>;
using HWC_DISPLAY_ID_OPT = HwcDisplayIdGetter<DisplayIdType>;
- // The display width and height
static constexpr int WIDTH = width;
static constexpr int HEIGHT = height;
+ static constexpr ui::Size RESOLUTION{WIDTH, HEIGHT};
static constexpr int GRALLOC_USAGE = grallocUsage;
@@ -262,7 +263,7 @@
static auto makeFakeExistingDisplayInjector(DisplayTransactionTest* test) {
auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder();
ceDisplayArgs.setId(DISPLAY_ID::get())
- .setPixels({WIDTH, HEIGHT})
+ .setPixels(RESOLUTION)
.setPowerAdvisor(&test->mPowerAdvisor);
auto compositionDisplay =
@@ -357,8 +358,7 @@
TestableSurfaceFlinger::FakeHwcDisplayInjector(displayId, HWC_DISPLAY_TYPE,
static_cast<bool>(DisplayVariant::PRIMARY))
.setHwcDisplayId(HWC_DISPLAY_ID)
- .setWidth(DisplayVariant::WIDTH)
- .setHeight(DisplayVariant::HEIGHT)
+ .setResolution(DisplayVariant::RESOLUTION)
.setActiveConfig(HWC_ACTIVE_CONFIG_ID)
.setPowerMode(INIT_POWER_MODE)
.inject(&test->mFlinger, test->mComposer);
@@ -381,7 +381,7 @@
auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
.setId(DisplayVariant::DISPLAY_ID::get())
- .setPixels({DisplayVariant::WIDTH, DisplayVariant::HEIGHT})
+ .setPixels(DisplayVariant::RESOLUTION)
.setIsSecure(static_cast<bool>(DisplayVariant::SECURE))
.setPowerAdvisor(&test->mPowerAdvisor)
.setName(std::string("Injected display for ") +
@@ -541,7 +541,7 @@
auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
.setId(Base::DISPLAY_ID::get())
- .setPixels({Base::WIDTH, Base::HEIGHT})
+ .setPixels(Base::RESOLUTION)
.setIsSecure(static_cast<bool>(Base::SECURE))
.setPowerAdvisor(&test->mPowerAdvisor)
.setName(std::string("Injected display for ") +
@@ -593,7 +593,7 @@
const auto displayId = Base::DISPLAY_ID::get();
auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
.setId(displayId)
- .setPixels({Base::WIDTH, Base::HEIGHT})
+ .setPixels(Base::RESOLUTION)
.setIsSecure(static_cast<bool>(Base::SECURE))
.setPowerAdvisor(&test->mPowerAdvisor)
.setName(std::string("Injected display for ") +
@@ -736,6 +736,12 @@
HdrNotSupportedVariant<SimpleHwcVirtualDisplayVariant>,
NoPerFrameMetadataSupportVariant<SimpleHwcVirtualDisplayVariant>>;
+inline DisplayModePtr createDisplayMode(DisplayModeId modeId, Fps refreshRate, int32_t group = 0,
+ ui::Size resolution = ui::Size(1920, 1080)) {
+ return mock::createDisplayMode(modeId, refreshRate, group, resolution,
+ PrimaryDisplayVariant::DISPLAY_ID::get());
+}
+
} // namespace android
// TODO(b/129481165): remove the #pragma below and fix conversion issues
diff --git a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
index e108bea..17511cd 100644
--- a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
+++ b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
@@ -31,6 +31,7 @@
#include "Scheduler/LayerInfo.h"
#include "TestableScheduler.h"
#include "TestableSurfaceFlinger.h"
+#include "mock/DisplayHardware/MockDisplayMode.h"
#include "mock/MockLayer.h"
#include "mock/MockSchedulerCallback.h"
@@ -42,6 +43,8 @@
using MockLayer = android::mock::MockLayer;
+using android::mock::createDisplayMode;
+
class LayerHistoryTest : public testing::Test {
protected:
static constexpr auto PRESENT_TIME_HISTORY_SIZE = LayerInfo::HISTORY_SIZE;
@@ -122,22 +125,12 @@
ASSERT_EQ(desiredRefreshRate, summary[0].desiredRefreshRate);
}
- std::shared_ptr<RefreshRateConfigs> mConfigs = std::make_shared<
- RefreshRateConfigs>(DisplayModes{DisplayMode::Builder(0)
- .setId(DisplayModeId(0))
- .setPhysicalDisplayId(
- PhysicalDisplayId::fromPort(0))
- .setVsyncPeriod(int32_t(LO_FPS_PERIOD))
- .setGroup(0)
- .build(),
- DisplayMode::Builder(1)
- .setId(DisplayModeId(1))
- .setPhysicalDisplayId(
- PhysicalDisplayId::fromPort(0))
- .setVsyncPeriod(int32_t(HI_FPS_PERIOD))
- .setGroup(0)
- .build()},
- DisplayModeId(0));
+ std::shared_ptr<RefreshRateConfigs> mConfigs =
+ std::make_shared<RefreshRateConfigs>(makeModes(createDisplayMode(DisplayModeId(0),
+ LO_FPS),
+ createDisplayMode(DisplayModeId(1),
+ HI_FPS)),
+ DisplayModeId(0));
mock::SchedulerCallback mSchedulerCallback;
diff --git a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
index 97f3747..fcde532 100644
--- a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
+++ b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
@@ -25,46 +25,33 @@
#include "DisplayHardware/HWC2.h"
#include "FpsOps.h"
#include "Scheduler/RefreshRateConfigs.h"
+#include "mock/DisplayHardware/MockDisplayMode.h"
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;
-using RefreshRate = RefreshRateConfigs::RefreshRate;
using LayerVoteType = RefreshRateConfigs::LayerVoteType;
using LayerRequirement = RefreshRateConfigs::LayerRequirement;
+using mock::createDisplayMode;
+
struct TestableRefreshRateConfigs : RefreshRateConfigs {
using RefreshRateConfigs::RefreshRateConfigs;
- RefreshRate getMinSupportedRefreshRate() const {
+ DisplayModePtr getMinSupportedRefreshRate() const {
std::lock_guard lock(mLock);
- return *mMinSupportedRefreshRate;
+ return mMinRefreshRateModeIt->second;
}
- RefreshRate getMaxSupportedRefreshRate() const {
+ DisplayModePtr getMaxSupportedRefreshRate() const {
std::lock_guard lock(mLock);
- return *mMaxSupportedRefreshRate;
+ return mMaxRefreshRateModeIt->second;
}
- RefreshRate getMinRefreshRateByPolicy() const {
+ DisplayModePtr getMinRefreshRateByPolicy() const {
std::lock_guard lock(mLock);
return getMinRefreshRateByPolicyLocked();
}
@@ -79,8 +66,8 @@
return RefreshRateConfigs::getBestRefreshRate(layers, signals);
}
- RefreshRate getBestRefreshRate(const std::vector<LayerRequirement>& layers = {},
- GlobalSignals signals = {}) const {
+ DisplayModePtr getBestRefreshRate(const std::vector<LayerRequirement>& layers = {},
+ GlobalSignals signals = {}) const {
return getBestRefreshRateAndSignals(layers, signals).first;
}
};
@@ -90,10 +77,6 @@
RefreshRateConfigsTest();
~RefreshRateConfigsTest();
- static RefreshRate asRefreshRate(DisplayModePtr displayMode) {
- return {displayMode, RefreshRate::ConstructorTag(0)};
- }
-
static constexpr DisplayModeId kModeId60{0};
static constexpr DisplayModeId kModeId90{1};
static constexpr DisplayModeId kModeId72{2};
@@ -126,30 +109,30 @@
static inline const DisplayModePtr kMode24Frac = createDisplayMode(kModeId24Frac, 23.976_Hz);
// 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};
+ static inline const DisplayModes kModes_60 = makeModes(kMode60);
+ static inline const DisplayModes kModes_60_90 = makeModes(kMode60, kMode90);
+ static inline const DisplayModes kModes_60_90_G1 = makeModes(kMode60, kMode90_G1);
+ static inline const DisplayModes kModes_60_90_4K = makeModes(kMode60, kMode90_4K);
+ static inline const DisplayModes kModes_60_72_90 = makeModes(kMode60, kMode90, kMode72);
+ static inline const DisplayModes kModes_60_90_72_120 =
+ makeModes(kMode60, kMode90, kMode72, kMode120);
+ static inline const DisplayModes kModes_30_60_72_90_120 =
+ makeModes(kMode60, kMode90, kMode72, kMode120, kMode30);
- 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};
+ static inline const DisplayModes kModes_30_60 =
+ makeModes(kMode60, kMode90_G1, kMode72_G1, kMode120_G1, kMode30);
+ static inline const DisplayModes kModes_30_60_72_90 =
+ makeModes(kMode60, kMode90, kMode72, kMode120_G1, kMode30);
+ static inline const DisplayModes kModes_30_60_90 =
+ makeModes(kMode60, kMode90, kMode72_G1, kMode120_G1, kMode30);
+ static inline const DisplayModes kModes_25_30_50_60 =
+ makeModes(kMode60, kMode90, kMode72_G1, kMode120_G1, kMode30_G1, kMode25_G1, kMode50);
+ static inline const DisplayModes kModes_60_120 = makeModes(kMode60, kMode120);
// This is a typical TV configuration.
- static inline const DisplayModes kModes_24_25_30_50_60_Frac = {kMode24, kMode24Frac, kMode25,
- kMode30, kMode30Frac, kMode50,
- kMode60, kMode60Frac};
+ static inline const DisplayModes kModes_24_25_30_50_60_Frac =
+ makeModes(kMode24, kMode24Frac, kMode25, kMode30, kMode30Frac, kMode50, kMode60,
+ kMode60Frac);
};
RefreshRateConfigsTest::RefreshRateConfigsTest() {
@@ -183,8 +166,8 @@
const auto minRate = configs.getMinSupportedRefreshRate();
const auto performanceRate = configs.getMaxSupportedRefreshRate();
- EXPECT_EQ(asRefreshRate(kMode60), minRate);
- EXPECT_EQ(asRefreshRate(kMode90), performanceRate);
+ EXPECT_EQ(kMode60, minRate);
+ EXPECT_EQ(kMode90, performanceRate);
const auto minRateByPolicy = configs.getMinRefreshRateByPolicy();
const auto performanceRateByPolicy = configs.getMaxRefreshRateByPolicy();
@@ -201,19 +184,19 @@
const auto minRate60 = configs.getMinRefreshRateByPolicy();
const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
- EXPECT_EQ(asRefreshRate(kMode60), minRate);
- EXPECT_EQ(asRefreshRate(kMode60), minRate60);
- EXPECT_EQ(asRefreshRate(kMode60), performanceRate60);
+ EXPECT_EQ(kMode60, minRate);
+ EXPECT_EQ(kMode60, minRate60);
+ EXPECT_EQ(kMode60, performanceRate60);
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}), 0);
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(kModeId90);
const auto minRate90 = configs.getMinRefreshRateByPolicy();
const auto performanceRate90 = configs.getMaxRefreshRateByPolicy();
- EXPECT_EQ(asRefreshRate(kMode90_G1), performanceRate);
- EXPECT_EQ(asRefreshRate(kMode90_G1), minRate90);
- EXPECT_EQ(asRefreshRate(kMode90_G1), performanceRate90);
+ EXPECT_EQ(kMode90_G1, performanceRate);
+ EXPECT_EQ(kMode90_G1, minRate90);
+ EXPECT_EQ(kMode90_G1, performanceRate90);
}
TEST_F(RefreshRateConfigsTest, twoModes_storesFullRefreshRateMap_differentResolutions) {
@@ -224,19 +207,19 @@
const auto minRate60 = configs.getMinRefreshRateByPolicy();
const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
- EXPECT_EQ(asRefreshRate(kMode60), minRate);
- EXPECT_EQ(asRefreshRate(kMode60), minRate60);
- EXPECT_EQ(asRefreshRate(kMode60), performanceRate60);
+ EXPECT_EQ(kMode60, minRate);
+ EXPECT_EQ(kMode60, minRate60);
+ EXPECT_EQ(kMode60, performanceRate60);
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}), 0);
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(kModeId90);
const auto minRate90 = configs.getMinRefreshRateByPolicy();
const auto performanceRate90 = configs.getMaxRefreshRateByPolicy();
- EXPECT_EQ(asRefreshRate(kMode90_4K), performanceRate);
- EXPECT_EQ(asRefreshRate(kMode90_4K), minRate90);
- EXPECT_EQ(asRefreshRate(kMode90_4K), performanceRate90);
+ EXPECT_EQ(kMode90_4K, performanceRate);
+ EXPECT_EQ(kMode90_4K, minRate90);
+ EXPECT_EQ(kMode90_4K, performanceRate90);
}
TEST_F(RefreshRateConfigsTest, twoModes_policyChange) {
@@ -245,35 +228,35 @@
const auto minRate = configs.getMinRefreshRateByPolicy();
const auto performanceRate = configs.getMaxRefreshRateByPolicy();
- EXPECT_EQ(asRefreshRate(kMode60), minRate);
- EXPECT_EQ(asRefreshRate(kMode90), performanceRate);
+ EXPECT_EQ(kMode60, minRate);
+ EXPECT_EQ(kMode90, performanceRate);
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
const auto minRate60 = configs.getMinRefreshRateByPolicy();
const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
- EXPECT_EQ(asRefreshRate(kMode60), minRate60);
- EXPECT_EQ(asRefreshRate(kMode60), performanceRate60);
+ EXPECT_EQ(kMode60, minRate60);
+ EXPECT_EQ(kMode60, performanceRate60);
}
-TEST_F(RefreshRateConfigsTest, twoModes_getCurrentRefreshRate) {
+TEST_F(RefreshRateConfigsTest, twoModes_getActiveMode) {
TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
{
- const auto current = configs.getCurrentRefreshRate();
- EXPECT_EQ(current.getModeId(), kModeId60);
+ const auto mode = configs.getActiveMode();
+ EXPECT_EQ(mode->getId(), kModeId60);
}
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(kModeId90);
{
- const auto current = configs.getCurrentRefreshRate();
- EXPECT_EQ(current.getModeId(), kModeId90);
+ const auto mode = configs.getActiveMode();
+ EXPECT_EQ(mode->getId(), kModeId90);
}
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}), 0);
{
- const auto current = configs.getCurrentRefreshRate();
- EXPECT_EQ(current.getModeId(), kModeId90);
+ const auto mode = configs.getActiveMode();
+ EXPECT_EQ(mode->getId(), kModeId90);
}
}
@@ -283,10 +266,10 @@
// 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());
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate());
EXPECT_EQ(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), NO_ERROR);
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate());
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate());
}
{
// We select max even when this will cause a non-seamless switch.
@@ -294,7 +277,7 @@
constexpr bool kAllowGroupSwitching = true;
EXPECT_EQ(configs.setDisplayManagerPolicy({kModeId90, kAllowGroupSwitching, {0_Hz, 90_Hz}}),
NO_ERROR);
- EXPECT_EQ(asRefreshRate(kMode90_G1), configs.getBestRefreshRate());
+ EXPECT_EQ(kMode90_G1, configs.getBestRefreshRate());
}
}
@@ -306,104 +289,104 @@
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
lr.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.name = "";
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}), 0);
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {0_Hz, 120_Hz}}), 0);
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_multipleThreshold_60_90) {
@@ -414,32 +397,32 @@
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
lr.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_72_90) {
@@ -449,26 +432,26 @@
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90_120) {
@@ -482,19 +465,19 @@
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 48_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 48_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes) {
@@ -510,7 +493,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -518,7 +501,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -526,7 +509,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "60Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -534,7 +517,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -542,7 +525,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -550,7 +533,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
@@ -558,7 +541,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -566,7 +549,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -574,7 +557,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.name = "90Hz ExplicitExactOrMultiple";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes_multipleThreshold) {
@@ -591,7 +574,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -599,7 +582,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -607,7 +590,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "60Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -615,7 +598,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -623,7 +606,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -631,7 +614,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
@@ -639,7 +622,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -647,7 +630,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -655,7 +638,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.name = "90Hz ExplicitExactOrMultiple";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60) {
@@ -665,26 +648,26 @@
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90) {
@@ -695,42 +678,42 @@
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
lr.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 24_Hz;
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
lr.name = "24Hz ExplicitExactOrMultiple";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_PriorityTest) {
@@ -742,39 +725,39 @@
lr1.vote = LayerVoteType::Min;
lr2.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::Min;
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::Min;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::Max;
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::Max;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::Heuristic;
lr1.desiredRefreshRate = 15_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::Heuristic;
lr1.desiredRefreshRate = 30_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo) {
@@ -786,9 +769,9 @@
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
lr.desiredRefreshRate = Fps::fromValue(fps);
- const auto refreshRate = configs.getBestRefreshRate(layers);
- EXPECT_EQ(asRefreshRate(kMode60), refreshRate)
- << lr.desiredRefreshRate << " chooses " << refreshRate.getName();
+ const auto mode = configs.getBestRefreshRate(layers);
+ EXPECT_EQ(kMode60, mode) << lr.desiredRefreshRate << " chooses "
+ << to_string(mode->getFps());
}
}
@@ -802,9 +785,9 @@
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
lr.desiredRefreshRate = Fps::fromValue(fps);
- const auto refreshRate = configs.getBestRefreshRate(layers);
- EXPECT_EQ(asRefreshRate(kMode60), refreshRate)
- << lr.desiredRefreshRate << " chooses " << refreshRate.getName();
+ const auto mode = configs.getBestRefreshRate(layers);
+ EXPECT_EQ(kMode60, mode) << lr.desiredRefreshRate << " chooses "
+ << to_string(mode->getFps());
}
}
@@ -819,19 +802,19 @@
lr1.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitDefault;
lr1.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::Heuristic;
lr1.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_75HzContent) {
@@ -843,9 +826,9 @@
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
for (float fps = 75.0f; fps < 100.0f; fps += 0.1f) {
lr.desiredRefreshRate = Fps::fromValue(fps);
- const auto refreshRate = configs.getBestRefreshRate(layers, {});
- EXPECT_EQ(asRefreshRate(kMode90), refreshRate)
- << lr.desiredRefreshRate << " chooses " << refreshRate.getName();
+ const auto mode = configs.getBestRefreshRate(layers, {});
+ EXPECT_EQ(kMode90, mode) << lr.desiredRefreshRate << " chooses "
+ << to_string(mode->getFps());
}
}
@@ -862,7 +845,7 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
@@ -870,14 +853,14 @@
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 30_Hz;
@@ -885,14 +868,14 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) {
@@ -907,28 +890,28 @@
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::NoVote;
lr2.name = "NoVote";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
// The other layer starts to provide buffers
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -937,7 +920,7 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, touchConsidered) {
@@ -1023,8 +1006,7 @@
ss << "ExplicitDefault " << desired;
lr.name = ss.str();
- const auto refreshRate = configs.getBestRefreshRate(layers);
- EXPECT_EQ(refreshRate.getFps(), expected);
+ EXPECT_EQ(expected, configs.getBestRefreshRate(layers)->getFps());
}
}
@@ -1035,36 +1017,36 @@
// Test that 23.976 will choose 24 if 23.976 is not supported
{
- TestableRefreshRateConfigs configs({kMode24, kMode25, kMode30, kMode30Frac, kMode60,
- kMode60Frac},
+ TestableRefreshRateConfigs configs(makeModes(kMode24, kMode25, kMode30, kMode30Frac,
+ kMode60, kMode60Frac),
kModeId60);
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
lr.desiredRefreshRate = 23.976_Hz;
lr.name = "ExplicitExactOrMultiple 23.976 Hz";
- EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers)->getId());
}
// Test that 24 will choose 23.976 if 24 is not supported
{
- TestableRefreshRateConfigs configs({kMode24Frac, kMode25, kMode30, kMode30Frac, kMode60,
- kMode60Frac},
+ TestableRefreshRateConfigs configs(makeModes(kMode24Frac, kMode25, kMode30, kMode30Frac,
+ kMode60, kMode60Frac),
kModeId60);
lr.desiredRefreshRate = 24_Hz;
lr.name = "ExplicitExactOrMultiple 24 Hz";
- EXPECT_EQ(kModeId24Frac, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId24Frac, configs.getBestRefreshRate(layers)->getId());
}
// Test that 29.97 will prefer 59.94 over 60 and 30
{
- TestableRefreshRateConfigs configs({kMode24, kMode24Frac, kMode25, kMode30, kMode60,
- kMode60Frac},
+ TestableRefreshRateConfigs configs(makeModes(kMode24, kMode24Frac, kMode25, kMode30,
+ kMode60, kMode60Frac),
kModeId60);
lr.desiredRefreshRate = 29.97_Hz;
lr.name = "ExplicitExactOrMultiple 29.97 Hz";
- EXPECT_EQ(kModeId60Frac, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId60Frac, configs.getBestRefreshRate(layers)->getId());
}
}
@@ -1083,32 +1065,31 @@
ss << "ExplicitExact " << desired;
lr.name = ss.str();
- auto selectedRefreshRate = configs.getBestRefreshRate(layers);
- EXPECT_EQ(selectedRefreshRate.getFps(), lr.desiredRefreshRate);
+ EXPECT_EQ(lr.desiredRefreshRate, configs.getBestRefreshRate(layers)->getFps());
}
}
// Test that 23.976 will choose 24 if 23.976 is not supported
{
- TestableRefreshRateConfigs configs({kMode24, kMode25, kMode30, kMode30Frac, kMode60,
- kMode60Frac},
+ TestableRefreshRateConfigs configs(makeModes(kMode24, kMode25, kMode30, kMode30Frac,
+ kMode60, kMode60Frac),
kModeId60);
lr.vote = LayerVoteType::ExplicitExact;
lr.desiredRefreshRate = 23.976_Hz;
lr.name = "ExplicitExact 23.976 Hz";
- EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers)->getId());
}
// Test that 24 will choose 23.976 if 24 is not supported
{
- TestableRefreshRateConfigs configs({kMode24Frac, kMode25, kMode30, kMode30Frac, kMode60,
- kMode60Frac},
+ TestableRefreshRateConfigs configs(makeModes(kMode24Frac, kMode25, kMode30, kMode30Frac,
+ kMode60, kMode60Frac),
kModeId60);
lr.desiredRefreshRate = 24_Hz;
lr.name = "ExplicitExact 24 Hz";
- EXPECT_EQ(kModeId24Frac, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId24Frac, configs.getBestRefreshRate(layers)->getId());
}
}
@@ -1126,10 +1107,9 @@
lr.name = "60Hz ExplicitDefault";
lr.focused = true;
- const auto [refreshRate, signals] =
- configs.getBestRefreshRate(layers, {.touch = true, .idle = true});
+ const auto [mode, signals] = configs.getBestRefreshRate(layers, {.touch = true, .idle = true});
- EXPECT_EQ(refreshRate, asRefreshRate(kMode60));
+ EXPECT_EQ(mode, kMode60);
EXPECT_FALSE(signals.touch);
}
@@ -1146,7 +1126,7 @@
lr.desiredRefreshRate = 90_Hz;
lr.name = "90Hz ExplicitDefault";
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.idle = true}));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.idle = true}));
}
TEST_F(RefreshRateConfigsTest,
@@ -1155,8 +1135,8 @@
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
- const auto [refreshRate, signals] = configs.getBestRefreshRateAndSignals({}, {});
- EXPECT_EQ(refreshRate, asRefreshRate(kMode90));
+ const auto [mode, signals] = configs.getBestRefreshRateAndSignals({}, {});
+ EXPECT_EQ(mode, kMode90);
EXPECT_FALSE(signals.touch);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
@@ -1166,46 +1146,46 @@
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz ExplicitExactOrMultiple";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::ExplicitDefault;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz ExplicitDefault";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Heuristic;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Max";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Min;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Min";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, groupSwitchingNotAllowed) {
@@ -1221,7 +1201,7 @@
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayer) {
@@ -1239,7 +1219,7 @@
layer.seamlessness = Seamlessness::SeamedAndSeamless;
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamless) {
@@ -1258,7 +1238,7 @@
layer.seamlessness = Seamlessness::OnlySeamless;
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamlessDefaultFps) {
@@ -1269,7 +1249,7 @@
policy.allowGroupSwitching = true;
EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(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}};
@@ -1279,7 +1259,7 @@
layer.seamlessness = Seamlessness::OnlySeamless;
layer.name = "60Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerDefaultSeamlessness) {
@@ -1290,7 +1270,7 @@
policy.allowGroupSwitching = true;
EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(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.
@@ -1303,7 +1283,7 @@
layer.name = "60Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersOnlySeamlessAndSeamed) {
@@ -1314,7 +1294,7 @@
policy.allowGroupSwitching = true;
EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(kModeId90);
// If there's a layer with seamlessness=SeamedAndSeamless, another layer with
// seamlessness=OnlySeamless can't change the mode group.
@@ -1332,7 +1312,7 @@
layers[1].name = "90Hz ExplicitDefault";
layers[1].focused = false;
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultFocusedAndSeamed) {
@@ -1343,7 +1323,7 @@
policy.allowGroupSwitching = true;
EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(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
@@ -1365,7 +1345,7 @@
layers[1].vote = LayerVoteType::ExplicitDefault;
layers[1].name = "90Hz ExplicitDefault";
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed) {
@@ -1376,7 +1356,7 @@
policy.allowGroupSwitching = true;
EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(kModeId90);
// Layer with seamlessness=Default can change the mode group if there's a not
// focused layer with seamlessness=SeamedAndSeamless. This happens for example,
@@ -1395,7 +1375,7 @@
layers[1].vote = LayerVoteType::ExplicitDefault;
layers[1].name = "90Hz ExplicitDefault";
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, nonSeamlessVotePrefersSeamlessSwitches) {
@@ -1415,10 +1395,10 @@
layer.name = "60Hz ExplicitExactOrMultiple";
layer.focused = true;
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
- configs.setCurrentModeId(kModeId120);
- EXPECT_EQ(kModeId120, configs.getBestRefreshRate(layers).getModeId());
+ configs.setActiveModeId(kModeId120);
+ EXPECT_EQ(kModeId120, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, nonSeamlessExactAndSeamlessMultipleLayers) {
@@ -1443,14 +1423,14 @@
.weight = 1.f,
.focused = true}};
- EXPECT_EQ(kModeId50, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId50, configs.getBestRefreshRate(layers)->getId());
auto& seamedLayer = layers[0];
seamedLayer.desiredRefreshRate = 30_Hz;
seamedLayer.name = "30Hz ExplicitDefault";
- configs.setCurrentModeId(kModeId30);
+ configs.setActiveModeId(kModeId30);
- EXPECT_EQ(kModeId25, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId25, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, minLayersDontTrigerSeamedSwitch) {
@@ -1465,7 +1445,7 @@
std::vector<LayerRequirement> layers = {
{.name = "Min", .vote = LayerVoteType::Min, .weight = 1.f, .focused = true}};
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
}
TEST_F(RefreshRateConfigsTest, primaryVsAppRequestPolicy) {
@@ -1485,12 +1465,12 @@
layers[0].vote = voteType;
layers[0].desiredRefreshRate = fps;
layers[0].focused = args.focused;
- return configs.getBestRefreshRate(layers, {.touch = args.touch}).getModeId();
+ return configs.getBestRefreshRate(layers, {.touch = args.touch})->getId();
};
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {30_Hz, 60_Hz}, {30_Hz, 90_Hz}}), 0);
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate().getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate()->getId());
EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
EXPECT_EQ(kModeId30, getFrameRate(LayerVoteType::Min, 90_Hz));
EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz));
@@ -1537,7 +1517,7 @@
// Refresh rate will be chosen by either touch state or idle state.
EXPECT_EQ(!touchActive, signals.idle);
- return refreshRate.getModeId();
+ return refreshRate->getId();
};
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
@@ -1555,10 +1535,10 @@
}
// With no layers, idle should still be lower priority than touch boost.
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate({}, {.touch = true, .idle = true}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate({}, {.touch = true, .idle = true})->getId());
// Idle should be higher precedence than other layer frame rate considerations.
- configs.setCurrentModeId(kModeId90);
+ configs.setActiveModeId(kModeId90);
{
constexpr bool kTouchActive = false;
@@ -1572,7 +1552,7 @@
}
// Idle should be applied rather than the current config when there are no layers.
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate({}, {.idle = true}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate({}, {.idle = true})->getId());
}
TEST_F(RefreshRateConfigsTest, findClosestKnownFrameRate) {
@@ -1598,13 +1578,12 @@
struct Expectation {
Fps fps;
- const RefreshRate& refreshRate;
+ DisplayModePtr mode;
};
const std::initializer_list<Expectation> knownFrameRatesExpectations = {
- {24_Hz, asRefreshRate(kMode60)}, {30_Hz, asRefreshRate(kMode60)},
- {45_Hz, asRefreshRate(kMode90)}, {60_Hz, asRefreshRate(kMode60)},
- {72_Hz, asRefreshRate(kMode90)}, {90_Hz, asRefreshRate(kMode90)},
+ {24_Hz, kMode60}, {30_Hz, kMode60}, {45_Hz, kMode90},
+ {60_Hz, kMode60}, {72_Hz, kMode90}, {90_Hz, kMode90},
};
// Make sure the test tests all the known frame rate
@@ -1620,9 +1599,9 @@
auto& layer = layers[0];
layer.vote = LayerVoteType::Heuristic;
- for (const auto& [fps, refreshRate] : knownFrameRatesExpectations) {
+ for (const auto& [fps, mode] : knownFrameRatesExpectations) {
layer.desiredRefreshRate = fps;
- EXPECT_EQ(refreshRate, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(mode, configs.getBestRefreshRate(layers));
}
}
@@ -1641,21 +1620,21 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
explicitExactLayer.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 72_Hz;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 120_Hz;
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactEnableFrameRateOverride) {
@@ -1674,21 +1653,21 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
explicitExactLayer.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 72_Hz;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 120_Hz;
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ReadsCache) {
@@ -1697,7 +1676,7 @@
using GlobalSignals = RefreshRateConfigs::GlobalSignals;
const auto args = std::make_pair(std::vector<LayerRequirement>{},
GlobalSignals{.touch = true, .idle = true});
- const auto result = std::make_pair(asRefreshRate(kMode90), GlobalSignals{.touch = true});
+ const auto result = std::make_pair(kMode90, GlobalSignals{.touch = true});
configs.mutableGetBestRefreshRateCache() = {args, result};
@@ -1736,13 +1715,13 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.vote = LayerVoteType::NoVote;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {.touch = true}));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers, {.touch = true}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_FractionalRefreshRates_ExactAndDefault) {
@@ -1761,7 +1740,7 @@
explicitDefaultLayer.name = "ExplicitDefault";
explicitDefaultLayer.desiredRefreshRate = 59.94_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
+ EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
}
// b/190578904
@@ -1771,17 +1750,20 @@
DisplayModes displayModes;
for (int fps = kMinRefreshRate; fps < kMaxRefreshRate; fps++) {
- displayModes.push_back(
- createDisplayMode(DisplayModeId(fps), Fps::fromValue(static_cast<float>(fps))));
+ const DisplayModeId modeId(fps);
+ displayModes.try_emplace(modeId,
+ createDisplayMode(modeId,
+ Fps::fromValue(static_cast<float>(fps))));
}
- const TestableRefreshRateConfigs configs(displayModes, displayModes[0]->getId());
+ const TestableRefreshRateConfigs configs(std::move(displayModes),
+ DisplayModeId(kMinRefreshRate));
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(), configs.getBestRefreshRate(layers).getFps().getIntValue())
+ EXPECT_EQ(fps.getIntValue(), configs.getBestRefreshRate(layers)->getFps().getIntValue())
<< "Failed for " << ftl::enum_string(vote);
};
@@ -1796,15 +1778,14 @@
// b/190578904
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_conflictingVotes) {
- const DisplayModes displayModes = {
- createDisplayMode(DisplayModeId(0), 43_Hz),
- createDisplayMode(DisplayModeId(1), 53_Hz),
- createDisplayMode(DisplayModeId(2), 55_Hz),
- createDisplayMode(DisplayModeId(3), 60_Hz),
- };
+ constexpr DisplayModeId kActiveModeId{0};
+ DisplayModes displayModes = makeModes(createDisplayMode(kActiveModeId, 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};
- const TestableRefreshRateConfigs configs(displayModes, displayModes[0]->getId());
+ const TestableRefreshRateConfigs configs(std::move(displayModes), kActiveModeId);
const std::vector<LayerRequirement> layers = {
{
@@ -1821,13 +1802,13 @@
},
};
- EXPECT_EQ(53_Hz, configs.getBestRefreshRate(layers, globalSignals).getFps());
+ EXPECT_EQ(53_Hz, configs.getBestRefreshRate(layers, globalSignals)->getFps());
}
-TEST_F(RefreshRateConfigsTest, testComparisonOperator) {
- EXPECT_TRUE(asRefreshRate(kMode60) < asRefreshRate(kMode90));
- EXPECT_FALSE(asRefreshRate(kMode60) < asRefreshRate(kMode60));
- EXPECT_FALSE(asRefreshRate(kMode90) < asRefreshRate(kMode90));
+TEST_F(RefreshRateConfigsTest, modeComparison) {
+ EXPECT_LT(kMode60->getFps(), kMode90->getFps());
+ EXPECT_GE(kMode60->getFps(), kMode60->getFps());
+ EXPECT_GE(kMode90->getFps(), kMode90->getFps());
}
TEST_F(RefreshRateConfigsTest, testKernelIdleTimerAction) {
@@ -1877,27 +1858,27 @@
RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId30);
const auto frameRate = 30_Hz;
- Fps displayRefreshRate = configs.getCurrentRefreshRate().getFps();
+ Fps displayRefreshRate = configs.getActiveMode()->getFps();
EXPECT_EQ(1, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
- configs.setCurrentModeId(kModeId60);
- displayRefreshRate = configs.getCurrentRefreshRate().getFps();
+ configs.setActiveModeId(kModeId60);
+ displayRefreshRate = configs.getActiveMode()->getFps();
EXPECT_EQ(2, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
- configs.setCurrentModeId(kModeId72);
- displayRefreshRate = configs.getCurrentRefreshRate().getFps();
+ configs.setActiveModeId(kModeId72);
+ displayRefreshRate = configs.getActiveMode()->getFps();
EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
- configs.setCurrentModeId(kModeId90);
- displayRefreshRate = configs.getCurrentRefreshRate().getFps();
+ configs.setActiveModeId(kModeId90);
+ displayRefreshRate = configs.getActiveMode()->getFps();
EXPECT_EQ(3, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
- configs.setCurrentModeId(kModeId120);
- displayRefreshRate = configs.getCurrentRefreshRate().getFps();
+ configs.setActiveModeId(kModeId120);
+ displayRefreshRate = configs.getActiveMode()->getFps();
EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
- configs.setCurrentModeId(kModeId90);
- displayRefreshRate = configs.getCurrentRefreshRate().getFps();
+ configs.setActiveModeId(kModeId90);
+ displayRefreshRate = configs.getActiveMode()->getFps();
EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, 22.5_Hz));
EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivisor(24_Hz, 25_Hz));
diff --git a/services/surfaceflinger/tests/unittests/RefreshRateStatsTest.cpp b/services/surfaceflinger/tests/unittests/RefreshRateStatsTest.cpp
index df4a9c4..e2e3d7b 100644
--- a/services/surfaceflinger/tests/unittests/RefreshRateStatsTest.cpp
+++ b/services/surfaceflinger/tests/unittests/RefreshRateStatsTest.cpp
@@ -21,8 +21,6 @@
#include <log/log.h>
#include <thread>
-#include "DisplayHardware/DisplayMode.h"
-#include "Scheduler/RefreshRateConfigs.h"
#include "Scheduler/RefreshRateStats.h"
#include "mock/MockTimeStats.h"
@@ -35,29 +33,15 @@
class RefreshRateStatsTest : public testing::Test {
protected:
- static inline const auto CONFIG_ID_0 = DisplayModeId(0);
- static inline const auto CONFIG_ID_1 = DisplayModeId(1);
- static inline const auto CONFIG_GROUP_0 = 0;
- static constexpr int64_t VSYNC_90 = 11111111;
- static constexpr int64_t VSYNC_60 = 16666667;
-
RefreshRateStatsTest();
~RefreshRateStatsTest();
- void init(const DisplayModes& configs) {
- mRefreshRateConfigs =
- std::make_unique<RefreshRateConfigs>(configs, /*currentConfig=*/CONFIG_ID_0);
-
- const auto currFps = mRefreshRateConfigs->getRefreshRateFromModeId(CONFIG_ID_0).getFps();
- mRefreshRateStats = std::make_unique<RefreshRateStats>(mTimeStats, currFps,
- /*currentPowerMode=*/PowerMode::OFF);
+ void resetStats(Fps fps) {
+ mRefreshRateStats = std::make_unique<RefreshRateStats>(mTimeStats, fps, PowerMode::OFF);
}
mock::TimeStats mTimeStats;
- std::unique_ptr<RefreshRateConfigs> mRefreshRateConfigs;
std::unique_ptr<RefreshRateStats> mRefreshRateStats;
-
- DisplayModePtr createDisplayMode(DisplayModeId modeId, int32_t group, int64_t vsyncPeriod);
};
RefreshRateStatsTest::RefreshRateStatsTest() {
@@ -72,20 +56,10 @@
ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
}
-DisplayModePtr RefreshRateStatsTest::createDisplayMode(DisplayModeId modeId, int32_t group,
- int64_t vsyncPeriod) {
- return DisplayMode::Builder(static_cast<hal::HWConfigId>(modeId.value()))
- .setId(modeId)
- .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
- .setVsyncPeriod(static_cast<int32_t>(vsyncPeriod))
- .setGroup(group)
- .build();
-}
-
namespace {
-TEST_F(RefreshRateStatsTest, oneConfigTest) {
- init({createDisplayMode(CONFIG_ID_0, CONFIG_GROUP_0, VSYNC_90)});
+TEST_F(RefreshRateStatsTest, oneMode) {
+ resetStats(90_Hz);
EXPECT_CALL(mTimeStats, recordRefreshRate(0, _)).Times(AtLeast(1));
EXPECT_CALL(mTimeStats, recordRefreshRate(90, _)).Times(AtLeast(1));
@@ -102,8 +76,7 @@
EXPECT_LT(screenOff, times.get("ScreenOff")->get());
EXPECT_FALSE(times.contains("90.00 Hz"));
- const auto config0Fps = mRefreshRateConfigs->getRefreshRateFromModeId(CONFIG_ID_0).getFps();
- mRefreshRateStats->setRefreshRate(config0Fps);
+ mRefreshRateStats->setRefreshRate(90_Hz);
mRefreshRateStats->setPowerMode(PowerMode::ON);
screenOff = mRefreshRateStats->getTotalTimes().get("ScreenOff")->get();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
@@ -121,20 +94,18 @@
EXPECT_LT(screenOff, times.get("ScreenOff")->get());
EXPECT_EQ(ninety, times.get("90.00 Hz")->get());
- mRefreshRateStats->setRefreshRate(config0Fps);
+ mRefreshRateStats->setRefreshRate(90_Hz);
screenOff = mRefreshRateStats->getTotalTimes().get("ScreenOff")->get();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
times = mRefreshRateStats->getTotalTimes();
- // Because the power mode is not PowerMode::ON, switching the config
- // does not update refresh rates that come from the config.
+ // Stats are not updated while the screen is off.
EXPECT_LT(screenOff, times.get("ScreenOff")->get());
EXPECT_EQ(ninety, times.get("90.00 Hz")->get());
}
-TEST_F(RefreshRateStatsTest, twoConfigsTest) {
- init({createDisplayMode(CONFIG_ID_0, CONFIG_GROUP_0, VSYNC_90),
- createDisplayMode(CONFIG_ID_1, CONFIG_GROUP_0, VSYNC_60)});
+TEST_F(RefreshRateStatsTest, twoModes) {
+ resetStats(90_Hz);
EXPECT_CALL(mTimeStats, recordRefreshRate(0, _)).Times(AtLeast(1));
EXPECT_CALL(mTimeStats, recordRefreshRate(60, _)).Times(AtLeast(1));
@@ -153,9 +124,7 @@
EXPECT_FALSE(times.contains("60.00 Hz"));
EXPECT_FALSE(times.contains("90.00 Hz"));
- const auto config0Fps = mRefreshRateConfigs->getRefreshRateFromModeId(CONFIG_ID_0).getFps();
- const auto config1Fps = mRefreshRateConfigs->getRefreshRateFromModeId(CONFIG_ID_1).getFps();
- mRefreshRateStats->setRefreshRate(config0Fps);
+ mRefreshRateStats->setRefreshRate(90_Hz);
mRefreshRateStats->setPowerMode(PowerMode::ON);
screenOff = mRefreshRateStats->getTotalTimes().get("ScreenOff")->get();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
@@ -165,8 +134,7 @@
ASSERT_TRUE(times.contains("90.00 Hz"));
EXPECT_LT(0ms, times.get("90.00 Hz")->get());
- // When power mode is normal, time for configs updates.
- mRefreshRateStats->setRefreshRate(config1Fps);
+ mRefreshRateStats->setRefreshRate(60_Hz);
auto ninety = mRefreshRateStats->getTotalTimes().get("90.00 Hz")->get();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
times = mRefreshRateStats->getTotalTimes();
@@ -176,7 +144,7 @@
ASSERT_TRUE(times.contains("60.00 Hz"));
EXPECT_LT(0ms, times.get("60.00 Hz")->get());
- mRefreshRateStats->setRefreshRate(config0Fps);
+ mRefreshRateStats->setRefreshRate(90_Hz);
auto sixty = mRefreshRateStats->getTotalTimes().get("60.00 Hz")->get();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
times = mRefreshRateStats->getTotalTimes();
@@ -185,7 +153,7 @@
EXPECT_LT(ninety, times.get("90.00 Hz")->get());
EXPECT_EQ(sixty, times.get("60.00 Hz")->get());
- mRefreshRateStats->setRefreshRate(config1Fps);
+ mRefreshRateStats->setRefreshRate(60_Hz);
ninety = mRefreshRateStats->getTotalTimes().get("90.00 Hz")->get();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
times = mRefreshRateStats->getTotalTimes();
@@ -194,10 +162,9 @@
EXPECT_EQ(ninety, times.get("90.00 Hz")->get());
EXPECT_LT(sixty, times.get("60.00 Hz")->get());
- // Because the power mode is not PowerMode::ON, switching the config
- // does not update refresh rates that come from the config.
+ // Stats are not updated while the screen is off.
mRefreshRateStats->setPowerMode(PowerMode::DOZE);
- mRefreshRateStats->setRefreshRate(config0Fps);
+ mRefreshRateStats->setRefreshRate(90_Hz);
sixty = mRefreshRateStats->getTotalTimes().get("60.00 Hz")->get();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
times = mRefreshRateStats->getTotalTimes();
@@ -206,7 +173,7 @@
EXPECT_EQ(ninety, times.get("90.00 Hz")->get());
EXPECT_EQ(sixty, times.get("60.00 Hz")->get());
- mRefreshRateStats->setRefreshRate(config1Fps);
+ mRefreshRateStats->setRefreshRate(60_Hz);
screenOff = mRefreshRateStats->getTotalTimes().get("ScreenOff")->get();
std::this_thread::sleep_for(std::chrono::milliseconds(2));
times = mRefreshRateStats->getTotalTimes();
diff --git a/services/surfaceflinger/tests/unittests/SchedulerTest.cpp b/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
index a992a91..aab2795 100644
--- a/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
@@ -24,12 +24,15 @@
#include "Scheduler/RefreshRateConfigs.h"
#include "TestableScheduler.h"
#include "TestableSurfaceFlinger.h"
+#include "mock/DisplayHardware/MockDisplayMode.h"
#include "mock/MockEventThread.h"
#include "mock/MockLayer.h"
#include "mock/MockSchedulerCallback.h"
namespace android::scheduler {
+using android::mock::createDisplayMode;
+
using testing::_;
using testing::Return;
@@ -55,21 +58,11 @@
SchedulerTest();
- const DisplayModePtr mode60 = DisplayMode::Builder(0)
- .setId(DisplayModeId(0))
- .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
- .setVsyncPeriod((60_Hz).getPeriodNsecs())
- .setGroup(0)
- .build();
- const DisplayModePtr mode120 = DisplayMode::Builder(1)
- .setId(DisplayModeId(1))
- .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
- .setVsyncPeriod((120_Hz).getPeriodNsecs())
- .setGroup(0)
- .build();
+ static inline const DisplayModePtr kMode60 = createDisplayMode(DisplayModeId(0), 60_Hz);
+ static inline const DisplayModePtr kMode120 = createDisplayMode(DisplayModeId(1), 120_Hz);
std::shared_ptr<RefreshRateConfigs> mConfigs =
- std::make_shared<RefreshRateConfigs>(DisplayModes{mode60}, mode60->getId());
+ std::make_shared<RefreshRateConfigs>(makeModes(kMode60), kMode60->getId());
mock::SchedulerCallback mSchedulerCallback;
TestableScheduler* mScheduler = new TestableScheduler{mConfigs, mSchedulerCallback};
@@ -172,7 +165,7 @@
constexpr uint32_t kDisplayArea = 999'999;
mScheduler->onActiveDisplayAreaChanged(kDisplayArea);
- EXPECT_CALL(mSchedulerCallback, changeRefreshRate(_, _)).Times(0);
+ EXPECT_CALL(mSchedulerCallback, requestDisplayMode(_, _)).Times(0);
mScheduler->chooseRefreshRateForContent();
}
@@ -182,7 +175,7 @@
ASSERT_EQ(1u, mScheduler->layerHistorySize());
mScheduler->setRefreshRateConfigs(
- std::make_shared<RefreshRateConfigs>(DisplayModes{mode60, mode120}, mode60->getId()));
+ std::make_shared<RefreshRateConfigs>(makeModes(kMode60, kMode120), kMode60->getId()));
ASSERT_EQ(0u, mScheduler->getNumActiveLayers());
mScheduler->recordLayerHistory(layer.get(), 0, LayerHistory::LayerUpdateType::Buffer);
@@ -221,12 +214,12 @@
}
MATCHER(Is120Hz, "") {
- return isApproxEqual(arg.getFps(), 120_Hz);
+ return isApproxEqual(arg->getFps(), 120_Hz);
}
TEST_F(SchedulerTest, chooseRefreshRateForContentSelectsMaxRefreshRate) {
mScheduler->setRefreshRateConfigs(
- std::make_shared<RefreshRateConfigs>(DisplayModes{mode60, mode120}, mode60->getId()));
+ std::make_shared<RefreshRateConfigs>(makeModes(kMode60, kMode120), kMode60->getId()));
const sp<MockLayer> layer = sp<MockLayer>::make(mFlinger.flinger());
EXPECT_CALL(*layer, isVisible()).WillOnce(Return(true));
@@ -239,11 +232,11 @@
constexpr uint32_t kDisplayArea = 999'999;
mScheduler->onActiveDisplayAreaChanged(kDisplayArea);
- EXPECT_CALL(mSchedulerCallback, changeRefreshRate(Is120Hz(), _)).Times(1);
+ EXPECT_CALL(mSchedulerCallback, requestDisplayMode(Is120Hz(), _)).Times(1);
mScheduler->chooseRefreshRateForContent();
// No-op if layer requirements have not changed.
- EXPECT_CALL(mSchedulerCallback, changeRefreshRate(_, _)).Times(0);
+ EXPECT_CALL(mSchedulerCallback, requestDisplayMode(_, _)).Times(0);
mScheduler->chooseRefreshRateForContent();
}
diff --git a/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp b/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp
index 3205952..32d57b5 100644
--- a/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp
+++ b/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp
@@ -43,13 +43,11 @@
mFlinger.onComposerHalHotplug(PrimaryDisplayVariant::HWC_DISPLAY_ID, Connection::CONNECTED);
{
- DisplayModes modes = {kDisplayMode60, kDisplayMode90, kDisplayMode120,
- kDisplayMode90DifferentResolution};
- const DisplayModeId activeModeId = kDisplayModeId60;
- auto configs = std::make_shared<scheduler::RefreshRateConfigs>(modes, activeModeId);
+ DisplayModes modes = makeModes(kMode60, kMode90, kMode120, kMode90_4K);
+ auto configs = std::make_shared<scheduler::RefreshRateConfigs>(modes, kModeId60);
mDisplay = PrimaryDisplayVariant::makeFakeExistingDisplayInjector(this)
- .setDisplayModes(modes, activeModeId, std::move(configs))
+ .setDisplayModes(std::move(modes), kModeId60, std::move(configs))
.inject();
}
@@ -68,49 +66,18 @@
sp<DisplayDevice> mDisplay;
mock::EventThread* mAppEventThread;
- const DisplayModeId kDisplayModeId60 = DisplayModeId(0);
- const DisplayModePtr kDisplayMode60 =
- DisplayMode::Builder(hal::HWConfigId(kDisplayModeId60.value()))
- .setId(kDisplayModeId60)
- .setPhysicalDisplayId(PrimaryDisplayVariant::DISPLAY_ID::get())
- .setVsyncPeriod((60_Hz).getPeriodNsecs())
- .setGroup(0)
- .setHeight(1000)
- .setWidth(1000)
- .build();
+ static constexpr DisplayModeId kModeId60{0};
+ static constexpr DisplayModeId kModeId90{1};
+ static constexpr DisplayModeId kModeId120{2};
+ static constexpr DisplayModeId kModeId90_4K{3};
- const DisplayModeId kDisplayModeId90 = DisplayModeId(1);
- const DisplayModePtr kDisplayMode90 =
- DisplayMode::Builder(hal::HWConfigId(kDisplayModeId90.value()))
- .setId(kDisplayModeId90)
- .setPhysicalDisplayId(PrimaryDisplayVariant::DISPLAY_ID::get())
- .setVsyncPeriod((90_Hz).getPeriodNsecs())
- .setGroup(1)
- .setHeight(1000)
- .setWidth(1000)
- .build();
+ static inline const DisplayModePtr kMode60 = createDisplayMode(kModeId60, 60_Hz, 0);
+ static inline const DisplayModePtr kMode90 = createDisplayMode(kModeId90, 90_Hz, 1);
+ static inline const DisplayModePtr kMode120 = createDisplayMode(kModeId120, 120_Hz, 2);
- const DisplayModeId kDisplayModeId120 = DisplayModeId(2);
- const DisplayModePtr kDisplayMode120 =
- DisplayMode::Builder(hal::HWConfigId(kDisplayModeId120.value()))
- .setId(kDisplayModeId120)
- .setPhysicalDisplayId(PrimaryDisplayVariant::DISPLAY_ID::get())
- .setVsyncPeriod((120_Hz).getPeriodNsecs())
- .setGroup(2)
- .setHeight(1000)
- .setWidth(1000)
- .build();
-
- const DisplayModeId kDisplayModeId90DifferentResolution = DisplayModeId(3);
- const DisplayModePtr kDisplayMode90DifferentResolution =
- DisplayMode::Builder(hal::HWConfigId(kDisplayModeId90DifferentResolution.value()))
- .setId(kDisplayModeId90DifferentResolution)
- .setPhysicalDisplayId(PrimaryDisplayVariant::DISPLAY_ID::get())
- .setVsyncPeriod((90_Hz).getPeriodNsecs())
- .setGroup(3)
- .setHeight(2000)
- .setWidth(2000)
- .build();
+ static constexpr ui::Size kResolution4K{3840, 2160};
+ static inline const DisplayModePtr kMode90_4K =
+ createDisplayMode(kModeId90_4K, 90_Hz, 3, kResolution4K);
};
void DisplayModeSwitchingTest::setupScheduler(
@@ -145,39 +112,39 @@
TEST_F(DisplayModeSwitchingTest, changeRefreshRate_OnActiveDisplay_WithRefreshRequired) {
ASSERT_FALSE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId60);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId60);
mFlinger.onActiveDisplayChanged(mDisplay);
- mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(),
- kDisplayModeId90.value(), false, 0.f, 120.f, 0.f, 120.f);
+ mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(), kModeId90.value(),
+ false, 0.f, 120.f, 0.f, 120.f);
ASSERT_TRUE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kDisplayModeId90);
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId60);
+ ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kModeId90);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId60);
// Verify that next commit will call setActiveConfigWithConstraints in HWC
const VsyncPeriodChangeTimeline timeline{.refreshRequired = true};
EXPECT_CALL(*mComposer,
setActiveConfigWithConstraints(PrimaryDisplayVariant::HWC_DISPLAY_ID,
- hal::HWConfigId(kDisplayModeId90.value()), _, _))
+ hal::HWConfigId(kModeId90.value()), _, _))
.WillOnce(DoAll(SetArgPointee<3>(timeline), Return(Error::NONE)));
mFlinger.commit();
Mock::VerifyAndClearExpectations(mComposer);
ASSERT_TRUE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId60);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId60);
// Verify that the next commit will complete the mode change and send
// a onModeChanged event to the framework.
- EXPECT_CALL(*mAppEventThread, onModeChanged(kDisplayMode90));
+ EXPECT_CALL(*mAppEventThread, onModeChanged(kMode90));
mFlinger.commit();
Mock::VerifyAndClearExpectations(mAppEventThread);
ASSERT_FALSE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId90);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId90);
}
TEST_F(DisplayModeSwitchingTest, changeRefreshRate_OnActiveDisplay_WithoutRefreshRequired) {
@@ -185,27 +152,27 @@
mFlinger.onActiveDisplayChanged(mDisplay);
- mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(),
- kDisplayModeId90.value(), true, 0.f, 120.f, 0.f, 120.f);
+ mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(), kModeId90.value(),
+ true, 0.f, 120.f, 0.f, 120.f);
ASSERT_TRUE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kDisplayModeId90);
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId60);
+ ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kModeId90);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId60);
// Verify that next commit will call setActiveConfigWithConstraints in HWC
// and complete the mode change.
const VsyncPeriodChangeTimeline timeline{.refreshRequired = false};
EXPECT_CALL(*mComposer,
setActiveConfigWithConstraints(PrimaryDisplayVariant::HWC_DISPLAY_ID,
- hal::HWConfigId(kDisplayModeId90.value()), _, _))
+ hal::HWConfigId(kModeId90.value()), _, _))
.WillOnce(DoAll(SetArgPointee<3>(timeline), Return(Error::NONE)));
- EXPECT_CALL(*mAppEventThread, onModeChanged(kDisplayMode90));
+ EXPECT_CALL(*mAppEventThread, onModeChanged(kMode90));
mFlinger.commit();
ASSERT_FALSE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId90);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId90);
}
TEST_F(DisplayModeSwitchingTest, twoConsecutiveSetDesiredDisplayModeSpecs) {
@@ -213,72 +180,72 @@
// is still being processed the later call will be respected.
ASSERT_FALSE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId60);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId60);
mFlinger.onActiveDisplayChanged(mDisplay);
- mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(),
- kDisplayModeId90.value(), false, 0.f, 120.f, 0.f, 120.f);
+ mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(), kModeId90.value(),
+ false, 0.f, 120.f, 0.f, 120.f);
const VsyncPeriodChangeTimeline timeline{.refreshRequired = true};
EXPECT_CALL(*mComposer,
setActiveConfigWithConstraints(PrimaryDisplayVariant::HWC_DISPLAY_ID,
- hal::HWConfigId(kDisplayModeId90.value()), _, _))
+ hal::HWConfigId(kModeId90.value()), _, _))
.WillOnce(DoAll(SetArgPointee<3>(timeline), Return(Error::NONE)));
mFlinger.commit();
- mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(),
- kDisplayModeId120.value(), false, 0.f, 180.f, 0.f, 180.f);
+ mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(), kModeId120.value(),
+ false, 0.f, 180.f, 0.f, 180.f);
ASSERT_TRUE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kDisplayModeId120);
+ ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kModeId120);
EXPECT_CALL(*mComposer,
setActiveConfigWithConstraints(PrimaryDisplayVariant::HWC_DISPLAY_ID,
- hal::HWConfigId(kDisplayModeId120.value()), _, _))
+ hal::HWConfigId(kModeId120.value()), _, _))
.WillOnce(DoAll(SetArgPointee<3>(timeline), Return(Error::NONE)));
mFlinger.commit();
ASSERT_TRUE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kDisplayModeId120);
+ ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kModeId120);
mFlinger.commit();
ASSERT_FALSE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId120);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId120);
}
TEST_F(DisplayModeSwitchingTest, changeResolution_OnActiveDisplay_WithoutRefreshRequired) {
ASSERT_FALSE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId60);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId60);
mFlinger.onActiveDisplayChanged(mDisplay);
- mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(),
- kDisplayModeId90DifferentResolution.value(), false, 0.f,
- 120.f, 0.f, 120.f);
+ mFlinger.setDesiredDisplayModeSpecs(mDisplay->getDisplayToken().promote(), kModeId90_4K.value(),
+ false, 0.f, 120.f, 0.f, 120.f);
ASSERT_TRUE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kDisplayModeId90DifferentResolution);
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId60);
+ ASSERT_EQ(mDisplay->getDesiredActiveMode()->mode->getId(), kModeId90_4K);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId60);
// Verify that next commit will call setActiveConfigWithConstraints in HWC
// and complete the mode change.
const VsyncPeriodChangeTimeline timeline{.refreshRequired = false};
EXPECT_CALL(*mComposer,
setActiveConfigWithConstraints(PrimaryDisplayVariant::HWC_DISPLAY_ID,
- hal::HWConfigId(
- kDisplayModeId90DifferentResolution.value()),
- _, _))
+ hal::HWConfigId(kModeId90_4K.value()), _, _))
.WillOnce(DoAll(SetArgPointee<3>(timeline), Return(Error::NONE)));
EXPECT_CALL(*mAppEventThread, onHotplugReceived(mDisplay->getPhysicalId(), true));
// Misc expecations. We don't need to enforce these method calls, but since the helper methods
// already set expectations we should add new ones here, otherwise the test will fail.
- EXPECT_CALL(*mConsumer, setDefaultBufferSize(2000, 2000)).WillOnce(Return(NO_ERROR));
+ EXPECT_CALL(*mConsumer,
+ setDefaultBufferSize(static_cast<uint32_t>(kResolution4K.getWidth()),
+ static_cast<uint32_t>(kResolution4K.getHeight())))
+ .WillOnce(Return(NO_ERROR));
EXPECT_CALL(*mConsumer, consumerConnect(_, false)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*mComposer, setClientTargetSlotCount(_)).WillOnce(Return(hal::Error::NONE));
@@ -296,7 +263,7 @@
mDisplay = mFlinger.getDisplay(displayToken);
ASSERT_FALSE(mDisplay->getDesiredActiveMode().has_value());
- ASSERT_EQ(mDisplay->getActiveMode()->getId(), kDisplayModeId90DifferentResolution);
+ ASSERT_EQ(mDisplay->getActiveMode()->getId(), kModeId90_4K);
}
} // namespace
diff --git a/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetupNewDisplayDeviceInternalTest.cpp b/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetupNewDisplayDeviceInternalTest.cpp
index 38dceb9..a0e078b 100644
--- a/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetupNewDisplayDeviceInternalTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetupNewDisplayDeviceInternalTest.cpp
@@ -240,19 +240,17 @@
ASSERT_TRUE(hwcDisplayId);
mFlinger.getHwComposer().allocatePhysicalDisplay(*hwcDisplayId, *displayId);
DisplayModePtr activeMode = DisplayMode::Builder(Case::Display::HWC_ACTIVE_CONFIG_ID)
- .setWidth(Case::Display::WIDTH)
- .setHeight(Case::Display::HEIGHT)
+ .setResolution(Case::Display::RESOLUTION)
.setVsyncPeriod(DEFAULT_VSYNC_PERIOD)
.setDpiX(DEFAULT_DPI)
.setDpiY(DEFAULT_DPI)
.setGroup(0)
.build();
- DisplayModes modes{activeMode};
state.physical = {.id = *displayId,
.type = *connectionType,
.hwcDisplayId = *hwcDisplayId,
- .supportedModes = modes,
- .activeMode = activeMode};
+ .supportedModes = makeModes(activeMode),
+ .activeMode = std::move(activeMode)};
}
state.isSecure = static_cast<bool>(Case::Display::SECURE);
@@ -270,8 +268,7 @@
EXPECT_EQ(static_cast<bool>(Case::Display::VIRTUAL), device->isVirtual());
EXPECT_EQ(static_cast<bool>(Case::Display::SECURE), device->isSecure());
EXPECT_EQ(static_cast<bool>(Case::Display::PRIMARY), device->isPrimary());
- EXPECT_EQ(Case::Display::WIDTH, device->getWidth());
- EXPECT_EQ(Case::Display::HEIGHT, device->getHeight());
+ EXPECT_EQ(Case::Display::RESOLUTION, device->getSize());
EXPECT_EQ(Case::WideColorSupport::WIDE_COLOR_SUPPORTED, device->hasWideColorGamut());
EXPECT_EQ(Case::HdrSupport::HDR10_PLUS_SUPPORTED, device->hasHDR10PlusSupport());
EXPECT_EQ(Case::HdrSupport::HDR10_SUPPORTED, device->hasHDR10Support());
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index fe0564e..aff4d83 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -45,6 +45,7 @@
#include "SurfaceInterceptor.h"
#include "TestableScheduler.h"
#include "mock/DisplayHardware/MockComposer.h"
+#include "mock/DisplayHardware/MockDisplayMode.h"
#include "mock/MockFrameTimeline.h"
#include "mock/MockFrameTracer.h"
#include "mock/MockSchedulerCallback.h"
@@ -227,31 +228,24 @@
if (std::holds_alternative<RefreshRateConfigsPtr>(modesVariant)) {
configs = std::move(std::get<RefreshRateConfigsPtr>(modesVariant));
} else {
- DisplayModes modes = {DisplayMode::Builder(0)
- .setId(DisplayModeId(0))
- .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
- .setVsyncPeriod(16'666'667)
- .setGroup(0)
- .build()};
+ constexpr DisplayModeId kModeId60{0};
+ DisplayModes modes = makeModes(mock::createDisplayMode(kModeId60, 60_Hz));
if (std::holds_alternative<TwoDisplayModes>(modesVariant)) {
- modes.emplace_back(DisplayMode::Builder(1)
- .setId(DisplayModeId(1))
- .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
- .setVsyncPeriod(11'111'111)
- .setGroup(0)
- .build());
+ constexpr DisplayModeId kModeId90{1};
+ modes.try_emplace(kModeId90, mock::createDisplayMode(kModeId90, 90_Hz));
}
- configs = std::make_shared<scheduler::RefreshRateConfigs>(modes, DisplayModeId(0));
+ configs = std::make_shared<scheduler::RefreshRateConfigs>(modes, kModeId60);
}
- const auto currFps = configs->getCurrentRefreshRate().getFps();
- mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(currFps);
+ const auto fps = configs->getActiveMode()->getFps();
+ mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);
mFlinger->mVsyncModulator = sp<scheduler::VsyncModulator>::make(
mFlinger->mVsyncConfiguration->getCurrentConfigs());
+
mFlinger->mRefreshRateStats =
- std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, currFps,
+ std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
hal::PowerMode::OFF);
using Callback = scheduler::ISchedulerCallback;
@@ -572,8 +566,7 @@
class FakeHwcDisplayInjector {
public:
static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
- static constexpr int32_t DEFAULT_WIDTH = 1920;
- static constexpr int32_t DEFAULT_HEIGHT = 1280;
+ static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280};
static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
static constexpr int32_t DEFAULT_DPI = 320;
@@ -589,17 +582,12 @@
return *this;
}
- auto& setWidth(int32_t width) {
- mWidth = width;
+ auto& setResolution(ui::Size resolution) {
+ mResolution = resolution;
return *this;
}
- auto& setHeight(int32_t height) {
- mHeight = height;
- return *this;
- }
-
- auto& setVsyncPeriod(int32_t vsyncPeriod) {
+ auto& setVsyncPeriod(nsecs_t vsyncPeriod) {
mVsyncPeriod = vsyncPeriod;
return *this;
}
@@ -660,18 +648,20 @@
EXPECT_CALL(*composer,
getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
- .WillRepeatedly(DoAll(SetArgPointee<3>(mWidth), Return(hal::Error::NONE)));
+ .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()),
+ Return(hal::Error::NONE)));
EXPECT_CALL(*composer,
getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
_))
- .WillRepeatedly(DoAll(SetArgPointee<3>(mHeight), Return(hal::Error::NONE)));
+ .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()),
+ Return(hal::Error::NONE)));
EXPECT_CALL(*composer,
getDisplayAttribute(mHwcDisplayId, mActiveConfig,
hal::Attribute::VSYNC_PERIOD, _))
- .WillRepeatedly(
- DoAll(SetArgPointee<3>(mVsyncPeriod), Return(hal::Error::NONE)));
+ .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)),
+ Return(hal::Error::NONE)));
EXPECT_CALL(*composer,
getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
@@ -708,9 +698,8 @@
const bool mIsPrimary;
hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
- int32_t mWidth = DEFAULT_WIDTH;
- int32_t mHeight = DEFAULT_HEIGHT;
- int32_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
+ ui::Size mResolution = DEFAULT_RESOLUTION;
+ nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
int32_t mDpiX = DEFAULT_DPI;
int32_t mDpiY = DEFAULT_DPI;
int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
@@ -723,12 +712,12 @@
class FakeDisplayDeviceInjector {
public:
FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
- std::shared_ptr<compositionengine::Display> compositionDisplay,
+ std::shared_ptr<compositionengine::Display> display,
std::optional<ui::DisplayConnectionType> connectionType,
std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
: mFlinger(flinger),
mCreationArgs(flinger.mFlinger.get(), flinger.mFlinger->getHwComposer(),
- mDisplayToken, compositionDisplay),
+ mDisplayToken, display),
mHwcDisplayId(hwcDisplayId) {
mCreationArgs.connectionType = connectionType;
mCreationArgs.isPrimary = isPrimary;
@@ -805,49 +794,52 @@
}
sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS {
+ const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
+
auto& modes = mCreationArgs.supportedModes;
auto& activeModeId = mCreationArgs.activeModeId;
- if (!mCreationArgs.refreshRateConfigs) {
- if (modes.empty()) {
- activeModeId = DisplayModeId(0);
- modes.emplace_back(
- DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
- .setId(activeModeId)
- .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
- .setWidth(FakeHwcDisplayInjector::DEFAULT_WIDTH)
- .setHeight(FakeHwcDisplayInjector::DEFAULT_HEIGHT)
- .setVsyncPeriod(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
- .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
- .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
- .setGroup(0)
- .build());
- }
+ if (displayId && !mCreationArgs.refreshRateConfigs) {
+ if (const auto physicalId = PhysicalDisplayId::tryCast(*displayId)) {
+ if (modes.empty()) {
+ constexpr DisplayModeId kModeId{0};
+ DisplayModePtr mode =
+ DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
+ .setId(kModeId)
+ .setPhysicalDisplayId(*physicalId)
+ .setResolution(FakeHwcDisplayInjector::DEFAULT_RESOLUTION)
+ .setVsyncPeriod(
+ FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
+ .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
+ .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
+ .setGroup(FakeHwcDisplayInjector::DEFAULT_CONFIG_GROUP)
+ .build();
- mCreationArgs.refreshRateConfigs =
- std::make_shared<scheduler::RefreshRateConfigs>(modes, activeModeId);
+ modes = ftl::init::map(kModeId, std::move(mode));
+ activeModeId = kModeId;
+ }
+
+ mCreationArgs.refreshRateConfigs =
+ std::make_shared<scheduler::RefreshRateConfigs>(modes, activeModeId);
+ }
}
DisplayDeviceState state;
if (const auto type = mCreationArgs.connectionType) {
- const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
LOG_ALWAYS_FATAL_IF(!displayId);
const auto physicalId = PhysicalDisplayId::tryCast(*displayId);
LOG_ALWAYS_FATAL_IF(!physicalId);
LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
- const auto it = std::find_if(modes.begin(), modes.end(),
- [&activeModeId](const DisplayModePtr& mode) {
- return mode->getId() == activeModeId;
- });
- LOG_ALWAYS_FATAL_IF(it == modes.end());
+ const auto activeMode = modes.get(activeModeId);
+ LOG_ALWAYS_FATAL_IF(!activeMode);
state.physical = {.id = *physicalId,
.type = *type,
.hwcDisplayId = *mHwcDisplayId,
.deviceProductInfo = {},
.supportedModes = modes,
- .activeMode = *it};
+ .activeMode = activeMode->get()};
}
state.isSecure = mCreationArgs.isSecure;
diff --git a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockDisplayMode.h b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockDisplayMode.h
new file mode 100644
index 0000000..a83ecbc
--- /dev/null
+++ b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockDisplayMode.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "DisplayHardware/DisplayMode.h"
+
+namespace android::mock {
+
+inline DisplayModePtr createDisplayMode(
+ DisplayModeId modeId, Fps refreshRate, int32_t group = 0,
+ ui::Size resolution = ui::Size(1920, 1080),
+ PhysicalDisplayId displayId = PhysicalDisplayId::fromPort(0)) {
+ return DisplayMode::Builder(hal::HWConfigId(modeId.value()))
+ .setId(modeId)
+ .setPhysicalDisplayId(displayId)
+ .setVsyncPeriod(refreshRate.getPeriodNsecs())
+ .setGroup(group)
+ .setResolution(resolution)
+ .build();
+}
+
+} // namespace android::mock
diff --git a/services/surfaceflinger/tests/unittests/mock/MockSchedulerCallback.h b/services/surfaceflinger/tests/unittests/mock/MockSchedulerCallback.h
index c90b8ed..5083d56 100644
--- a/services/surfaceflinger/tests/unittests/mock/MockSchedulerCallback.h
+++ b/services/surfaceflinger/tests/unittests/mock/MockSchedulerCallback.h
@@ -25,7 +25,7 @@
struct SchedulerCallback final : ISchedulerCallback {
MOCK_METHOD(void, scheduleComposite, (FrameHint), (override));
MOCK_METHOD(void, setVsyncEnabled, (bool), (override));
- MOCK_METHOD(void, changeRefreshRate, (const RefreshRate&, DisplayModeEvent), (override));
+ MOCK_METHOD(void, requestDisplayMode, (DisplayModePtr, DisplayModeEvent), (override));
MOCK_METHOD(void, kernelTimerChanged, (bool), (override));
MOCK_METHOD(void, triggerOnFrameRateOverridesChanged, (), (override));
};
@@ -33,7 +33,7 @@
struct NoOpSchedulerCallback final : ISchedulerCallback {
void scheduleComposite(FrameHint) override {}
void setVsyncEnabled(bool) override {}
- void changeRefreshRate(const RefreshRate&, DisplayModeEvent) override {}
+ void requestDisplayMode(DisplayModePtr, DisplayModeEvent) override {}
void kernelTimerChanged(bool) override {}
void triggerOnFrameRateOverridesChanged() override {}
};