SF: Split Scheduler initialization
Create VsyncSchedule and timers after Scheduler construction, which will
happen on boot rather than initial hotplug in the future.
Remove Scheduler from SF factory.
Bug: 185535769
Test: Boot
Change-Id: I1096987f468a43fa4b6ae39709b44425d026248c
diff --git a/services/surfaceflinger/Scheduler/Scheduler.cpp b/services/surfaceflinger/Scheduler/Scheduler.cpp
index eeea25d..f201996 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.cpp
+++ b/services/surfaceflinger/Scheduler/Scheduler.cpp
@@ -117,16 +117,10 @@
}
};
-Scheduler::Scheduler(const std::shared_ptr<scheduler::RefreshRateConfigs>& configs,
- ISchedulerCallback& callback)
- : Scheduler(configs, callback,
- {.useContentDetection = sysprop::use_content_detection_for_refresh_rate(false)}) {
-}
+Scheduler::Scheduler(ISchedulerCallback& callback, Options options)
+ : mOptions(options), mSchedulerCallback(callback) {}
-Scheduler::Scheduler(const std::shared_ptr<scheduler::RefreshRateConfigs>& configs,
- ISchedulerCallback& callback, Options options)
- : Scheduler(createVsyncSchedule(configs->supportsKernelIdleTimer()), configs, callback,
- createLayerHistory(), options) {
+void Scheduler::startTimers() {
using namespace sysprop;
if (const int64_t millis = set_touch_timer_ms(0); millis > 0) {
@@ -147,22 +141,6 @@
}
}
-Scheduler::Scheduler(VsyncSchedule schedule,
- const std::shared_ptr<scheduler::RefreshRateConfigs>& configs,
- ISchedulerCallback& schedulerCallback,
- std::unique_ptr<LayerHistory> layerHistory, Options options)
- : mOptions(options),
- mVsyncSchedule(std::move(schedule)),
- mLayerHistory(std::move(layerHistory)),
- mSchedulerCallback(schedulerCallback),
- mPredictedVsyncTracer(
- base::GetBoolProperty("debug.sf.show_predicted_vsync", false)
- ? std::make_unique<PredictedVsyncTracer>(*mVsyncSchedule.dispatch)
- : nullptr) {
- setRefreshRateConfigs(configs);
- mSchedulerCallback.setVsyncEnabled(false);
-}
-
Scheduler::~Scheduler() {
// Ensure the OneShotTimer threads are joined before we start destroying state.
mDisplayPowerTimer.reset();
@@ -170,7 +148,7 @@
mRefreshRateConfigs.reset();
}
-Scheduler::VsyncSchedule Scheduler::createVsyncSchedule(bool supportKernelTimer) {
+void Scheduler::createVsyncSchedule(bool supportKernelTimer) {
auto clock = std::make_unique<scheduler::SystemClock>();
auto tracker = createVSyncTracker();
auto dispatch = createVSyncDispatch(*tracker);
@@ -180,11 +158,11 @@
auto controller =
std::make_unique<scheduler::VSyncReactor>(std::move(clock), *tracker, pendingFenceLimit,
supportKernelTimer);
- return {std::move(controller), std::move(tracker), std::move(dispatch)};
-}
+ mVsyncSchedule = {std::move(controller), std::move(tracker), std::move(dispatch)};
-std::unique_ptr<LayerHistory> Scheduler::createLayerHistory() {
- return std::make_unique<scheduler::LayerHistory>();
+ if (base::GetBoolProperty("debug.sf.show_predicted_vsync", false)) {
+ mPredictedVsyncTracer = std::make_unique<PredictedVsyncTracer>(*mVsyncSchedule.dispatch);
+ }
}
std::unique_ptr<VSyncSource> Scheduler::makePrimaryDispSyncSource(
@@ -594,11 +572,11 @@
// If the content detection feature is off, we still keep the layer history,
// since we use it for other features (like Frame Rate API), so layers
// still need to be registered.
- mLayerHistory->registerLayer(layer, voteType);
+ mLayerHistory.registerLayer(layer, voteType);
}
void Scheduler::deregisterLayer(Layer* layer) {
- mLayerHistory->deregisterLayer(layer);
+ mLayerHistory.deregisterLayer(layer);
}
void Scheduler::recordLayerHistory(Layer* layer, nsecs_t presentTime,
@@ -608,11 +586,11 @@
if (!mRefreshRateConfigs->canSwitch()) return;
}
- mLayerHistory->record(layer, presentTime, systemTime(), updateType);
+ mLayerHistory.record(layer, presentTime, systemTime(), updateType);
}
void Scheduler::setModeChangePending(bool pending) {
- mLayerHistory->setModeChangePending(pending);
+ mLayerHistory.setModeChangePending(pending);
}
void Scheduler::chooseRefreshRateForContent() {
@@ -625,7 +603,7 @@
const auto refreshRateConfigs = holdRefreshRateConfigs();
scheduler::LayerHistory::Summary summary =
- mLayerHistory->summarize(*refreshRateConfigs, systemTime());
+ mLayerHistory.summarize(*refreshRateConfigs, systemTime());
scheduler::RefreshRateConfigs::GlobalSignals consideredSignals;
DisplayModePtr newMode;
bool frameRateChanged;
@@ -686,7 +664,7 @@
// Display Power event will boost the refresh rate to performance.
// Clear Layer History to get fresh FPS detection
- mLayerHistory->clear();
+ mLayerHistory.clear();
}
void Scheduler::kernelIdleTimerCallback(TimerState state) {
@@ -730,7 +708,7 @@
// NOTE: Instead of checking all the layers, we should be checking the layer
// that is currently on top. b/142507166 will give us this capability.
if (handleTimerStateChanged(&mFeatures.touch, touch)) {
- mLayerHistory->clear();
+ mLayerHistory.clear();
}
ATRACE_INT("TouchState", static_cast<int>(touch));
}
@@ -747,7 +725,7 @@
mTouchTimer ? mTouchTimer->dump().c_str() : "off");
StringAppendF(&result, "+ Content detection: %s %s\n\n",
toContentDetectionString(mOptions.useContentDetection),
- mLayerHistory ? mLayerHistory->dump().c_str() : "(no layer history)");
+ mLayerHistory.dump().c_str());
{
std::lock_guard lock(mFrameRateOverridesLock);
@@ -911,7 +889,7 @@
}
void Scheduler::onActiveDisplayAreaChanged(uint32_t displayArea) {
- mLayerHistory->setDisplayArea(displayArea);
+ mLayerHistory.setDisplayArea(displayArea);
}
void Scheduler::setPreferredRefreshRateForUid(FrameRateOverride frameRateOverride) {
diff --git a/services/surfaceflinger/Scheduler/Scheduler.h b/services/surfaceflinger/Scheduler/Scheduler.h
index 8397738..8204abc 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.h
+++ b/services/surfaceflinger/Scheduler/Scheduler.h
@@ -75,9 +75,17 @@
using RefreshRate = scheduler::RefreshRateConfigs::RefreshRate;
using ModeEvent = scheduler::RefreshRateConfigEvent;
- Scheduler(const std::shared_ptr<scheduler::RefreshRateConfigs>&, ISchedulerCallback&);
+ struct Options {
+ // Whether to use content detection at all.
+ bool useContentDetection = false;
+ };
+
+ Scheduler(ISchedulerCallback&, Options);
~Scheduler();
+ void createVsyncSchedule(bool supportKernelIdleTimer);
+ void startTimers();
+
using ConnectionHandle = scheduler::ConnectionHandle;
ConnectionHandle createConnection(const char* connectionName, frametimeline::TokenManager*,
std::chrono::nanoseconds workDuration,
@@ -213,27 +221,12 @@
enum class TimerState { Reset, Expired };
enum class TouchState { Inactive, Active };
- struct Options {
- // Whether to use content detection at all.
- bool useContentDetection;
- };
-
struct VsyncSchedule {
std::unique_ptr<scheduler::VsyncController> controller;
std::unique_ptr<scheduler::VSyncTracker> tracker;
std::unique_ptr<scheduler::VSyncDispatch> dispatch;
};
- // Unlike the testing constructor, this creates the VsyncSchedule, LayerHistory, and timers.
- Scheduler(const std::shared_ptr<scheduler::RefreshRateConfigs>&, ISchedulerCallback&, Options);
-
- // Used by tests to inject mocks.
- Scheduler(VsyncSchedule, const std::shared_ptr<scheduler::RefreshRateConfigs>&,
- ISchedulerCallback&, std::unique_ptr<LayerHistory>, Options);
-
- static VsyncSchedule createVsyncSchedule(bool supportKernelIdleTimer);
- static std::unique_ptr<LayerHistory> createLayerHistory();
-
// Create a connection on the given EventThread.
ConnectionHandle createConnection(std::unique_ptr<EventThread>);
sp<EventThreadConnection> createConnectionInternal(
@@ -297,7 +290,7 @@
VsyncSchedule mVsyncSchedule;
// Used to choose refresh rate if content detection is enabled.
- std::unique_ptr<LayerHistory> mLayerHistory;
+ LayerHistory mLayerHistory;
// Timer used to monitor touch events.
std::optional<scheduler::OneShotTimer> mTouchTimer;
@@ -338,7 +331,7 @@
GUARDED_BY(mVsyncTimelineLock);
static constexpr std::chrono::nanoseconds MAX_VSYNC_APPLIED_TIME = 200ms;
- const std::unique_ptr<PredictedVsyncTracer> mPredictedVsyncTracer;
+ std::unique_ptr<PredictedVsyncTracer> mPredictedVsyncTracer;
// The frame rate override lists need their own mutex as they are being read
// by SurfaceFlinger, Scheduler and EventThread (as a callback) to prevent deadlocks
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index c2dcd70..34629a2 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -3149,8 +3149,19 @@
mVsyncConfiguration = getFactory().createVsyncConfiguration(currRefreshRate);
mVsyncModulator = sp<VsyncModulator>::make(mVsyncConfiguration->getCurrentConfigs());
- // start the EventThread
- mScheduler = getFactory().createScheduler(display->holdRefreshRateConfigs(), *this);
+ const Scheduler::Options options = {
+ .useContentDetection = sysprop::use_content_detection_for_refresh_rate(false)};
+
+ mScheduler = std::make_unique<Scheduler>(static_cast<ISchedulerCallback&>(*this), options);
+ {
+ auto configs = display->holdRefreshRateConfigs();
+ mScheduler->createVsyncSchedule(configs->supportsKernelIdleTimer());
+ mScheduler->setRefreshRateConfigs(std::move(configs));
+ }
+
+ setVsyncEnabled(false);
+ mScheduler->startTimers();
+
const auto configs = mVsyncConfiguration->getCurrentConfigs();
const nsecs_t vsyncPeriod = currRefreshRate.getPeriodNsecs();
mAppConnectionHandle =
diff --git a/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp b/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
index 9a2f910..ae21fcc 100644
--- a/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
+++ b/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
@@ -64,12 +64,6 @@
}
}
-std::unique_ptr<Scheduler> DefaultFactory::createScheduler(
- const std::shared_ptr<scheduler::RefreshRateConfigs>& refreshRateConfigs,
- ISchedulerCallback& callback) {
- return std::make_unique<Scheduler>(std::move(refreshRateConfigs), callback);
-}
-
sp<SurfaceInterceptor> DefaultFactory::createSurfaceInterceptor() {
return new android::impl::SurfaceInterceptor();
}
diff --git a/services/surfaceflinger/SurfaceFlingerDefaultFactory.h b/services/surfaceflinger/SurfaceFlingerDefaultFactory.h
index 2be09ee..4f70979 100644
--- a/services/surfaceflinger/SurfaceFlingerDefaultFactory.h
+++ b/services/surfaceflinger/SurfaceFlingerDefaultFactory.h
@@ -30,8 +30,6 @@
std::unique_ptr<MessageQueue> createMessageQueue(ICompositor&) override;
std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Fps currentRefreshRate) override;
- std::unique_ptr<Scheduler> createScheduler(
- const std::shared_ptr<scheduler::RefreshRateConfigs>&, ISchedulerCallback&) override;
sp<SurfaceInterceptor> createSurfaceInterceptor() override;
sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override;
sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&) override;
diff --git a/services/surfaceflinger/SurfaceFlingerFactory.h b/services/surfaceflinger/SurfaceFlingerFactory.h
index bca533b..a1bf9fe 100644
--- a/services/surfaceflinger/SurfaceFlingerFactory.h
+++ b/services/surfaceflinger/SurfaceFlingerFactory.h
@@ -80,8 +80,6 @@
virtual std::unique_ptr<MessageQueue> createMessageQueue(ICompositor&) = 0;
virtual std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Fps currentRefreshRate) = 0;
- virtual std::unique_ptr<Scheduler> createScheduler(
- const std::shared_ptr<scheduler::RefreshRateConfigs>&, ISchedulerCallback&) = 0;
virtual sp<SurfaceInterceptor> createSurfaceInterceptor() = 0;
virtual sp<StartPropertySetThread> createStartPropertySetThread(
diff --git a/services/surfaceflinger/tests/unittests/CompositionTest.cpp b/services/surfaceflinger/tests/unittests/CompositionTest.cpp
index 40ef6e7..daa6543 100644
--- a/services/surfaceflinger/tests/unittests/CompositionTest.cpp
+++ b/services/surfaceflinger/tests/unittests/CompositionTest.cpp
@@ -145,9 +145,6 @@
mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
std::move(eventThread), std::move(sfEventThread), kCallback,
kHasMultipleConfigs);
-
- // Layer history should be created if there are multiple configs.
- ASSERT_TRUE(mFlinger.scheduler()->hasLayerHistory());
}
void setupForceGeometryDirty() {
@@ -843,7 +840,7 @@
sp<L> layer = factory();
// Layer should be registered with scheduler.
- EXPECT_EQ(1, test->mFlinger.scheduler()->layerHistorySize());
+ EXPECT_EQ(1u, test->mFlinger.scheduler()->layerHistorySize());
Mock::VerifyAndClear(test->mComposer);
Mock::VerifyAndClear(test->mRenderEngine);
@@ -888,7 +885,7 @@
// Layer should be unregistered with scheduler.
test->mFlinger.commit();
- EXPECT_EQ(0, test->mFlinger.scheduler()->layerHistorySize());
+ EXPECT_EQ(0u, test->mFlinger.scheduler()->layerHistorySize());
}
};
diff --git a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
index e8795fe..4993a2d 100644
--- a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
+++ b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
@@ -59,10 +59,8 @@
LayerHistoryTest() { mFlinger.resetScheduler(mScheduler); }
- void SetUp() override { ASSERT_TRUE(mScheduler->hasLayerHistory()); }
-
- LayerHistory& history() { return *mScheduler->mutableLayerHistory(); }
- const LayerHistory& history() const { return *mScheduler->mutableLayerHistory(); }
+ LayerHistory& history() { return mScheduler->mutableLayerHistory(); }
+ const LayerHistory& history() const { return mScheduler->mutableLayerHistory(); }
LayerHistory::Summary summarizeLayerHistory(nsecs_t now) {
return history().summarize(*mScheduler->refreshRateConfigs(), now);
diff --git a/services/surfaceflinger/tests/unittests/SchedulerTest.cpp b/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
index 599b235..e558f3b 100644
--- a/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
@@ -68,14 +68,6 @@
std::make_shared<scheduler::RefreshRateConfigs>(DisplayModes{mode60}, mode60->getId());
mock::SchedulerCallback mSchedulerCallback;
-
- // The scheduler should initially disable VSYNC.
- struct ExpectDisableVsync {
- ExpectDisableVsync(mock::SchedulerCallback& callback) {
- EXPECT_CALL(callback, setVsyncEnabled(false)).Times(1);
- }
- } mExpectDisableVsync{mSchedulerCallback};
-
TestableScheduler* mScheduler = new TestableScheduler{mConfigs, mSchedulerCallback};
Scheduler::ConnectionHandle mConnectionHandle;
@@ -166,9 +158,9 @@
sp<mock::MockLayer> layer = sp<mock::MockLayer>::make(mFlinger.flinger());
// recordLayerHistory should be a noop
- ASSERT_EQ(static_cast<size_t>(0), mScheduler->getNumActiveLayers());
+ ASSERT_EQ(0u, mScheduler->getNumActiveLayers());
mScheduler->recordLayerHistory(layer.get(), 0, LayerHistory::LayerUpdateType::Buffer);
- ASSERT_EQ(static_cast<size_t>(0), mScheduler->getNumActiveLayers());
+ ASSERT_EQ(0u, mScheduler->getNumActiveLayers());
constexpr bool kPowerStateNormal = true;
mScheduler->setDisplayPowerState(kPowerStateNormal);
@@ -181,17 +173,17 @@
}
TEST_F(SchedulerTest, updateDisplayModes) {
- ASSERT_EQ(static_cast<size_t>(0), mScheduler->layerHistorySize());
+ ASSERT_EQ(0u, mScheduler->layerHistorySize());
sp<mock::MockLayer> layer = sp<mock::MockLayer>::make(mFlinger.flinger());
- ASSERT_EQ(static_cast<size_t>(1), mScheduler->layerHistorySize());
+ ASSERT_EQ(1u, mScheduler->layerHistorySize());
mScheduler->setRefreshRateConfigs(
std::make_shared<scheduler::RefreshRateConfigs>(DisplayModes{mode60, mode120},
mode60->getId()));
- ASSERT_EQ(static_cast<size_t>(0), mScheduler->getNumActiveLayers());
+ ASSERT_EQ(0u, mScheduler->getNumActiveLayers());
mScheduler->recordLayerHistory(layer.get(), 0, LayerHistory::LayerUpdateType::Buffer);
- ASSERT_EQ(static_cast<size_t>(1), mScheduler->getNumActiveLayers());
+ ASSERT_EQ(1u, mScheduler->getNumActiveLayers());
}
TEST_F(SchedulerTest, testDispatchCachedReportedMode) {
diff --git a/services/surfaceflinger/tests/unittests/SetFrameRateTest.cpp b/services/surfaceflinger/tests/unittests/SetFrameRateTest.cpp
index d021178..d9c6bfb 100644
--- a/services/surfaceflinger/tests/unittests/SetFrameRateTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SetFrameRateTest.cpp
@@ -454,20 +454,16 @@
parent->setFrameRate(FRAME_RATE_VOTE1);
commitTransaction();
- mFlinger.mutableScheduler()
- .mutableLayerHistory()
- ->record(parent.get(), 0, 0, LayerHistory::LayerUpdateType::Buffer);
- mFlinger.mutableScheduler()
- .mutableLayerHistory()
- ->record(child.get(), 0, 0, LayerHistory::LayerUpdateType::Buffer);
+ auto& history = mFlinger.mutableScheduler().mutableLayerHistory();
+ history.record(parent.get(), 0, 0, LayerHistory::LayerUpdateType::Buffer);
+ history.record(child.get(), 0, 0, LayerHistory::LayerUpdateType::Buffer);
- const auto layerHistorySummary =
- mFlinger.mutableScheduler()
- .mutableLayerHistory()
- ->summarize(*mFlinger.mutableScheduler().refreshRateConfigs(), 0);
- ASSERT_EQ(2u, layerHistorySummary.size());
- EXPECT_EQ(FRAME_RATE_VOTE1.rate, layerHistorySummary[0].desiredRefreshRate);
- EXPECT_EQ(FRAME_RATE_VOTE1.rate, layerHistorySummary[1].desiredRefreshRate);
+ const auto configs = mFlinger.mutableScheduler().refreshRateConfigs();
+ const auto summary = history.summarize(*configs, 0);
+
+ ASSERT_EQ(2u, summary.size());
+ EXPECT_EQ(FRAME_RATE_VOTE1.rate, summary[0].desiredRefreshRate);
+ EXPECT_EQ(FRAME_RATE_VOTE1.rate, summary[1].desiredRefreshRate);
}
TEST_P(SetFrameRateTest, addChildForParentWithTreeVote) {
diff --git a/services/surfaceflinger/tests/unittests/TestableScheduler.h b/services/surfaceflinger/tests/unittests/TestableScheduler.h
index 1d21bd4..1b850fc 100644
--- a/services/surfaceflinger/tests/unittests/TestableScheduler.h
+++ b/services/surfaceflinger/tests/unittests/TestableScheduler.h
@@ -32,19 +32,20 @@
class TestableScheduler : public Scheduler {
public:
- TestableScheduler(const std::shared_ptr<scheduler::RefreshRateConfigs>& refreshRateConfigs,
+ TestableScheduler(std::shared_ptr<scheduler::RefreshRateConfigs> configs,
ISchedulerCallback& callback)
: TestableScheduler(std::make_unique<mock::VsyncController>(),
- std::make_unique<mock::VSyncTracker>(), refreshRateConfigs,
+ std::make_unique<mock::VSyncTracker>(), std::move(configs),
callback) {}
TestableScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
std::unique_ptr<scheduler::VSyncTracker> vsyncTracker,
- const std::shared_ptr<scheduler::RefreshRateConfigs>& refreshRateConfigs,
+ std::shared_ptr<scheduler::RefreshRateConfigs> configs,
ISchedulerCallback& callback)
- : Scheduler({std::move(vsyncController), std::move(vsyncTracker), nullptr},
- refreshRateConfigs, callback, createLayerHistory(),
- {.useContentDetection = true}) {}
+ : Scheduler(callback, {.useContentDetection = true}) {
+ mVsyncSchedule = {std::move(vsyncController), std::move(vsyncTracker), nullptr};
+ setRefreshRateConfigs(std::move(configs));
+ }
// Used to inject mock event thread.
ConnectionHandle createConnection(std::unique_ptr<EventThread> eventThread) {
@@ -58,22 +59,13 @@
auto& mutablePrimaryHWVsyncEnabled() { return mPrimaryHWVsyncEnabled; }
auto& mutableHWVsyncAvailable() { return mHWVsyncAvailable; }
- bool hasLayerHistory() const { return static_cast<bool>(mLayerHistory); }
+ auto& mutableLayerHistory() { return mLayerHistory; }
- auto* mutableLayerHistory() { return mLayerHistory.get(); }
-
- size_t layerHistorySize() NO_THREAD_SAFETY_ANALYSIS {
- if (!mLayerHistory) return 0;
- return mutableLayerHistory()->mLayerInfos.size();
- }
+ size_t layerHistorySize() NO_THREAD_SAFETY_ANALYSIS { return mLayerHistory.mLayerInfos.size(); }
+ size_t getNumActiveLayers() NO_THREAD_SAFETY_ANALYSIS { return mLayerHistory.mActiveLayersEnd; }
auto refreshRateConfigs() { return holdRefreshRateConfigs(); }
- size_t getNumActiveLayers() NO_THREAD_SAFETY_ANALYSIS {
- if (!mLayerHistory) return 0;
- return mutableLayerHistory()->mActiveLayersEnd;
- }
-
void replaceTouchTimer(int64_t millis) {
if (mTouchTimer) {
mTouchTimer.reset();
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index 8cca6af..c2c4a54 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -82,11 +82,6 @@
return std::make_unique<scheduler::FakePhaseOffsets>();
}
- std::unique_ptr<Scheduler> createScheduler(
- const std::shared_ptr<scheduler::RefreshRateConfigs>&, ISchedulerCallback&) override {
- return nullptr;
- }
-
sp<SurfaceInterceptor> createSurfaceInterceptor() override {
return new android::impl::SurfaceInterceptor();
}