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

Commit 6f240179 authored by Lloyd Pique's avatar Lloyd Pique
Browse files

SF: Remove dead code from Scheduler 

While looking into some other Scheduler changes, I noticed that both
Scheduler::mRenderEventConnection and
Scheduler::mLastCompositeEventConnection are initialized but otherwise
unused. Scheduler::getEventConnection() is never called to retrieve
either value.

As there doesn't seem to be any use for them, let's remove them.

This change also required removing test fixture setup from the unit
tests, as the tests worked to install test double implementations.

Test: atest libsurfaceflinger_unittest
Bug: None
Flag: EXEMPT dead code

Change-Id: Ic004df96dd5fe3dadd0cd1455cd85506736a1875
parent da642806

services/surfaceflinger/Scheduler/Scheduler.cpp

+1 −5
Original line number Diff line number Diff line
@@ -38,7 +38,6 @@ 
#include <FrameTimeline/FrameTimeline.h>

#include <scheduler/interface/ICompositor.h>



#include <algorithm>

#include <cinttypes>

#include <cstdint>

#include <functional>
@@ -46,16 +45,15 @@ 
#include <numeric>



#include <common/FlagManager.h>

#include "../Layer.h"

#include "EventThread.h"

#include "FrameRateOverrideMappings.h"

#include "FrontEnd/LayerHandle.h"

#include "Layer.h"

#include "OneShotTimer.h"

#include "RefreshRateStats.h"

#include "SurfaceFlingerFactory.h"

#include "SurfaceFlingerProperties.h"

#include "TimeStats/TimeStats.h"

#include "VSyncTracker.h"

#include "VsyncConfiguration.h"

#include "VsyncController.h"

#include "VsyncSchedule.h"
@@ -361,10 +359,8 @@ void Scheduler::createEventThread(Cycle cycle, frametimeline::TokenManager* toke 


    if (cycle == Cycle::Render) {

        mRenderEventThread = std::move(eventThread);

        mRenderEventConnection = mRenderEventThread->createEventConnection();

    } else {

        mLastCompositeEventThread = std::move(eventThread);

        mLastCompositeEventConnection = mLastCompositeEventThread->createEventConnection();

    }

}

services/surfaceflinger/Scheduler/Scheduler.h

+0 −7
Original line number Diff line number Diff line
@@ -145,10 +145,6 @@ public: 
            Cycle, EventRegistrationFlags eventRegistration = {},

            const sp<IBinder>& layerHandle = nullptr) EXCLUDES(mChoreographerLock);



    const sp<EventThreadConnection>& getEventConnection(Cycle cycle) const {

        return cycle == Cycle::Render ? mRenderEventConnection : mLastCompositeEventConnection;

    }



    enum class Hotplug { Connected, Disconnected };

    void dispatchHotplug(PhysicalDisplayId, Hotplug);
@@ -467,10 +463,7 @@ private: 
    void onExpectedPresentTimePosted(TimePoint expectedPresentTime) override EXCLUDES(mDisplayLock);



    std::unique_ptr<EventThread> mRenderEventThread;

    sp<EventThreadConnection> mRenderEventConnection;



    std::unique_ptr<EventThread> mLastCompositeEventThread;

    sp<EventThreadConnection> mLastCompositeEventConnection;



    std::atomic<nsecs_t> mLastResyncTime = 0;

services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp

+0 −11
Original line number Diff line number Diff line
@@ -64,17 +64,6 @@ DisplayTransactionTest::~DisplayTransactionTest() { 


void DisplayTransactionTest::injectMockScheduler(PhysicalDisplayId displayId) {

    LOG_ALWAYS_FATAL_IF(mFlinger.scheduler());



    EXPECT_CALL(*mEventThread, registerDisplayEventConnection(_));

    EXPECT_CALL(*mEventThread, createEventConnection(_, _))

            .WillOnce(Return(

                    sp<EventThreadConnection>::make(mEventThread, mock::EventThread::kCallingUid)));



    EXPECT_CALL(*mSFEventThread, registerDisplayEventConnection(_));

    EXPECT_CALL(*mSFEventThread, createEventConnection(_, _))

            .WillOnce(Return(sp<EventThreadConnection>::make(mSFEventThread,

                                                             mock::EventThread::kCallingUid)));



    mFlinger.setupScheduler(std::make_unique<mock::VsyncController>(),

                            std::make_shared<mock::VSyncTracker>(),

                            std::unique_ptr<EventThread>(mEventThread),

services/surfaceflinger/tests/unittests/SchedulerTest.cpp

+2 −2
Original line number Diff line number Diff line
@@ -124,7 +124,7 @@ SchedulerTest::SchedulerTest() { 


    // createConnection call to scheduler makes a createEventConnection call to EventThread. Make

    // sure that call gets executed and returns an EventThread::Connection object.

    EXPECT_CALL(*mEventThread, createEventConnection(_, _))

    EXPECT_CALL(*mEventThread, createEventConnection(_))

            .WillRepeatedly(Return(mEventThreadConnection));



    mScheduler->setEventThread(Cycle::Render, std::move(eventThread));
@@ -797,7 +797,7 @@ TEST_F(AttachedChoreographerTest, registerMultipleOnSameLayer) { 


    const auto mockConnection1 = sp<MockEventThreadConnection>::make(mEventThread);

    const auto mockConnection2 = sp<MockEventThreadConnection>::make(mEventThread);

    EXPECT_CALL(*mEventThread, createEventConnection(_, _))

    EXPECT_CALL(*mEventThread, createEventConnection(_))

            .WillOnce(Return(mockConnection1))

            .WillOnce(Return(mockConnection2));

services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp

+0 −10
Original line number Diff line number Diff line
@@ -187,16 +187,6 @@ void DisplayModeSwitchingTest::setupScheduler( 
    mAppEventThread = eventThread.get();

    auto sfEventThread = std::make_unique<mock::EventThread>();



    EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));

    EXPECT_CALL(*eventThread, createEventConnection(_, _))

            .WillOnce(Return(sp<EventThreadConnection>::make(eventThread.get(),

                                                             mock::EventThread::kCallingUid)));



    EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));

    EXPECT_CALL(*sfEventThread, createEventConnection(_, _))

            .WillOnce(Return(sp<EventThreadConnection>::make(sfEventThread.get(),

                                                             mock::EventThread::kCallingUid)));



    auto vsyncController = std::make_unique<mock::VsyncController>();

    auto vsyncTracker = std::make_shared<mock::VSyncTracker>();