SF: Deduplicate mock scheduler setup in tests (fb281c53) · Commits · e / os / android_frameworks_native

services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp

+19 −28

Original line number	Original line	Diff line number	Diff line
	@@ -191,29 +191,20 @@ bool LayerTraceGenerator::generate(const proto::TransactionTraceFile& traceFile,
	return false;		return false;
	}		}

	Factory mFactory;		Factory factory;
	sp<MockSurfaceFlinger> flinger = sp<MockSurfaceFlinger>::make(mFactory);		sp<MockSurfaceFlinger> flingerPtr = sp<MockSurfaceFlinger>::make(factory);
	TestableSurfaceFlinger mFlinger(flinger);		TestableSurfaceFlinger flinger(flingerPtr);
	mFlinger.setupRenderEngine(		flinger.setupRenderEngine(
	std::make_unique<testing::NiceMock<renderengine::mock::RenderEngine>>());		std::make_unique<testing::NiceMock<renderengine::mock::RenderEngine>>());
	mock::VsyncController* mVsyncController = new testing::NiceMock<mock::VsyncController>();		flinger.setupMockScheduler({.useNiceMock = true});
	mock::VSyncTracker* mVSyncTracker = new testing::NiceMock<mock::VSyncTracker>();
	mock::EventThread* mEventThread = new testing::NiceMock<mock::EventThread>();		Hwc2::mock::Composer* composerPtr = new testing::NiceMock<Hwc2::mock::Composer>();
	mock::EventThread* mSFEventThread = new testing::NiceMock<mock::EventThread>();		flinger.setupComposer(std::unique_ptr<Hwc2::Composer>(composerPtr));
	mFlinger.setupScheduler(std::unique_ptr<scheduler::VsyncController>(mVsyncController),		flinger.mutableMaxRenderTargetSize() = 16384;
	std::unique_ptr<scheduler::VSyncTracker>(mVSyncTracker),
	std::unique_ptr<EventThread>(mEventThread),		flingerPtr->setLayerTracingFlags(LayerTracing::TRACE_INPUT \| LayerTracing::TRACE_BUFFERS);
	std::unique_ptr<EventThread>(mSFEventThread),		flingerPtr->setLayerTraceSize(512 * 1024); // 512MB buffer size
	TestableSurfaceFlinger::SchedulerCallbackImpl::kNoOp,		flingerPtr->startLayerTracing(traceFile.entry(0).elapsed_realtime_nanos());
	TestableSurfaceFlinger::kOneDisplayMode, true /* useNiceMock */);

	Hwc2::mock::Composer* mComposer = new testing::NiceMock<Hwc2::mock::Composer>();
	mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
	mFlinger.mutableMaxRenderTargetSize() = 16384;

	flinger->setLayerTracingFlags(LayerTracing::TRACE_INPUT \| LayerTracing::TRACE_BUFFERS);
	flinger->setLayerTraceSize(512 * 1024); // 512MB buffer size
	flinger->startLayerTracing(traceFile.entry(0).elapsed_realtime_nanos());
	std::unique_ptr<TraceGenFlingerDataMapper> mapper =		std::unique_ptr<TraceGenFlingerDataMapper> mapper =
	std::make_unique<TraceGenFlingerDataMapper>();		std::make_unique<TraceGenFlingerDataMapper>();
	TraceGenFlingerDataMapper* dataMapper = mapper.get();		TraceGenFlingerDataMapper* dataMapper = mapper.get();
	@@ -234,7 +225,7 @@ bool LayerTraceGenerator::generate(const proto::TransactionTraceFile& traceFile,
	parser.fromProto(entry.added_layers(j), tracingArgs);		parser.fromProto(entry.added_layers(j), tracingArgs);

	gui::CreateSurfaceResult outResult;		gui::CreateSurfaceResult outResult;
	LayerCreationArgs args(mFlinger.flinger(), nullptr /* client */, tracingArgs.name,		LayerCreationArgs args(flinger.flinger(), nullptr /* client */, tracingArgs.name,
	tracingArgs.flags, LayerMetadata(),		tracingArgs.flags, LayerMetadata(),
	std::make_optional<int32_t>(tracingArgs.layerId));		std::make_optional<int32_t>(tracingArgs.layerId));

	@@ -247,10 +238,10 @@ bool LayerTraceGenerator::generate(const proto::TransactionTraceFile& traceFile,
	} else if (tracingArgs.parentId != -1) {		} else if (tracingArgs.parentId != -1) {
	parentHandle = dataMapper->getLayerHandle(tracingArgs.parentId);		parentHandle = dataMapper->getLayerHandle(tracingArgs.parentId);
	}		}
	mFlinger.createLayer(args, parentHandle, outResult);		flinger.createLayer(args, parentHandle, outResult);
	} else {		} else {
	sp<IBinder> mirrorFromHandle = dataMapper->getLayerHandle(tracingArgs.mirrorFromId);		sp<IBinder> mirrorFromHandle = dataMapper->getLayerHandle(tracingArgs.mirrorFromId);
	mFlinger.mirrorLayer(args, mirrorFromHandle, outResult);		flinger.mirrorLayer(args, mirrorFromHandle, outResult);
	}		}
	LOG_ALWAYS_FATAL_IF(outResult.layerId != tracingArgs.layerId,		LOG_ALWAYS_FATAL_IF(outResult.layerId != tracingArgs.layerId,
	"Could not create layer expected:%d actual:%d", tracingArgs.layerId,		"Could not create layer expected:%d actual:%d", tracingArgs.layerId,
	@@ -261,19 +252,19 @@ bool LayerTraceGenerator::generate(const proto::TransactionTraceFile& traceFile,
	for (int j = 0; j < entry.transactions_size(); j++) {		for (int j = 0; j < entry.transactions_size(); j++) {
	// apply transactions		// apply transactions
	TransactionState transaction = parser.fromProto(entry.transactions(j));		TransactionState transaction = parser.fromProto(entry.transactions(j));
	mFlinger.setTransactionStateInternal(transaction);		flinger.setTransactionStateInternal(transaction);
	}		}

	const auto frameTime = TimePoint::fromNs(entry.elapsed_realtime_nanos());		const auto frameTime = TimePoint::fromNs(entry.elapsed_realtime_nanos());
	const auto vsyncId = VsyncId{entry.vsync_id()};		const auto vsyncId = VsyncId{entry.vsync_id()};
	mFlinger.commit(frameTime, vsyncId);		flinger.commit(frameTime, vsyncId);

	for (int j = 0; j < entry.removed_layer_handles_size(); j++) {		for (int j = 0; j < entry.removed_layer_handles_size(); j++) {
	dataMapper->mLayerHandles.erase(entry.removed_layer_handles(j));		dataMapper->mLayerHandles.erase(entry.removed_layer_handles(j));
	}		}
	}		}

	flinger->stopLayerTracing(outputLayersTracePath);		flingerPtr->stopLayerTracing(outputLayersTracePath);
	ALOGD("End of generating trace file. File written to %s", outputLayersTracePath);		ALOGD("End of generating trace file. File written to %s", outputLayersTracePath);
	dataMapper->mLayerHandles.clear();		dataMapper->mLayerHandles.clear();
	return true;		return true;

services/surfaceflinger/tests/unittests/CompositionTest.cpp

+1 −32

Original line number	Original line	Diff line number	Diff line
	@@ -99,7 +99,7 @@ public:
	::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
	ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());		ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());

	setupScheduler();		mFlinger.setupMockScheduler({.displayId = DEFAULT_DISPLAY_ID});

	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)));
	@@ -122,36 +122,6 @@ public:
	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 setupScheduler() {
	auto eventThread = std::make_unique<mock::EventThread>();
	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,
	ResyncCallback())));

	EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
	EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
	.WillOnce(Return(sp<EventThreadConnection>::make(sfEventThread.get(),
	mock::EventThread::kCallingUid,
	ResyncCallback())));

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

	EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
	EXPECT_CALL(*vsyncTracker, currentPeriod())
	.WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
	EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));

	mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
	std::move(eventThread), std::move(sfEventThread),
	TestableSurfaceFlinger::SchedulerCallbackImpl::kNoOp,
	TestableSurfaceFlinger::kTwoDisplayModes);
	}

	void setupForceGeometryDirty() {		void setupForceGeometryDirty() {
	// TODO: This requires the visible region and other related		// TODO: This requires the visible region and other related
	// state to be set, and is problematic for BufferLayers since they are		// state to be set, and is problematic for BufferLayers since they are
	@@ -176,7 +146,6 @@ public:
	bool mDisplayOff = false;		bool mDisplayOff = false;
	TestableSurfaceFlinger mFlinger;		TestableSurfaceFlinger mFlinger;
	sp<DisplayDevice> mDisplay;		sp<DisplayDevice> mDisplay;
	sp<DisplayDevice> mExternalDisplay;
	sp<compositionengine::mock::DisplaySurface> mDisplaySurface =		sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
	sp<compositionengine::mock::DisplaySurface>::make();		sp<compositionengine::mock::DisplaySurface>::make();
	sp<mock::NativeWindow> mNativeWindow = sp<mock::NativeWindow>::make();		sp<mock::NativeWindow> mNativeWindow = sp<mock::NativeWindow>::make();

services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp

+9 −5

Original line number	Original line	Diff line number	Diff line
	@@ -29,9 +29,7 @@ using testing::SetArgPointee;

	using android::hardware::graphics::composer::hal::HWDisplayId;		using android::hardware::graphics::composer::hal::HWDisplayId;

	using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;		DisplayTransactionTest::DisplayTransactionTest(bool withMockScheduler) {

	DisplayTransactionTest::DisplayTransactionTest() {
	const ::testing::TestInfo* const test_info =		const ::testing::TestInfo* const test_info =
	::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
	ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());		ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
	@@ -48,7 +46,10 @@ DisplayTransactionTest::DisplayTransactionTest() {
	return nullptr;		return nullptr;
	});		});

	injectMockScheduler();		if (withMockScheduler) {
			injectMockScheduler(PhysicalDisplayId::fromPort(0));
			}

	mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));		mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));

	injectMockComposer(0);		injectMockComposer(0);
	@@ -61,7 +62,9 @@ DisplayTransactionTest::~DisplayTransactionTest() {
	mFlinger.resetScheduler(nullptr);		mFlinger.resetScheduler(nullptr);
	}		}

	void DisplayTransactionTest::injectMockScheduler() {		void DisplayTransactionTest::injectMockScheduler(PhysicalDisplayId displayId) {
			LOG_ALWAYS_FATAL_IF(mFlinger.scheduler());

	EXPECT_CALL(*mEventThread, registerDisplayEventConnection(_));		EXPECT_CALL(*mEventThread, registerDisplayEventConnection(_));
	EXPECT_CALL(*mEventThread, createEventConnection(_, _))		EXPECT_CALL(*mEventThread, createEventConnection(_, _))
	.WillOnce(Return(sp<EventThreadConnection>::make(mEventThread,		.WillOnce(Return(sp<EventThreadConnection>::make(mEventThread,
	@@ -78,6 +81,7 @@ void DisplayTransactionTest::injectMockScheduler() {
	std::unique_ptr<scheduler::VSyncTracker>(mVSyncTracker),		std::unique_ptr<scheduler::VSyncTracker>(mVSyncTracker),
	std::unique_ptr<EventThread>(mEventThread),		std::unique_ptr<EventThread>(mEventThread),
	std::unique_ptr<EventThread>(mSFEventThread),		std::unique_ptr<EventThread>(mSFEventThread),
			TestableSurfaceFlinger::DefaultDisplayMode{displayId},
	TestableSurfaceFlinger::SchedulerCallbackImpl::kMock);		TestableSurfaceFlinger::SchedulerCallbackImpl::kMock);
	}		}

services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -85,7 +85,7 @@ public:
	// --------------------------------------------------------------------		// --------------------------------------------------------------------
	// Mock/Fake injection		// Mock/Fake injection

	void injectMockScheduler();		void injectMockScheduler(PhysicalDisplayId);
	void injectMockComposer(int virtualDisplayCount);		void injectMockComposer(int virtualDisplayCount);
	void injectFakeBufferQueueFactory();		void injectFakeBufferQueueFactory();
	void injectFakeNativeWindowSurfaceFactory();		void injectFakeNativeWindowSurfaceFactory();
	@@ -139,7 +139,7 @@ public:
	surfaceflinger::mock::NativeWindowSurface* mNativeWindowSurface = nullptr;		surfaceflinger::mock::NativeWindowSurface* mNativeWindowSurface = nullptr;

	protected:		protected:
	DisplayTransactionTest();		DisplayTransactionTest(bool withMockScheduler = true);
	};		};

	constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;		constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;

services/surfaceflinger/tests/unittests/FpsReporterTest.cpp

+1 −32

Original line number	Original line	Diff line number	Diff line
	@@ -29,9 +29,7 @@
	#include "TestableSurfaceFlinger.h"		#include "TestableSurfaceFlinger.h"
	#include "fake/FakeClock.h"		#include "fake/FakeClock.h"
	#include "mock/DisplayHardware/MockComposer.h"		#include "mock/DisplayHardware/MockComposer.h"
	#include "mock/MockEventThread.h"
	#include "mock/MockFrameTimeline.h"		#include "mock/MockFrameTimeline.h"
	#include "mock/MockVsyncController.h"

	namespace android {		namespace android {

	@@ -47,7 +45,6 @@ using testing::UnorderedElementsAre;
	using android::Hwc2::IComposer;		using android::Hwc2::IComposer;
	using android::Hwc2::IComposerClient;		using android::Hwc2::IComposerClient;

	using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
	using gui::LayerMetadata;		using gui::LayerMetadata;

	struct TestableFpsListener : public gui::BnFpsListener {		struct TestableFpsListener : public gui::BnFpsListener {
	@@ -77,7 +74,6 @@ protected:
	static constexpr uint32_t LAYER_FLAGS = 0;		static constexpr uint32_t LAYER_FLAGS = 0;
	static constexpr int32_t PRIORITY_UNSET = -1;		static constexpr int32_t PRIORITY_UNSET = -1;

	void setupScheduler();
	sp<Layer> createBufferStateLayer(LayerMetadata metadata);		sp<Layer> createBufferStateLayer(LayerMetadata metadata);

	TestableSurfaceFlinger mFlinger;		TestableSurfaceFlinger mFlinger;
	@@ -102,7 +98,7 @@ FpsReporterTest::FpsReporterTest() {
	::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
	ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());		ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());

	setupScheduler();		mFlinger.setupMockScheduler();
	mFlinger.setupComposer(std::make_unique<Hwc2::mock::Composer>());		mFlinger.setupComposer(std::make_unique<Hwc2::mock::Composer>());

	mFpsListener = sp<TestableFpsListener>::make();		mFpsListener = sp<TestableFpsListener>::make();
	@@ -120,33 +116,6 @@ sp<Layer> FpsReporterTest::createBufferStateLayer(LayerMetadata metadata = {}) {
	return sp<Layer>::make(args);		return sp<Layer>::make(args);
	}		}

	void FpsReporterTest::setupScheduler() {
	auto eventThread = std::make_unique<mock::EventThread>();
	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,
	ResyncCallback())));

	EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
	EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
	.WillOnce(Return(sp<EventThreadConnection>::make(sfEventThread.get(),
	mock::EventThread::kCallingUid,
	ResyncCallback())));

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

	EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
	EXPECT_CALL(*vsyncTracker, currentPeriod())
	.WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
	EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
	mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
	std::move(eventThread), std::move(sfEventThread));
	}

	namespace {		namespace {

	TEST_F(FpsReporterTest, callsListeners) {		TEST_F(FpsReporterTest, callsListeners) {