SF: Simplify getBestRefreshRate caching
Cache the arguments/result as std::pair by removing the out parameter
for GlobalSignals.
Bug: 185535769
Test: libsurfaceflinger_unittest
Change-Id: Ibfb2aa4ca327b378844554bcd96620f84fc0460a
diff --git a/services/surfaceflinger/Scheduler/RefreshRateConfigs.cpp b/services/surfaceflinger/Scheduler/RefreshRateConfigs.cpp
index 3becb5c..3b9cfa6 100644
--- a/services/surfaceflinger/Scheduler/RefreshRateConfigs.cpp
+++ b/services/surfaceflinger/Scheduler/RefreshRateConfigs.cpp
@@ -38,6 +38,8 @@
namespace android::scheduler {
namespace {
+constexpr RefreshRateConfigs::GlobalSignals kNoSignals;
+
std::string formatLayerInfo(const RefreshRateConfigs::LayerRequirement& layer, float weight) {
return base::StringPrintf("%s (type=%s, weight=%.2f seamlessness=%s) %s", layer.name.c_str(),
ftl::enum_string(layer.vote).c_str(), weight,
@@ -235,63 +237,26 @@
float score;
};
-RefreshRate RefreshRateConfigs::getBestRefreshRate(const std::vector<LayerRequirement>& layers,
- GlobalSignals globalSignals,
- GlobalSignals* outSignalsConsidered) const {
+auto RefreshRateConfigs::getBestRefreshRate(const std::vector<LayerRequirement>& layers,
+ GlobalSignals signals) const
+ -> std::pair<RefreshRate, GlobalSignals> {
std::lock_guard lock(mLock);
- if (auto cached = getCachedBestRefreshRate(layers, globalSignals, outSignalsConsidered)) {
- return *cached;
+ if (mGetBestRefreshRateCache &&
+ mGetBestRefreshRateCache->arguments == std::make_pair(layers, signals)) {
+ return mGetBestRefreshRateCache->result;
}
- GlobalSignals signalsConsidered;
- RefreshRate result = getBestRefreshRateLocked(layers, globalSignals, &signalsConsidered);
- lastBestRefreshRateInvocation.emplace(
- GetBestRefreshRateInvocation{.layerRequirements = layers,
- .globalSignals = globalSignals,
- .outSignalsConsidered = signalsConsidered,
- .resultingBestRefreshRate = result});
- if (outSignalsConsidered) {
- *outSignalsConsidered = signalsConsidered;
- }
+ const auto result = getBestRefreshRateLocked(layers, signals);
+ mGetBestRefreshRateCache = GetBestRefreshRateCache{{layers, signals}, result};
return result;
}
-std::optional<RefreshRate> RefreshRateConfigs::getCachedBestRefreshRate(
- const std::vector<LayerRequirement>& layers, GlobalSignals globalSignals,
- GlobalSignals* outSignalsConsidered) const {
- const bool sameAsLastCall = lastBestRefreshRateInvocation &&
- lastBestRefreshRateInvocation->layerRequirements == layers &&
- lastBestRefreshRateInvocation->globalSignals == globalSignals;
-
- if (sameAsLastCall) {
- if (outSignalsConsidered) {
- *outSignalsConsidered = lastBestRefreshRateInvocation->outSignalsConsidered;
- }
- return lastBestRefreshRateInvocation->resultingBestRefreshRate;
- }
-
- return {};
-}
-
-RefreshRate RefreshRateConfigs::getBestRefreshRateLocked(
- const std::vector<LayerRequirement>& layers, GlobalSignals globalSignals,
- GlobalSignals* outSignalsConsidered) const {
+auto RefreshRateConfigs::getBestRefreshRateLocked(const std::vector<LayerRequirement>& layers,
+ GlobalSignals signals) const
+ -> std::pair<RefreshRate, GlobalSignals> {
ATRACE_CALL();
- ALOGV("getBestRefreshRate %zu layers", layers.size());
-
- if (outSignalsConsidered) *outSignalsConsidered = {};
- const auto setTouchConsidered = [&] {
- if (outSignalsConsidered) {
- outSignalsConsidered->touch = true;
- }
- };
-
- const auto setIdleConsidered = [&] {
- if (outSignalsConsidered) {
- outSignalsConsidered->idle = true;
- }
- };
+ ALOGV("%s: %zu layers", __func__, layers.size());
int noVoteLayers = 0;
int minVoteLayers = 0;
@@ -301,6 +266,7 @@
int explicitExact = 0;
float maxExplicitWeight = 0;
int seamedFocusedLayers = 0;
+
for (const auto& layer : layers) {
switch (layer.vote) {
case LayerVoteType::NoVote:
@@ -349,10 +315,9 @@
// Consider the touch event if there are no Explicit* layers. Otherwise wait until after we've
// selected a refresh rate to see if we should apply touch boost.
- if (globalSignals.touch && !hasExplicitVoteLayers) {
+ if (signals.touch && !hasExplicitVoteLayers) {
ALOGV("TouchBoost - choose %s", getMaxRefreshRateByPolicyLocked().getName().c_str());
- setTouchConsidered();
- return getMaxRefreshRateByPolicyLocked(anchorGroup);
+ return {getMaxRefreshRateByPolicyLocked(anchorGroup), GlobalSignals{.touch = true}};
}
// If the primary range consists of a single refresh rate then we can only
@@ -361,23 +326,21 @@
const bool primaryRangeIsSingleRate =
isApproxEqual(policy->primaryRange.min, policy->primaryRange.max);
- if (!globalSignals.touch && globalSignals.idle &&
- !(primaryRangeIsSingleRate && hasExplicitVoteLayers)) {
+ if (!signals.touch && signals.idle && !(primaryRangeIsSingleRate && hasExplicitVoteLayers)) {
ALOGV("Idle - choose %s", getMinRefreshRateByPolicyLocked().getName().c_str());
- setIdleConsidered();
- return getMinRefreshRateByPolicyLocked();
+ return {getMinRefreshRateByPolicyLocked(), GlobalSignals{.idle = true}};
}
if (layers.empty() || noVoteLayers == layers.size()) {
const auto& refreshRate = getMaxRefreshRateByPolicyLocked(anchorGroup);
ALOGV("no layers with votes - choose %s", refreshRate.getName().c_str());
- return refreshRate;
+ return {refreshRate, kNoSignals};
}
// Only if all layers want Min we should return Min
if (noVoteLayers + minVoteLayers == layers.size()) {
ALOGV("all layers Min - choose %s", getMinRefreshRateByPolicyLocked().getName().c_str());
- return getMinRefreshRateByPolicyLocked();
+ return {getMinRefreshRateByPolicyLocked(), kNoSignals};
}
// Find the best refresh rate based on score
@@ -466,9 +429,9 @@
[](RefreshRateScore score) { return score.score == 0; })) {
const auto& refreshRate = getMaxRefreshRateByPolicyLocked(anchorGroup);
ALOGV("layers not scored - choose %s", refreshRate.getName().c_str());
- return refreshRate;
+ return {refreshRate, kNoSignals};
} else {
- return *bestRefreshRate;
+ return {*bestRefreshRate, kNoSignals};
}
}
@@ -490,14 +453,13 @@
using fps_approx_ops::operator<;
- if (globalSignals.touch && explicitDefaultVoteLayers == 0 && touchBoostForExplicitExact &&
+ if (signals.touch && explicitDefaultVoteLayers == 0 && touchBoostForExplicitExact &&
bestRefreshRate->getFps() < touchRefreshRate.getFps()) {
- setTouchConsidered();
ALOGV("TouchBoost - choose %s", touchRefreshRate.getName().c_str());
- return touchRefreshRate;
+ return {touchRefreshRate, GlobalSignals{.touch = true}};
}
- return *bestRefreshRate;
+ return {*bestRefreshRate, kNoSignals};
}
std::unordered_map<uid_t, std::vector<const RefreshRateConfigs::LayerRequirement*>>
@@ -699,7 +661,7 @@
// Invalidate the cached invocation to getBestRefreshRate. This forces
// the refresh rate to be recomputed on the next call to getBestRefreshRate.
- lastBestRefreshRateInvocation.reset();
+ mGetBestRefreshRateCache.reset();
mCurrentRefreshRate = mRefreshRates.at(modeId).get();
}
@@ -741,7 +703,7 @@
// Invalidate the cached invocation to getBestRefreshRate. This forces
// the refresh rate to be recomputed on the next call to getBestRefreshRate.
- lastBestRefreshRateInvocation.reset();
+ mGetBestRefreshRateCache.reset();
mRefreshRates.clear();
for (const auto& mode : modes) {
@@ -800,7 +762,7 @@
ALOGE("Invalid refresh rate policy: %s", policy.toString().c_str());
return BAD_VALUE;
}
- lastBestRefreshRateInvocation.reset();
+ mGetBestRefreshRateCache.reset();
Policy previousPolicy = *getCurrentPolicyLocked();
mDisplayManagerPolicy = policy;
if (*getCurrentPolicyLocked() == previousPolicy) {
@@ -815,7 +777,7 @@
if (policy && !isPolicyValidLocked(*policy)) {
return BAD_VALUE;
}
- lastBestRefreshRateInvocation.reset();
+ mGetBestRefreshRateCache.reset();
Policy previousPolicy = *getCurrentPolicyLocked();
mOverridePolicy = policy;
if (*getCurrentPolicyLocked() == previousPolicy) {
diff --git a/services/surfaceflinger/Scheduler/RefreshRateConfigs.h b/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
index 7ef95f9..ade1787 100644
--- a/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
+++ b/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
@@ -20,6 +20,7 @@
#include <numeric>
#include <optional>
#include <type_traits>
+#include <utility>
#include <android-base/stringprintf.h>
#include <gui/DisplayEventReceiver.h>
@@ -249,11 +250,10 @@
}
};
- // Returns the refresh rate that best fits the given layers. outSignalsConsidered returns
- // whether the refresh rate was chosen based on touch boost and/or idle timer.
- RefreshRate getBestRefreshRate(const std::vector<LayerRequirement>&, GlobalSignals,
- GlobalSignals* outSignalsConsidered = nullptr) const
- EXCLUDES(mLock);
+ // Returns the refresh rate that best fits the given layers, and whether the refresh rate was
+ // chosen based on touch boost and/or idle timer.
+ std::pair<RefreshRate, GlobalSignals> getBestRefreshRate(const std::vector<LayerRequirement>&,
+ GlobalSignals) const EXCLUDES(mLock);
FpsRange getSupportedRefreshRateRange() const EXCLUDES(mLock) {
std::lock_guard lock(mLock);
@@ -403,13 +403,8 @@
const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
std::vector<const RefreshRate*>* outRefreshRates) REQUIRES(mLock);
- std::optional<RefreshRate> getCachedBestRefreshRate(const std::vector<LayerRequirement>&,
- GlobalSignals,
- GlobalSignals* outSignalsConsidered) const
- REQUIRES(mLock);
-
- RefreshRate getBestRefreshRateLocked(const std::vector<LayerRequirement>&, GlobalSignals,
- GlobalSignals* outSignalsConsidered) const REQUIRES(mLock);
+ std::pair<RefreshRate, GlobalSignals> getBestRefreshRateLocked(
+ const std::vector<LayerRequirement>&, GlobalSignals) const REQUIRES(mLock);
// Returns the refresh rate with the highest score in the collection specified from begin
// to end. If there are more than one with the same highest refresh rate, the first one is
@@ -497,14 +492,11 @@
const Config mConfig;
bool mSupportsFrameRateOverrideByContent;
- struct GetBestRefreshRateInvocation {
- std::vector<LayerRequirement> layerRequirements;
- GlobalSignals globalSignals;
- GlobalSignals outSignalsConsidered;
- RefreshRate resultingBestRefreshRate;
+ struct GetBestRefreshRateCache {
+ std::pair<std::vector<LayerRequirement>, GlobalSignals> arguments;
+ std::pair<RefreshRate, GlobalSignals> result;
};
- mutable std::optional<GetBestRefreshRateInvocation> lastBestRefreshRateInvocation
- GUARDED_BY(mLock);
+ mutable std::optional<GetBestRefreshRateCache> mGetBestRefreshRateCache GUARDED_BY(mLock);
// Declare mIdleTimer last to ensure its thread joins before the mutex/callbacks are destroyed.
std::mutex mIdleTimerCallbacksMutex;
diff --git a/services/surfaceflinger/Scheduler/Scheduler.cpp b/services/surfaceflinger/Scheduler/Scheduler.cpp
index a85e748..665d36982 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.cpp
+++ b/services/surfaceflinger/Scheduler/Scheduler.cpp
@@ -537,18 +537,19 @@
ATRACE_CALL();
- const auto refreshRateConfigs = holdRefreshRateConfigs();
- scheduler::LayerHistory::Summary summary =
- mLayerHistory.summarize(*refreshRateConfigs, systemTime());
- scheduler::RefreshRateConfigs::GlobalSignals consideredSignals;
DisplayModePtr newMode;
+ GlobalSignals consideredSignals;
+
bool frameRateChanged;
bool frameRateOverridesChanged;
+
+ const auto refreshRateConfigs = holdRefreshRateConfigs();
+ LayerHistory::Summary summary = mLayerHistory.summarize(*refreshRateConfigs, systemTime());
{
std::lock_guard<std::mutex> lock(mPolicyLock);
- mPolicy.contentRequirements = summary;
+ mPolicy.contentRequirements = std::move(summary);
- newMode = calculateRefreshRateModeId(&consideredSignals);
+ std::tie(newMode, consideredSignals) = chooseDisplayMode();
frameRateOverridesChanged = updateFrameRateOverrides(consideredSignals, newMode->getFps());
if (mPolicy.mode == newMode) {
@@ -678,8 +679,7 @@
mVsyncSchedule->dump(out);
}
-bool Scheduler::updateFrameRateOverrides(
- scheduler::RefreshRateConfigs::GlobalSignals consideredSignals, Fps displayRefreshRate) {
+bool Scheduler::updateFrameRateOverrides(GlobalSignals consideredSignals, Fps displayRefreshRate) {
const auto refreshRateConfigs = holdRefreshRateConfigs();
if (!refreshRateConfigs->supportsFrameRateOverrideByContent()) {
return false;
@@ -697,9 +697,11 @@
template <class T>
bool Scheduler::handleTimerStateChanged(T* currentState, T newState) {
DisplayModePtr newMode;
+ GlobalSignals consideredSignals;
+
bool refreshRateChanged = false;
bool frameRateOverridesChanged;
- scheduler::RefreshRateConfigs::GlobalSignals consideredSignals;
+
const auto refreshRateConfigs = holdRefreshRateConfigs();
{
std::lock_guard<std::mutex> lock(mPolicyLock);
@@ -707,7 +709,7 @@
return false;
}
*currentState = newState;
- newMode = calculateRefreshRateModeId(&consideredSignals);
+ std::tie(newMode, consideredSignals) = chooseDisplayMode();
frameRateOverridesChanged = updateFrameRateOverrides(consideredSignals, newMode->getFps());
if (mPolicy.mode == newMode) {
// We don't need to change the display mode, but we might need to send an event
@@ -733,33 +735,33 @@
return consideredSignals.touch;
}
-DisplayModePtr Scheduler::calculateRefreshRateModeId(
- scheduler::RefreshRateConfigs::GlobalSignals* consideredSignals) {
+auto Scheduler::chooseDisplayMode() -> std::pair<DisplayModePtr, GlobalSignals> {
ATRACE_CALL();
- if (consideredSignals) *consideredSignals = {};
- const auto refreshRateConfigs = holdRefreshRateConfigs();
+ const auto configs = holdRefreshRateConfigs();
+
// If Display Power is not in normal operation we want to be in performance mode. When coming
// back to normal mode, a grace period is given with DisplayPowerTimer.
if (mDisplayPowerTimer &&
(!mPolicy.isDisplayPowerStateNormal || mPolicy.displayPowerTimer == TimerState::Reset)) {
- return refreshRateConfigs->getMaxRefreshRateByPolicy().getMode();
+ constexpr GlobalSignals kNoSignals;
+ return {configs->getMaxRefreshRateByPolicy().getMode(), kNoSignals};
}
- const bool touchActive = mTouchTimer && mPolicy.touch == TouchState::Active;
- const bool idle = mPolicy.idleTimer == TimerState::Expired;
+ const GlobalSignals signals{.touch = mTouchTimer && mPolicy.touch == TouchState::Active,
+ .idle = mPolicy.idleTimer == TimerState::Expired};
- return refreshRateConfigs
- ->getBestRefreshRate(mPolicy.contentRequirements, {.touch = touchActive, .idle = idle},
- consideredSignals)
- .getMode();
+ const auto [refreshRate, consideredSignals] =
+ configs->getBestRefreshRate(mPolicy.contentRequirements, signals);
+
+ return {refreshRate.getMode(), consideredSignals};
}
DisplayModePtr Scheduler::getPreferredDisplayMode() {
std::lock_guard<std::mutex> lock(mPolicyLock);
- // Make sure that the default mode ID is first updated, before returned.
+ // Make sure the stored mode is up to date.
if (mPolicy.mode) {
- mPolicy.mode = calculateRefreshRateModeId();
+ mPolicy.mode = chooseDisplayMode().first;
}
return mPolicy.mode;
}
diff --git a/services/surfaceflinger/Scheduler/Scheduler.h b/services/surfaceflinger/Scheduler/Scheduler.h
index bc9024a..468c4cc 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.h
+++ b/services/surfaceflinger/Scheduler/Scheduler.h
@@ -269,15 +269,14 @@
void setVsyncPeriod(nsecs_t period);
- // This function checks whether individual features that are affecting the refresh rate
- // selection were initialized, prioritizes them, and calculates the DisplayModeId
- // for the suggested refresh rate.
- DisplayModePtr calculateRefreshRateModeId(
- RefreshRateConfigs::GlobalSignals* consideredSignals = nullptr) REQUIRES(mPolicyLock);
+ using GlobalSignals = RefreshRateConfigs::GlobalSignals;
+
+ // Returns the display mode that fulfills the policy, and the signals that were considered.
+ std::pair<DisplayModePtr, GlobalSignals> chooseDisplayMode() REQUIRES(mPolicyLock);
+
+ bool updateFrameRateOverrides(GlobalSignals, Fps displayRefreshRate) REQUIRES(mPolicyLock);
void dispatchCachedReportedMode() REQUIRES(mPolicyLock) EXCLUDES(mRefreshRateConfigsLock);
- bool updateFrameRateOverrides(RefreshRateConfigs::GlobalSignals, Fps displayRefreshRate)
- REQUIRES(mPolicyLock);
impl::EventThread::ThrottleVsyncCallback makeThrottleVsyncCallback() const
EXCLUDES(mRefreshRateConfigsLock);
diff --git a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
index 2c862d3..4efcc05 100644
--- a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
+++ b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
@@ -71,11 +71,17 @@
const std::vector<Fps>& knownFrameRates() const { return mKnownFrameRates; }
- using RefreshRateConfigs::GetBestRefreshRateInvocation;
+ using RefreshRateConfigs::GetBestRefreshRateCache;
+ auto& mutableGetBestRefreshRateCache() { return mGetBestRefreshRateCache; }
- std::optional<GetBestRefreshRateInvocation>& mutableLastBestRefreshRateInvocation() {
- std::lock_guard lock(mLock);
- return lastBestRefreshRateInvocation;
+ auto getBestRefreshRateAndSignals(const std::vector<LayerRequirement>& layers,
+ GlobalSignals signals) const {
+ return RefreshRateConfigs::getBestRefreshRate(layers, signals);
+ }
+
+ RefreshRate getBestRefreshRate(const std::vector<LayerRequirement>& layers = {},
+ GlobalSignals signals = {}) const {
+ return getBestRefreshRateAndSignals(layers, signals).first;
}
};
@@ -273,200 +279,200 @@
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_noLayers) {
{
- RefreshRateConfigs configs(kModes_60_72_90, kModeId72);
+ TestableRefreshRateConfigs configs(kModes_60_72_90, kModeId72);
// If there are no layers we select the default frame rate, which is the max of the primary
// range.
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate({}, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate());
EXPECT_EQ(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), NO_ERROR);
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate({}, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate());
}
{
// We select max even when this will cause a non-seamless switch.
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
constexpr bool kAllowGroupSwitching = true;
EXPECT_EQ(configs.setDisplayManagerPolicy({kModeId90, kAllowGroupSwitching, {0_Hz, 90_Hz}}),
NO_ERROR);
- EXPECT_EQ(asRefreshRate(kMode90_G1), configs.getBestRefreshRate({}, {}));
+ EXPECT_EQ(asRefreshRate(kMode90_G1), configs.getBestRefreshRate());
}
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_90) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(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(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(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(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_multipleThreshold_60_90) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60, {.frameRateMultipleThreshold = 90});
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60, {.frameRateMultipleThreshold = 90});
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_72_90) {
- RefreshRateConfigs configs(kModes_60_72_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_72_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90_120) {
- RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -476,23 +482,23 @@
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 48_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 48_Hz;
lr2.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes) {
- RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -504,7 +510,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -512,7 +518,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -520,7 +526,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "60Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -528,7 +534,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -536,7 +542,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -544,7 +550,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
@@ -552,7 +558,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -560,7 +566,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -568,12 +574,12 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.name = "90Hz ExplicitExactOrMultiple";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes_multipleThreshold) {
- RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60,
- {.frameRateMultipleThreshold = 120});
+ TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60,
+ {.frameRateMultipleThreshold = 120});
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -585,7 +591,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -593,7 +599,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -601,7 +607,7 @@
lr2.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "60Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -609,7 +615,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -617,7 +623,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -625,7 +631,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::Heuristic;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::Heuristic;
@@ -633,7 +639,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -641,7 +647,7 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
lr1.desiredRefreshRate = 24_Hz;
lr1.vote = LayerVoteType::ExplicitDefault;
@@ -649,86 +655,86 @@
lr2.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.name = "90Hz ExplicitExactOrMultiple";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60) {
- RefreshRateConfigs configs(kModes_30_60, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_30_60, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 90_Hz;
lr.vote = LayerVoteType::Heuristic;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 45_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 24_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90) {
- RefreshRateConfigs configs(kModes_30_60_72_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_30_60_72_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
lr.vote = LayerVoteType::Min;
lr.name = "Min";
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
lr.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 45_Hz;
lr.name = "45Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 30_Hz;
lr.name = "30Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 24_Hz;
lr.name = "24Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
lr.desiredRefreshRate = 24_Hz;
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
lr.name = "24Hz ExplicitExactOrMultiple";
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {.touch = true}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_PriorityTest) {
- RefreshRateConfigs configs(kModes_30_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_30_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -736,43 +742,43 @@
lr1.vote = LayerVoteType::Min;
lr2.vote = LayerVoteType::Max;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(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(asRefreshRate(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(asRefreshRate(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(asRefreshRate(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(asRefreshRate(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(asRefreshRate(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(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -780,14 +786,15 @@
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, {});
+ const auto refreshRate = configs.getBestRefreshRate(layers);
EXPECT_EQ(asRefreshRate(kMode60), refreshRate)
<< lr.desiredRefreshRate << " chooses " << refreshRate.getName();
}
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo_multipleThreshold_60_120) {
- RefreshRateConfigs configs(kModes_60_120, kModeId60, {.frameRateMultipleThreshold = 120});
+ TestableRefreshRateConfigs configs(kModes_60_120, kModeId60,
+ {.frameRateMultipleThreshold = 120});
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -795,14 +802,14 @@
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, {});
+ const auto refreshRate = configs.getBestRefreshRate(layers);
EXPECT_EQ(asRefreshRate(kMode60), refreshRate)
<< lr.desiredRefreshRate << " chooses " << refreshRate.getName();
}
}
TEST_F(RefreshRateConfigsTest, twoModes_getBestRefreshRate_Explicit) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -812,19 +819,19 @@
lr1.desiredRefreshRate = 60_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitDefault;
lr1.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::Heuristic;
lr1.desiredRefreshRate = 90_Hz;
lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
lr2.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, testInPolicy) {
@@ -839,7 +846,7 @@
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_75HzContent) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -854,7 +861,7 @@
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_Multiples) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -866,7 +873,7 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
@@ -874,14 +881,14 @@
lr2.vote = LayerVoteType::ExplicitDefault;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz ExplicitDefault";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::Max;
lr2.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 30_Hz;
@@ -889,18 +896,18 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 30_Hz;
lr1.name = "30Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::Max;
lr2.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -911,7 +918,7 @@
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::NoVote;
lr2.name = "NoVote";
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
@@ -932,7 +939,7 @@
lr1.name = "60Hz ExplicitExactOrMultiple";
lr2.vote = LayerVoteType::Max;
lr2.name = "Max";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
// The other layer starts to provide buffers
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
@@ -941,18 +948,17 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 90_Hz;
lr2.name = "90Hz Heuristic";
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, touchConsidered) {
RefreshRateConfigs configs(kModes_60_90, kModeId60);
- RefreshRateConfigs::GlobalSignals consideredSignals;
- configs.getBestRefreshRate({}, {}, &consideredSignals);
- EXPECT_FALSE(consideredSignals.touch);
+ auto [_, signals] = configs.getBestRefreshRate({}, {});
+ EXPECT_FALSE(signals.touch);
- configs.getBestRefreshRate({}, {.touch = true}, &consideredSignals);
- EXPECT_TRUE(consideredSignals.touch);
+ std::tie(std::ignore, signals) = configs.getBestRefreshRate({}, {.touch = true});
+ EXPECT_TRUE(signals.touch);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
auto& lr1 = layers[0];
@@ -964,8 +970,8 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.name = "60Hz Heuristic";
- configs.getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
- EXPECT_TRUE(consideredSignals.touch);
+ std::tie(std::ignore, signals) = configs.getBestRefreshRate(layers, {.touch = true});
+ EXPECT_TRUE(signals.touch);
lr1.vote = LayerVoteType::ExplicitDefault;
lr1.desiredRefreshRate = 60_Hz;
@@ -973,8 +979,8 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.name = "60Hz Heuristic";
- configs.getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
- EXPECT_FALSE(consideredSignals.touch);
+ std::tie(std::ignore, signals) = configs.getBestRefreshRate(layers, {.touch = true});
+ EXPECT_FALSE(signals.touch);
lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
lr1.desiredRefreshRate = 60_Hz;
@@ -982,8 +988,8 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.name = "60Hz Heuristic";
- configs.getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
- EXPECT_TRUE(consideredSignals.touch);
+ std::tie(std::ignore, signals) = configs.getBestRefreshRate(layers, {.touch = true});
+ EXPECT_TRUE(signals.touch);
lr1.vote = LayerVoteType::ExplicitDefault;
lr1.desiredRefreshRate = 60_Hz;
@@ -991,12 +997,12 @@
lr2.vote = LayerVoteType::Heuristic;
lr2.desiredRefreshRate = 60_Hz;
lr2.name = "60Hz Heuristic";
- configs.getBestRefreshRate(layers, {.touch = true}, &consideredSignals);
- EXPECT_FALSE(consideredSignals.touch);
+ std::tie(std::ignore, signals) = configs.getBestRefreshRate(layers, {.touch = true});
+ EXPECT_FALSE(signals.touch);
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitDefault) {
- RefreshRateConfigs configs(kModes_60_90_72_120, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_72_120, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -1028,7 +1034,7 @@
ss << "ExplicitDefault " << desired;
lr.name = ss.str();
- const auto refreshRate = configs.getBestRefreshRate(layers, {});
+ const auto refreshRate = configs.getBestRefreshRate(layers);
EXPECT_EQ(refreshRate.getFps(), expected);
}
}
@@ -1040,34 +1046,36 @@
// Test that 23.976 will choose 24 if 23.976 is not supported
{
- RefreshRateConfigs configs({kMode24, kMode25, kMode30, kMode30Frac, kMode60, kMode60Frac},
- kModeId60);
+ TestableRefreshRateConfigs configs({kMode24, kMode25, kMode30, kMode30Frac, kMode60,
+ kMode60Frac},
+ kModeId60);
lr.vote = LayerVoteType::ExplicitExactOrMultiple;
lr.desiredRefreshRate = 23.976_Hz;
lr.name = "ExplicitExactOrMultiple 23.976 Hz";
- EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers).getModeId());
}
// Test that 24 will choose 23.976 if 24 is not supported
{
- RefreshRateConfigs configs({kMode24Frac, kMode25, kMode30, kMode30Frac, kMode60,
- kMode60Frac},
- kModeId60);
+ TestableRefreshRateConfigs configs({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).getModeId());
}
// Test that 29.97 will prefer 59.94 over 60 and 30
{
- RefreshRateConfigs configs({kMode24, kMode24Frac, kMode25, kMode30, kMode60, kMode60Frac},
- kModeId60);
+ TestableRefreshRateConfigs configs({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).getModeId());
}
}
@@ -1077,7 +1085,7 @@
// Test that voting for supported refresh rate will select this refresh rate
{
- RefreshRateConfigs configs(kModes_24_25_30_50_60_Frac, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_24_25_30_50_60_Frac, kModeId60);
for (auto desired : {23.976_Hz, 24_Hz, 25_Hz, 29.97_Hz, 30_Hz, 50_Hz, 59.94_Hz, 60_Hz}) {
lr.vote = LayerVoteType::ExplicitExact;
@@ -1086,31 +1094,32 @@
ss << "ExplicitExact " << desired;
lr.name = ss.str();
- auto selectedRefreshRate = configs.getBestRefreshRate(layers, {});
+ auto selectedRefreshRate = configs.getBestRefreshRate(layers);
EXPECT_EQ(selectedRefreshRate.getFps(), lr.desiredRefreshRate);
}
}
// Test that 23.976 will choose 24 if 23.976 is not supported
{
- RefreshRateConfigs configs({kMode24, kMode25, kMode30, kMode30Frac, kMode60, kMode60Frac},
- kModeId60);
+ TestableRefreshRateConfigs configs({kMode24, kMode25, kMode30, kMode30Frac, kMode60,
+ kMode60Frac},
+ kModeId60);
lr.vote = LayerVoteType::ExplicitExact;
lr.desiredRefreshRate = 23.976_Hz;
lr.name = "ExplicitExact 23.976 Hz";
- EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers).getModeId());
}
// Test that 24 will choose 23.976 if 24 is not supported
{
- RefreshRateConfigs configs({kMode24Frac, kMode25, kMode30, kMode30Frac, kMode60,
- kMode60Frac},
- kModeId60);
+ TestableRefreshRateConfigs configs({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).getModeId());
}
}
@@ -1123,20 +1132,21 @@
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
- RefreshRateConfigs::GlobalSignals consideredSignals;
lr.vote = LayerVoteType::ExplicitDefault;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz ExplicitDefault";
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode60),
- configs.getBestRefreshRate(layers, {.touch = true, .idle = true},
- &consideredSignals));
- EXPECT_FALSE(consideredSignals.touch);
+
+ const auto [refreshRate, signals] =
+ configs.getBestRefreshRate(layers, {.touch = true, .idle = true});
+
+ EXPECT_EQ(refreshRate, asRefreshRate(kMode60));
+ EXPECT_FALSE(signals.touch);
}
TEST_F(RefreshRateConfigsTest,
getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresIdleFlag) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}, {60_Hz, 90_Hz}}), 0);
@@ -1152,13 +1162,13 @@
TEST_F(RefreshRateConfigsTest,
getBestRefreshRate_withDisplayManagerRequestingSingleRate_onlySwitchesRatesForExplicitFocusedLayers) {
- RefreshRateConfigs configs(kModes_60_90, kModeId90);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId90);
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
- RefreshRateConfigs::GlobalSignals consideredSignals;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate({}, {}, &consideredSignals));
- EXPECT_FALSE(consideredSignals.touch);
+ const auto [refreshRate, signals] = configs.getBestRefreshRateAndSignals({}, {});
+ EXPECT_EQ(refreshRate, asRefreshRate(kMode90));
+ EXPECT_FALSE(signals.touch);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
auto& lr = layers[0];
@@ -1167,50 +1177,50 @@
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz ExplicitExactOrMultiple";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::ExplicitDefault;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz ExplicitDefault";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Heuristic;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Heuristic";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Max;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Max";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.vote = LayerVoteType::Min;
lr.desiredRefreshRate = 60_Hz;
lr.name = "60Hz Min";
lr.focused = false;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
lr.focused = true;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, groupSwitchingNotAllowed) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
// The default policy doesn't allow group switching. Verify that no
// group switches are performed.
@@ -1222,11 +1232,12 @@
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayer) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+
RefreshRateConfigs::Policy policy;
policy.defaultMode = configs.getCurrentPolicy().defaultMode;
policy.allowGroupSwitching = true;
@@ -1239,11 +1250,11 @@
layer.seamlessness = Seamlessness::SeamedAndSeamless;
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamless) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
RefreshRateConfigs::Policy policy;
policy.defaultMode = configs.getCurrentPolicy().defaultMode;
@@ -1258,11 +1269,11 @@
layer.seamlessness = Seamlessness::OnlySeamless;
layer.name = "90Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamlessDefaultFps) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
RefreshRateConfigs::Policy policy;
policy.defaultMode = configs.getCurrentPolicy().defaultMode;
@@ -1279,11 +1290,11 @@
layer.seamlessness = Seamlessness::OnlySeamless;
layer.name = "60Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerDefaultSeamlessness) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
RefreshRateConfigs::Policy policy;
policy.defaultMode = configs.getCurrentPolicy().defaultMode;
@@ -1303,11 +1314,11 @@
layer.name = "60Hz ExplicitDefault";
layer.focused = true;
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersOnlySeamlessAndSeamed) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
RefreshRateConfigs::Policy policy;
policy.defaultMode = configs.getCurrentPolicy().defaultMode;
@@ -1332,11 +1343,11 @@
layers[1].name = "90Hz ExplicitDefault";
layers[1].focused = false;
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultFocusedAndSeamed) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
RefreshRateConfigs::Policy policy;
policy.defaultMode = configs.getCurrentPolicy().defaultMode;
@@ -1365,11 +1376,11 @@
layers[1].vote = LayerVoteType::ExplicitDefault;
layers[1].name = "90Hz ExplicitDefault";
- EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
RefreshRateConfigs::Policy policy;
policy.defaultMode = configs.getCurrentPolicy().defaultMode;
@@ -1395,11 +1406,11 @@
layers[1].vote = LayerVoteType::ExplicitDefault;
layers[1].name = "90Hz ExplicitDefault";
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, nonSeamlessVotePrefersSeamlessSwitches) {
- RefreshRateConfigs configs(kModes_30_60, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_30_60, kModeId60);
// Allow group switching.
RefreshRateConfigs::Policy policy;
@@ -1415,14 +1426,14 @@
layer.name = "60Hz ExplicitExactOrMultiple";
layer.focused = true;
- EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers).getModeId());
configs.setCurrentModeId(kModeId120);
- EXPECT_EQ(kModeId120, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId120, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, nonSeamlessExactAndSeamlessMultipleLayers) {
- RefreshRateConfigs configs(kModes_25_30_50_60, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_25_30_50_60, kModeId60);
// Allow group switching.
RefreshRateConfigs::Policy policy;
@@ -1443,18 +1454,18 @@
.weight = 1.f,
.focused = true}};
- EXPECT_EQ(kModeId50, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId50, configs.getBestRefreshRate(layers).getModeId());
auto& seamedLayer = layers[0];
seamedLayer.desiredRefreshRate = 30_Hz;
seamedLayer.name = "30Hz ExplicitDefault";
configs.setCurrentModeId(kModeId30);
- EXPECT_EQ(kModeId25, configs.getBestRefreshRate(layers, {}).getModeId());
+ EXPECT_EQ(kModeId25, configs.getBestRefreshRate(layers).getModeId());
}
TEST_F(RefreshRateConfigsTest, minLayersDontTrigerSeamedSwitch) {
- RefreshRateConfigs configs(kModes_60_90_G1, kModeId90);
+ TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId90);
// Allow group switching.
RefreshRateConfigs::Policy policy;
@@ -1465,11 +1476,11 @@
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).getModeId());
}
TEST_F(RefreshRateConfigsTest, primaryVsAppRequestPolicy) {
- RefreshRateConfigs configs(kModes_30_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_30_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
layers[0].name = "Test layer";
@@ -1490,7 +1501,7 @@
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().getModeId());
EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
EXPECT_EQ(kModeId30, getFrameRate(LayerVoteType::Min, 90_Hz));
EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz));
@@ -1523,7 +1534,7 @@
}
TEST_F(RefreshRateConfigsTest, idle) {
- RefreshRateConfigs configs(kModes_60_90, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
layers[0].name = "Test layer";
@@ -1531,15 +1542,13 @@
const auto getIdleFrameRate = [&](LayerVoteType voteType, bool touchActive) -> DisplayModeId {
layers[0].vote = voteType;
layers[0].desiredRefreshRate = 90_Hz;
- RefreshRateConfigs::GlobalSignals consideredSignals;
- const auto configId =
- configs.getBestRefreshRate(layers, {.touch = touchActive, .idle = true},
- &consideredSignals)
- .getModeId();
- // Refresh rate will be chosen by either touch state or idle state
- EXPECT_EQ(!touchActive, consideredSignals.idle);
- return configId;
+ const auto [refreshRate, signals] =
+ configs.getBestRefreshRateAndSignals(layers, {.touch = touchActive, .idle = true});
+
+ // Refresh rate will be chosen by either touch state or idle state.
+ EXPECT_EQ(!touchActive, signals.idle);
+ return refreshRate.getModeId();
};
EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
@@ -1624,12 +1633,12 @@
for (const auto& [fps, refreshRate] : knownFrameRatesExpectations) {
layer.desiredRefreshRate = fps;
- EXPECT_EQ(refreshRate, configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(refreshRate, configs.getBestRefreshRate(layers));
}
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExact) {
- RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
+ TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
auto& explicitExactLayer = layers[0];
@@ -1643,26 +1652,26 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode30), configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
explicitExactLayer.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 72_Hz;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 120_Hz;
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactEnableFrameRateOverride) {
- RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60,
- {.enableFrameRateOverride = true});
+ TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60,
+ {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
auto& explicitExactLayer = layers[0];
@@ -1676,77 +1685,55 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
explicitExactLayer.desiredRefreshRate = 60_Hz;
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 72_Hz;
- EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode72), configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 90_Hz;
- EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode90), configs.getBestRefreshRate(layers));
explicitExactLayer.desiredRefreshRate = 120_Hz;
- EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers));
}
-TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ReadsCached) {
- using GetBestRefreshRateInvocation = TestableRefreshRateConfigs::GetBestRefreshRateInvocation;
- using GlobalSignals = RefreshRateConfigs::GlobalSignals;
-
+TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ReadsCache) {
TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
- configs.mutableLastBestRefreshRateInvocation() =
- GetBestRefreshRateInvocation{.globalSignals = {.touch = true, .idle = true},
- .outSignalsConsidered = {.touch = true},
- .resultingBestRefreshRate = asRefreshRate(kMode90)};
+ 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});
- EXPECT_EQ(asRefreshRate(kMode90),
- configs.getBestRefreshRate({}, {.touch = true, .idle = true}));
+ configs.mutableGetBestRefreshRateCache() = {args, result};
- const GlobalSignals cachedSignalsConsidered{.touch = true};
-
- configs.mutableLastBestRefreshRateInvocation() =
- GetBestRefreshRateInvocation{.globalSignals = {.touch = true, .idle = true},
- .outSignalsConsidered = cachedSignalsConsidered,
- .resultingBestRefreshRate = asRefreshRate(kMode30)};
-
- GlobalSignals signalsConsidered;
- EXPECT_EQ(asRefreshRate(kMode30),
- configs.getBestRefreshRate({}, {.touch = true, .idle = true}, &signalsConsidered));
-
- EXPECT_EQ(cachedSignalsConsidered, signalsConsidered);
+ EXPECT_EQ(result, configs.getBestRefreshRateAndSignals(args.first, args.second));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_WritesCache) {
- using GlobalSignals = RefreshRateConfigs::GlobalSignals;
-
TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
- EXPECT_FALSE(configs.mutableLastBestRefreshRateInvocation());
+ EXPECT_FALSE(configs.mutableGetBestRefreshRateCache());
- GlobalSignals globalSignals{.touch = true, .idle = true};
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
- const auto lastResult = configs.getBestRefreshRate(layers, globalSignals,
- /* outSignalsConsidered */ nullptr);
+ RefreshRateConfigs::GlobalSignals globalSignals{.touch = true, .idle = true};
- const auto& lastInvocation = configs.mutableLastBestRefreshRateInvocation();
- ASSERT_TRUE(lastInvocation);
- EXPECT_EQ(layers, lastInvocation->layerRequirements);
- EXPECT_EQ(globalSignals, lastInvocation->globalSignals);
- EXPECT_EQ(lastResult, lastInvocation->resultingBestRefreshRate);
+ const auto result = configs.getBestRefreshRateAndSignals(layers, globalSignals);
- // outSignalsConsidered needs to be populated even tho earlier we gave nullptr
- // to getBestRefreshRate()
- GlobalSignals defaultSignals;
- EXPECT_FALSE(defaultSignals == lastInvocation->outSignalsConsidered);
+ const auto& cache = configs.mutableGetBestRefreshRateCache();
+ ASSERT_TRUE(cache);
+
+ EXPECT_EQ(cache->arguments, std::make_pair(layers, globalSignals));
+ EXPECT_EQ(cache->result, result);
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactTouchBoost) {
- RefreshRateConfigs configs(kModes_60_120, kModeId60, {.enableFrameRateOverride = true});
+ TestableRefreshRateConfigs configs(kModes_60_120, kModeId60, {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
auto& explicitExactLayer = layers[0];
@@ -1760,18 +1747,18 @@
explicitExactLayer.name = "ExplicitExact";
explicitExactLayer.desiredRefreshRate = 30_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode120), configs.getBestRefreshRate(layers, {.touch = true}));
explicitExactOrMultipleLayer.vote = LayerVoteType::NoVote;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {.touch = true}));
}
TEST_F(RefreshRateConfigsTest, getBestRefreshRate_FractionalRefreshRates_ExactAndDefault) {
- RefreshRateConfigs configs(kModes_24_25_30_50_60_Frac, kModeId60,
- {.enableFrameRateOverride = true});
+ TestableRefreshRateConfigs configs(kModes_24_25_30_50_60_Frac, kModeId60,
+ {.enableFrameRateOverride = true});
std::vector<LayerRequirement> layers = {{.weight = 0.5f}, {.weight = 0.5f}};
auto& explicitDefaultLayer = layers[0];
@@ -1785,7 +1772,7 @@
explicitDefaultLayer.name = "ExplicitDefault";
explicitDefaultLayer.desiredRefreshRate = 59.94_Hz;
- EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers, {}));
+ EXPECT_EQ(asRefreshRate(kMode60), configs.getBestRefreshRate(layers));
}
// b/190578904
@@ -1799,13 +1786,13 @@
createDisplayMode(DisplayModeId(fps), Fps::fromValue(static_cast<float>(fps))));
}
- const RefreshRateConfigs configs(displayModes, displayModes[0]->getId());
+ const TestableRefreshRateConfigs configs(displayModes, displayModes[0]->getId());
std::vector<LayerRequirement> layers = {{.weight = 1.f}};
const auto testRefreshRate = [&](Fps fps, LayerVoteType vote) {
layers[0].desiredRefreshRate = fps;
layers[0].vote = vote;
- EXPECT_EQ(fps.getIntValue(), configs.getBestRefreshRate(layers, {}).getFps().getIntValue())
+ EXPECT_EQ(fps.getIntValue(), configs.getBestRefreshRate(layers).getFps().getIntValue())
<< "Failed for " << ftl::enum_string(vote);
};
@@ -1828,7 +1815,7 @@
};
const RefreshRateConfigs::GlobalSignals globalSignals = {.touch = false, .idle = false};
- const RefreshRateConfigs configs(displayModes, displayModes[0]->getId());
+ const TestableRefreshRateConfigs configs(displayModes, displayModes[0]->getId());
const std::vector<LayerRequirement> layers = {
{