Merge "SF: Refactor Scheduler mock injection" (3a8a6c67) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/Scheduler/Scheduler.cpp

+8 −0

Original line number	Original line	Diff line number	Diff line
	@@ -118,6 +118,14 @@ Scheduler::Scheduler(impl::EventControlThread::SetVSyncEnabledFunction function,
	}		}
	}		}

			Scheduler::Scheduler(std::unique_ptr<DispSync> primaryDispSync,
			std::unique_ptr<EventControlThread> eventControlThread,
			const scheduler::RefreshRateConfigs& configs)
			: mHasSyncFramework(false),
			mPrimaryDispSync(std::move(primaryDispSync)),
			mEventControlThread(std::move(eventControlThread)),
			mRefreshRateConfigs(configs) {}

	Scheduler::~Scheduler() {		Scheduler::~Scheduler() {
	// Ensure the OneShotTimer threads are joined before we start destroying state.		// Ensure the OneShotTimer threads are joined before we start destroying state.
	mDisplayPowerTimer.reset();		mDisplayPowerTimer.reset();

services/surfaceflinger/Scheduler/Scheduler.h

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -204,6 +204,10 @@ private:
	enum class TimerState { Reset, Expired };		enum class TimerState { Reset, Expired };
	enum class TouchState { Inactive, Active };		enum class TouchState { Inactive, Active };

			// Used by tests to inject mocks.
			Scheduler(std::unique_ptr<DispSync>, std::unique_ptr<EventControlThread>,
			const scheduler::RefreshRateConfigs&);

	// Creates a connection on the given EventThread and forwards the given callbacks.		// Creates a connection on the given EventThread and forwards the given callbacks.
	sp<EventThreadConnection> createConnectionInternal(EventThread*, ResyncCallback&&,		sp<EventThreadConnection> createConnectionInternal(EventThread*, ResyncCallback&&,
	ISurfaceComposer::ConfigChanged);		ISurfaceComposer::ConfigChanged);

services/surfaceflinger/tests/unittests/CompositionTest.cpp

+15 −18

Original line number	Original line	Diff line number	Diff line
	@@ -34,7 +34,6 @@
	#include "ColorLayer.h"		#include "ColorLayer.h"
	#include "Layer.h"		#include "Layer.h"

	#include "TestableScheduler.h"
	#include "TestableSurfaceFlinger.h"		#include "TestableSurfaceFlinger.h"
	#include "mock/DisplayHardware/MockComposer.h"		#include "mock/DisplayHardware/MockComposer.h"
	#include "mock/MockDispSync.h"		#include "mock/MockDispSync.h"
	@@ -95,10 +94,6 @@ public:
	mFlinger.mutableEventQueue().reset(mMessageQueue);		mFlinger.mutableEventQueue().reset(mMessageQueue);
	setupScheduler();		setupScheduler();

	EXPECT_CALL(*mPrimaryDispSync, computeNextRefresh(0)).WillRepeatedly(Return(0));
	EXPECT_CALL(*mPrimaryDispSync, getPeriod())
	.WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_REFRESH_RATE));
	EXPECT_CALL(*mPrimaryDispSync, expectedPresentTime()).WillRepeatedly(Return(0));
	EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))		EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
	.WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));		.WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
	EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))		EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
	@@ -125,15 +120,22 @@ public:
	}		}

	void setupScheduler() {		void setupScheduler() {
	mScheduler = new TestableScheduler(mFlinger.mutableRefreshRateConfigs());		auto eventThread = std::make_unique<mock::EventThread>();
	mScheduler->mutableEventControlThread().reset(mEventControlThread);		auto sfEventThread = std::make_unique<mock::EventThread>();
	mScheduler->mutablePrimaryDispSync().reset(mPrimaryDispSync);
	EXPECT_CALL(*mEventThread.get(), registerDisplayEventConnection(_));		EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
	sp<Scheduler::ConnectionHandle> connectionHandle =		EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
	mScheduler->addConnection(std::move(mEventThread));
	mFlinger.mutableSfConnectionHandle() = std::move(connectionHandle);		auto primaryDispSync = std::make_unique<mock::DispSync>();

	mFlinger.mutableScheduler().reset(mScheduler);		EXPECT_CALL(*primaryDispSync, computeNextRefresh(0)).WillRepeatedly(Return(0));
			EXPECT_CALL(*primaryDispSync, getPeriod())
			.WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_REFRESH_RATE));
			EXPECT_CALL(*primaryDispSync, expectedPresentTime()).WillRepeatedly(Return(0));

			mFlinger.setupScheduler(std::move(primaryDispSync),
			std::make_unique<mock::EventControlThread>(),
			std::move(eventThread), std::move(sfEventThread));
	}		}

	void setupForceGeometryDirty() {		void setupForceGeometryDirty() {
	@@ -157,7 +159,6 @@ public:

	std::unordered_set<HWC2::Capability> mDefaultCapabilities = {HWC2::Capability::SidebandStream};		std::unordered_set<HWC2::Capability> mDefaultCapabilities = {HWC2::Capability::SidebandStream};

	TestableScheduler* mScheduler;
	TestableSurfaceFlinger mFlinger;		TestableSurfaceFlinger mFlinger;
	sp<DisplayDevice> mDisplay;		sp<DisplayDevice> mDisplay;
	sp<DisplayDevice> mExternalDisplay;		sp<DisplayDevice> mExternalDisplay;
	@@ -168,13 +169,9 @@ public:
	sp<GraphicBuffer> mBuffer = new GraphicBuffer();		sp<GraphicBuffer> mBuffer = new GraphicBuffer();
	ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();		ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();

	std::unique_ptr<mock::EventThread> mEventThread = std::make_unique<mock::EventThread>();
	mock::EventControlThread* mEventControlThread = new mock::EventControlThread();

	Hwc2::mock::Composer* mComposer = nullptr;		Hwc2::mock::Composer* mComposer = nullptr;
	renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();		renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
	mock::MessageQueue* mMessageQueue = new mock::MessageQueue();		mock::MessageQueue* mMessageQueue = new mock::MessageQueue();
	mock::DispSync* mPrimaryDispSync = new mock::DispSync();

	sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;		sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;

services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp

+17 −24

Original line number	Original line	Diff line number	Diff line
	@@ -95,11 +95,10 @@ public:
	DisplayTransactionTest();		DisplayTransactionTest();
	~DisplayTransactionTest() override;		~DisplayTransactionTest() override;

	void setupScheduler();

	// --------------------------------------------------------------------		// --------------------------------------------------------------------
	// Mock/Fake injection		// Mock/Fake injection

			void injectMockScheduler();
	void injectMockComposer(int virtualDisplayCount);		void injectMockComposer(int virtualDisplayCount);
	void injectFakeBufferQueueFactory();		void injectFakeBufferQueueFactory();
	void injectFakeNativeWindowSurfaceFactory();		void injectFakeNativeWindowSurfaceFactory();
	@@ -119,11 +118,7 @@ public:
	// --------------------------------------------------------------------		// --------------------------------------------------------------------
	// Test instances		// Test instances

	TestableScheduler* mScheduler;
	TestableSurfaceFlinger mFlinger;		TestableSurfaceFlinger mFlinger;
	mock::EventThread* mEventThread = new mock::EventThread();
	mock::EventThread* mSFEventThread = new mock::EventThread();
	mock::EventControlThread* mEventControlThread = new mock::EventControlThread();
	sp<mock::NativeWindow> mNativeWindow = new mock::NativeWindow();		sp<mock::NativeWindow> mNativeWindow = new mock::NativeWindow();
	sp<GraphicBuffer> mBuffer = new GraphicBuffer();		sp<GraphicBuffer> mBuffer = new GraphicBuffer();

	@@ -134,7 +129,11 @@ public:
	Hwc2::mock::Composer* mComposer = nullptr;		Hwc2::mock::Composer* mComposer = nullptr;
	mock::MessageQueue* mMessageQueue = new mock::MessageQueue();		mock::MessageQueue* mMessageQueue = new mock::MessageQueue();
	mock::SurfaceInterceptor* mSurfaceInterceptor = new mock::SurfaceInterceptor();		mock::SurfaceInterceptor* mSurfaceInterceptor = new mock::SurfaceInterceptor();
	mock::DispSync* mPrimaryDispSync = new mock::DispSync();
			mock::DispSync* mPrimaryDispSync = new mock::DispSync;
			mock::EventControlThread* mEventControlThread = new mock::EventControlThread;
			mock::EventThread* mEventThread = new mock::EventThread;
			mock::EventThread* mSFEventThread = new mock::EventThread;

	// These mocks are created only when expected to be created via a factory.		// These mocks are created only when expected to be created via a factory.
	sp<mock::GraphicBufferConsumer> mConsumer;		sp<mock::GraphicBufferConsumer> mConsumer;
	@@ -164,7 +163,7 @@ DisplayTransactionTest::DisplayTransactionTest() {
	return nullptr;		return nullptr;
	});		});

	setupScheduler();		injectMockScheduler();
	mFlinger.mutableEventQueue().reset(mMessageQueue);		mFlinger.mutableEventQueue().reset(mMessageQueue);
	mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));		mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
	mFlinger.mutableInterceptor().reset(mSurfaceInterceptor);		mFlinger.mutableInterceptor().reset(mSurfaceInterceptor);
	@@ -178,20 +177,14 @@ DisplayTransactionTest::~DisplayTransactionTest() {
	ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());		ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
	}		}

	void DisplayTransactionTest::setupScheduler() {		void DisplayTransactionTest::injectMockScheduler() {
	mScheduler = new TestableScheduler(mFlinger.mutableRefreshRateConfigs());
	mScheduler->mutableEventControlThread().reset(mEventControlThread);
	mScheduler->mutablePrimaryDispSync().reset(mPrimaryDispSync);
	EXPECT_CALL(*mEventThread, registerDisplayEventConnection(_));		EXPECT_CALL(*mEventThread, registerDisplayEventConnection(_));
	EXPECT_CALL(*mSFEventThread, registerDisplayEventConnection(_));		EXPECT_CALL(*mSFEventThread, registerDisplayEventConnection(_));

	sp<Scheduler::ConnectionHandle> sfConnectionHandle =		mFlinger.setupScheduler(std::unique_ptr<DispSync>(mPrimaryDispSync),
	mScheduler->addConnection(std::unique_ptr<EventThread>(mSFEventThread));		std::unique_ptr<EventControlThread>(mEventControlThread),
	mFlinger.mutableSfConnectionHandle() = std::move(sfConnectionHandle);		std::unique_ptr<EventThread>(mEventThread),
	sp<Scheduler::ConnectionHandle> appConnectionHandle =		std::unique_ptr<EventThread>(mSFEventThread));
	mScheduler->addConnection(std::unique_ptr<EventThread>(mEventThread));
	mFlinger.mutableAppConnectionHandle() = std::move(appConnectionHandle);
	mFlinger.mutableScheduler().reset(mScheduler);
	}		}

	void DisplayTransactionTest::injectMockComposer(int virtualDisplayCount) {		void DisplayTransactionTest::injectMockComposer(int virtualDisplayCount) {
	@@ -1131,8 +1124,8 @@ TEST_F(DisplayTransactionTest, resetDisplayStateClearsState) {
	// Preconditions		// Preconditions

	// vsync is enabled and available		// vsync is enabled and available
	mScheduler->mutablePrimaryHWVsyncEnabled() = true;		mFlinger.scheduler()->mutablePrimaryHWVsyncEnabled() = true;
	mScheduler->mutableHWVsyncAvailable() = true;		mFlinger.scheduler()->mutableHWVsyncAvailable() = true;

	// A display exists		// A display exists
	auto existing = Case::Display::makeFakeExistingDisplayInjector(this);		auto existing = Case::Display::makeFakeExistingDisplayInjector(this);
	@@ -1156,8 +1149,8 @@ TEST_F(DisplayTransactionTest, resetDisplayStateClearsState) {
	// Postconditions		// Postconditions

	// vsyncs should be off and not available.		// vsyncs should be off and not available.
	EXPECT_FALSE(mScheduler->mutablePrimaryHWVsyncEnabled());		EXPECT_FALSE(mFlinger.scheduler()->mutablePrimaryHWVsyncEnabled());
	EXPECT_FALSE(mScheduler->mutableHWVsyncAvailable());		EXPECT_FALSE(mFlinger.scheduler()->mutableHWVsyncAvailable());

	// The display should have been removed from the display map.		// The display should have been removed from the display map.
	EXPECT_FALSE(hasDisplayDevice(existing.token()));		EXPECT_FALSE(hasDisplayDevice(existing.token()));
	@@ -3008,7 +3001,7 @@ struct DisplayPowerCase {
	}		}

	static void setInitialPrimaryHWVsyncEnabled(DisplayTransactionTest* test, bool enabled) {		static void setInitialPrimaryHWVsyncEnabled(DisplayTransactionTest* test, bool enabled) {
	test->mScheduler->mutablePrimaryHWVsyncEnabled() = enabled;		test->mFlinger.scheduler()->mutablePrimaryHWVsyncEnabled() = enabled;
	}		}

	static void setupRepaintEverythingCallExpectations(DisplayTransactionTest* test) {		static void setupRepaintEverythingCallExpectations(DisplayTransactionTest* test) {

services/surfaceflinger/tests/unittests/TestableScheduler.h

+5 −4

Original line number	Original line	Diff line number	Diff line
	@@ -20,15 +20,16 @@
	#include <gui/ISurfaceComposer.h>		#include <gui/ISurfaceComposer.h>

	#include "Scheduler/EventThread.h"		#include "Scheduler/EventThread.h"
	#include "Scheduler/RefreshRateConfigs.h"
	#include "Scheduler/Scheduler.h"		#include "Scheduler/Scheduler.h"

	namespace android {		namespace android {

	class TestableScheduler : public Scheduler {		class TestableScheduler : public Scheduler {
	public:		public:
	TestableScheduler(const scheduler::RefreshRateConfigs& refreshRateConfig)		TestableScheduler(std::unique_ptr<DispSync> primaryDispSync,
	: Scheduler([](bool) {}, refreshRateConfig) {}		std::unique_ptr<EventControlThread> eventControlThread,
			const scheduler::RefreshRateConfigs& configs)
			: Scheduler(std::move(primaryDispSync), std::move(eventControlThread), configs) {}

	// Creates EventThreadConnection with the given eventThread. Creates Scheduler::Connection		// Creates EventThreadConnection with the given eventThread. Creates Scheduler::Connection
	// and adds it to the list of connectins. Returns the ConnectionHandle for the		// and adds it to the list of connectins. Returns the ConnectionHandle for the
	@@ -62,7 +63,7 @@ public:
	mutableEventControlThread().reset();		mutableEventControlThread().reset();
	mutablePrimaryDispSync().reset();		mutablePrimaryDispSync().reset();
	mConnections.clear();		mConnections.clear();
	};		}
	};		};

	} // namespace android		} // namespace android