Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit aa49af7d authored by Dominik Laskowski's avatar Dominik Laskowski
Browse files

SF: Add test for emitting of mode change event 

Also, remove the trivial SchedulerTest.dispatchCachedReportedMode, and
clean up related tests.

Bug: 255635821
Flag: TEST_ONLY
Test: SchedulerTest.emitModeChangeEvent
Change-Id: Id380776438d93f701f27fc5887e9b99064d32d0e
parent 9b4b4909

services/surfaceflinger/tests/unittests/SchedulerTest.cpp

+42 −13
Original line number Diff line number Diff line
@@ -78,6 +78,8 @@ protected: 


    SchedulerTest();



    static constexpr RefreshRateSelector::LayerRequirement kLayer = {.weight = 1.f};



    static constexpr PhysicalDisplayId kDisplayId1 = PhysicalDisplayId::fromPort(255u);

    static inline const ftl::NonNull<DisplayModePtr> kDisplay1Mode60 =

            ftl::as_non_null(createDisplayMode(kDisplayId1, DisplayModeId(0), 60_Hz));
@@ -85,6 +87,9 @@ protected: 
            ftl::as_non_null(createDisplayMode(kDisplayId1, DisplayModeId(1), 120_Hz));

    static inline const DisplayModes kDisplay1Modes = makeModes(kDisplay1Mode60, kDisplay1Mode120);



    static inline FrameRateMode kDisplay1Mode60_60{60_Hz, kDisplay1Mode60};

    static inline FrameRateMode kDisplay1Mode120_120{120_Hz, kDisplay1Mode120};



    static constexpr PhysicalDisplayId kDisplayId2 = PhysicalDisplayId::fromPort(254u);

    static inline const ftl::NonNull<DisplayModePtr> kDisplay2Mode60 =

            ftl::as_non_null(createDisplayMode(kDisplayId2, DisplayModeId(0), 60_Hz));
@@ -123,6 +128,7 @@ SchedulerTest::SchedulerTest() { 
            .WillRepeatedly(Return(mEventThreadConnection));



    mScheduler->setEventThread(Cycle::Render, std::move(eventThread));

    mScheduler->setEventThread(Cycle::LastComposite, std::make_unique<MockEventThread>());



    mFlinger.resetScheduler(mScheduler);

}
@@ -193,11 +199,39 @@ TEST_F(SchedulerTest, updateDisplayModes) { 
    ASSERT_EQ(1u, mScheduler->getNumActiveLayers());

}



TEST_F(SchedulerTest, dispatchCachedReportedMode) {

    mScheduler->clearCachedReportedMode();

TEST_F(SchedulerTest, emitModeChangeEvent) {

    const auto selectorPtr =

            std::make_shared<RefreshRateSelector>(kDisplay1Modes, kDisplay1Mode120->getId());

    mScheduler->registerDisplay(kDisplayId1, selectorPtr);

    mScheduler->onPrimaryDisplayModeChanged(Cycle::Render, kDisplay1Mode120_120);



    mScheduler->setContentRequirements({kLayer});



    // No event is emitted in response to idle.

    EXPECT_CALL(*mEventThread, onModeChanged(_)).Times(0);

    EXPECT_NO_FATAL_FAILURE(mScheduler->dispatchCachedReportedMode());



    using TimerState = TestableScheduler::TimerState;



    mScheduler->idleTimerCallback(TimerState::Expired);

    selectorPtr->setActiveMode(kDisplay1Mode60->getId(), 60_Hz);



    auto layer = kLayer;

    layer.vote = RefreshRateSelector::LayerVoteType::ExplicitExact;

    layer.desiredRefreshRate = 60_Hz;

    mScheduler->setContentRequirements({layer});



    // An event is emitted implicitly despite choosing the same mode as when idle.

    EXPECT_CALL(*mEventThread, onModeChanged(kDisplay1Mode60_60)).Times(1);



    mScheduler->idleTimerCallback(TimerState::Reset);



    mScheduler->setContentRequirements({kLayer});



    // An event is emitted explicitly for the mode change.

    EXPECT_CALL(*mEventThread, onModeChanged(kDisplay1Mode120_120)).Times(1);



    mScheduler->touchTimerCallback(TimerState::Reset);

    mScheduler->onPrimaryDisplayModeChanged(Cycle::Render, kDisplay1Mode120_120);

}



TEST_F(SchedulerTest, calculateMaxAcquiredBufferCount) {
@@ -246,14 +280,12 @@ TEST_F(SchedulerTest, chooseRefreshRateForContentSelectsMaxRefreshRate) { 
                                            /*updateAttachedChoreographer*/ false);

}



TEST_F(SchedulerTest, chooseDisplayModesSingleDisplay) {

TEST_F(SchedulerTest, chooseDisplayModes) {

    mScheduler->registerDisplay(kDisplayId1,

                                std::make_shared<RefreshRateSelector>(kDisplay1Modes,

                                                                      kDisplay1Mode60->getId()));



    std::vector<RefreshRateSelector::LayerRequirement> layers =

            std::vector<RefreshRateSelector::LayerRequirement>({{.weight = 1.f}, {.weight = 1.f}});

    mScheduler->setContentRequirements(layers);

    mScheduler->setContentRequirements({kLayer, kLayer});

    GlobalSignals globalSignals = {.idle = true};

    mScheduler->setTouchStateAndIdleTimerPolicy(globalSignals);
@@ -288,15 +320,14 @@ TEST_F(SchedulerTest, chooseDisplayModesSingleDisplay) { 
    EXPECT_EQ(choice->get(), DisplayModeChoice({120_Hz, kDisplay1Mode120}, globalSignals));

}



TEST_F(SchedulerTest, chooseDisplayModesSingleDisplayHighHintTouchSignal) {

TEST_F(SchedulerTest, chooseDisplayModesHighHintTouchSignal) {

    mScheduler->registerDisplay(kDisplayId1,

                                std::make_shared<RefreshRateSelector>(kDisplay1Modes,

                                                                      kDisplay1Mode60->getId()));



    using DisplayModeChoice = TestableScheduler::DisplayModeChoice;



    std::vector<RefreshRateSelector::LayerRequirement> layers =

            std::vector<RefreshRateSelector::LayerRequirement>({{.weight = 1.f}, {.weight = 1.f}});

    std::vector<RefreshRateSelector::LayerRequirement> layers = {kLayer, kLayer};

    auto& lr1 = layers[0];

    auto& lr2 = layers[1];
@@ -371,9 +402,7 @@ TEST_F(SchedulerTest, chooseDisplayModesMultipleDisplays) { 
                                                                               kDisplay2Mode60},

                                                                 GlobalSignals{});



        std::vector<RefreshRateSelector::LayerRequirement> layers = {{.weight = 1.f},

                                                                     {.weight = 1.f}};

        mScheduler->setContentRequirements(layers);

        mScheduler->setContentRequirements({kLayer, kLayer});

        mScheduler->setTouchStateAndIdleTimerPolicy(globalSignals);



        const auto actualChoices = mScheduler->chooseDisplayModes();

services/surfaceflinger/tests/unittests/TestableScheduler.h

+6 −9
Original line number Diff line number Diff line
@@ -176,6 +176,11 @@ public: 
        mPolicy.idleTimer = globalSignals.idle ? TimerState::Expired : TimerState::Reset;

    }



    using Scheduler::TimerState;



    using Scheduler::idleTimerCallback;

    using Scheduler::touchTimerCallback;



    void setContentRequirements(std::vector<RefreshRateSelector::LayerRequirement> layers) {

        std::lock_guard<std::mutex> lock(mPolicyLock);

        mPolicy.contentRequirements = std::move(layers);
@@ -188,15 +193,7 @@ public: 
        return Scheduler::chooseDisplayModes();

    }



    void dispatchCachedReportedMode() {

        std::lock_guard<std::mutex> lock(mPolicyLock);

        Scheduler::dispatchCachedReportedMode();

    }



    void clearCachedReportedMode() {

        std::lock_guard<std::mutex> lock(mPolicyLock);

        mPolicy.cachedModeChangedParams.reset();

    }

    using Scheduler::onPrimaryDisplayModeChanged;



    void setInitialHwVsyncEnabled(PhysicalDisplayId id, bool enabled) {

        auto schedule = getVsyncSchedule(id);