SF: Use display device factory in unit test (0b1fe70e) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp

+292 −50

Original line number	Original line	Diff line number	Diff line
	@@ -21,12 +21,19 @@
	#include <gtest/gtest.h>		#include <gtest/gtest.h>

	#include <log/log.h>		#include <log/log.h>
			#include "system/window.h"

	#include "MockComposer.h"		#include "MockComposer.h"
			#include "MockDisplaySurface.h"
			#include "MockEventControlThread.h"
	#include "MockEventThread.h"		#include "MockEventThread.h"
	#include "MockGraphicBufferConsumer.h"		#include "MockGraphicBufferConsumer.h"
	#include "MockGraphicBufferProducer.h"		#include "MockGraphicBufferProducer.h"
			#include "MockMessageQueue.h"
			#include "MockNativeWindow.h"
			#include "MockNativeWindowSurface.h"
	#include "MockRenderEngine.h"		#include "MockRenderEngine.h"
			#include "MockSurfaceInterceptor.h"
	#include "TestableSurfaceFlinger.h"		#include "TestableSurfaceFlinger.h"

	namespace android {		namespace android {
	@@ -39,41 +46,119 @@ using testing::Mock;
	using testing::Return;		using testing::Return;
	using testing::SetArgPointee;		using testing::SetArgPointee;

			using android::hardware::graphics::common::V1_0::ColorMode;
	using android::hardware::graphics::common::V1_0::Hdr;		using android::hardware::graphics::common::V1_0::Hdr;
	using android::Hwc2::Error;		using android::Hwc2::Error;
	using android::Hwc2::IComposer;		using android::Hwc2::IComposer;
	using android::Hwc2::IComposerClient;		using android::Hwc2::IComposerClient;

	using HWC2Display = TestableSurfaceFlinger::HWC2Display;		using HWC2Display = TestableSurfaceFlinger::HWC2Display;
			using HotplugEvent = TestableSurfaceFlinger::HotplugEvent;

	constexpr int32_t DEFAULT_REFRESH_RATE = 1666666666;		constexpr int32_t DEFAULT_REFRESH_RATE = 1666666666;
	constexpr int32_t DEFAULT_DPI = 320;		constexpr int32_t DEFAULT_DPI = 320;

			constexpr int DEFAULT_CONFIG_ID = 0;

	class DisplayTransactionTest : public testing::Test {		class DisplayTransactionTest : public testing::Test {
	protected:		protected:
	DisplayTransactionTest();		DisplayTransactionTest();
	~DisplayTransactionTest() override;		~DisplayTransactionTest() override;

			// --------------------------------------------------------------------
			// Precondition helpers

	void setupComposer(int virtualDisplayCount);		void setupComposer(int virtualDisplayCount);
	void setupPrimaryDisplay(int width, int height);		void setupFakeHwcDisplay(hwc2_display_t displayId, DisplayDevice::DisplayType type, int width,
			int height);

			struct FakeDisplayDeviceFactory {
			public:
			FakeDisplayDeviceFactory(TestableSurfaceFlinger& flinger, sp<BBinder>& displayToken,
			DisplayDevice::DisplayType type, int hwcId)
			: mFlinger(flinger), mDisplayToken(displayToken), mType(type), mHwcId(hwcId) {}

			sp<DisplayDevice> build() {
			return new DisplayDevice(mFlinger.mFlinger.get(), mType, mHwcId, false, mDisplayToken,
			mNativeWindow, mDisplaySurface, std::move(mRenderSurface), 0,
			0, false, false, HWC_POWER_MODE_NORMAL);
			}

			FakeDisplayDeviceFactory& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
			mNativeWindow = nativeWindow;
			return *this;
			}

			FakeDisplayDeviceFactory& setDisplaySurface(const sp<DisplaySurface>& displaySurface) {
			mDisplaySurface = displaySurface;
			return *this;
			}

			FakeDisplayDeviceFactory& setRenderSurface(std::unique_ptr<RE::Surface> renderSurface) {
			mRenderSurface = std::move(renderSurface);
			return *this;
			}

			TestableSurfaceFlinger& mFlinger;
			sp<BBinder>& mDisplayToken;
			DisplayDevice::DisplayType mType;
			int mHwcId;
			sp<ANativeWindow> mNativeWindow;
			sp<DisplaySurface> mDisplaySurface;
			std::unique_ptr<RE::Surface> mRenderSurface;
			};

			sp<BBinder> setupFakeExistingPhysicalDisplay(hwc2_display_t displayId,
			DisplayDevice::DisplayType type);

			void setupFakeBufferQueueFactory();
			void setupFakeNativeWindowSurfaceFactory(int displayWidth, int displayHeight, bool critical,
			bool async);
			void expectFramebufferUsageSet(int width, int height, int grallocUsage);
			void expectHwcHotplugCalls(hwc2_display_t displayId, int displayWidth, int displayHeight);

			// --------------------------------------------------------------------
			// Call expectation helpers

			void expectRESurfaceCreationCalls();
			void expectPhysicalDisplayDeviceCreationCalls(hwc2_display_t displayId, int displayWidth,
			int displayHeight, bool critical, bool async);

			// --------------------------------------------------------------------
			// Postcondition helpers

			bool hasTransactionFlagSet(int flag);
			bool hasDisplayDevice(sp<IBinder> displayToken);
			sp<DisplayDevice> getDisplayDevice(sp<IBinder> displayToken);
			bool hasCurrentDisplayState(sp<IBinder> displayToken);
			const DisplayDeviceState& getCurrentDisplayState(sp<IBinder> displayToken);
			bool hasDrawingDisplayState(sp<IBinder> displayToken);
			const DisplayDeviceState& getDrawingDisplayState(sp<IBinder> displayToken);

	void expectFramebufferQueuePairCreation(int width, int height);		// --------------------------------------------------------------------
			// Test instances

	std::unordered_set<HWC2::Capability> mCapabilities;		std::unordered_set<HWC2::Capability> mCapabilities;

	TestableSurfaceFlinger mFlinger;		TestableSurfaceFlinger mFlinger;
	mock::EventThread* mEventThread = new mock::EventThread();		mock::EventThread* mEventThread = new mock::EventThread();
			mock::EventControlThread* mEventControlThread = new mock::EventControlThread();

	// These mocks are created by the test, but are destroyed by SurfaceFlinger		// These mocks are created by the test, but are destroyed by SurfaceFlinger
	// by virtue of being stored into a std::unique_ptr. However we still need		// by virtue of being stored into a std::unique_ptr. However we still need
	// to keep a reference to them for use in setting up call expectations.		// to keep a reference to them for use in setting up call expectations.
	RE::mock::RenderEngine* mRenderEngine = new RE::mock::RenderEngine();		RE::mock::RenderEngine* mRenderEngine = new RE::mock::RenderEngine();
	Hwc2::mock::Composer* mComposer = new Hwc2::mock::Composer();		Hwc2::mock::Composer* mComposer = new Hwc2::mock::Composer();
			mock::MessageQueue* mMessageQueue = new mock::MessageQueue();
			mock::SurfaceInterceptor* mSurfaceInterceptor = new mock::SurfaceInterceptor();

	// 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;
	sp<mock::GraphicBufferProducer> mProducer;		sp<mock::GraphicBufferProducer> mProducer;
	std::unique_ptr<HWC2Display> mDisplay;		mock::NativeWindowSurface* mNativeWindowSurface = nullptr;
			sp<mock::NativeWindow> mNativeWindow;
			RE::mock::Surface* mRenderSurface = nullptr;
			std::vector<std::unique_ptr<HWC2Display>> mFakeHwcDisplays;
	};		};

	DisplayTransactionTest::DisplayTransactionTest() {		DisplayTransactionTest::DisplayTransactionTest() {
	@@ -85,8 +170,16 @@ DisplayTransactionTest::DisplayTransactionTest() {
	ADD_FAILURE() << "Unexpected request to create a buffer queue.";		ADD_FAILURE() << "Unexpected request to create a buffer queue.";
	});		});

			mFlinger.setCreateNativeWindowSurface([](auto) {
			ADD_FAILURE() << "Unexpected request to create a native window surface.";
			return nullptr;
			});

			mFlinger.mutableEventControlThread().reset(mEventControlThread);
	mFlinger.mutableEventThread().reset(mEventThread);		mFlinger.mutableEventThread().reset(mEventThread);
			mFlinger.mutableEventQueue().reset(mMessageQueue);
	mFlinger.setupRenderEngine(std::unique_ptr<RE::RenderEngine>(mRenderEngine));		mFlinger.setupRenderEngine(std::unique_ptr<RE::RenderEngine>(mRenderEngine));
			mFlinger.mutableInterceptor().reset(mSurfaceInterceptor);

	setupComposer(0);		setupComposer(0);
	}		}
	@@ -106,13 +199,14 @@ void DisplayTransactionTest::setupComposer(int virtualDisplayCount) {
	Mock::VerifyAndClear(mComposer);		Mock::VerifyAndClear(mComposer);
	}		}

	void DisplayTransactionTest::setupPrimaryDisplay(int width, int height) {		void DisplayTransactionTest::setupFakeHwcDisplay(hwc2_display_t displayId,
	mDisplay = std::make_unique<HWC2Display>(*mComposer, mCapabilities, 0,		DisplayDevice::DisplayType type, int width,
			int height) {
			auto display = std::make_unique<HWC2Display>(*mComposer, mCapabilities, displayId,
	HWC2::DisplayType::Physical);		HWC2::DisplayType::Physical);
			display->mutableIsConnected() = true;
	mDisplay->mutableIsConnected() = true;		display->mutableConfigs().emplace(DEFAULT_CONFIG_ID,
	mDisplay->mutableConfigs().emplace(0,		HWC2::Display::Config::Builder(*display, DEFAULT_CONFIG_ID)
	HWC2::Display::Config::Builder(*mDisplay, 0)
	.setWidth(width)		.setWidth(width)
	.setHeight(height)		.setHeight(height)
	.setVsyncPeriod(DEFAULT_REFRESH_RATE)		.setVsyncPeriod(DEFAULT_REFRESH_RATE)
	@@ -120,12 +214,34 @@ void DisplayTransactionTest::setupPrimaryDisplay(int width, int height) {
	.setDpiY(DEFAULT_DPI)		.setDpiY(DEFAULT_DPI)
	.build());		.build());

	mFlinger.mutableHwcDisplayData()[DisplayDevice::DISPLAY_PRIMARY].reset();		mFlinger.mutableHwcDisplayData()[type].reset();
	mFlinger.mutableHwcDisplayData()[DisplayDevice::DISPLAY_PRIMARY].hwcDisplay = mDisplay.get();		mFlinger.mutableHwcDisplayData()[type].hwcDisplay = display.get();
	mFlinger.mutableHwcDisplaySlots().emplace(0, DisplayDevice::DISPLAY_PRIMARY);		mFlinger.mutableHwcDisplaySlots().emplace(displayId, type);

			mFakeHwcDisplays.push_back(std::move(display));
			}

			sp<BBinder> DisplayTransactionTest::setupFakeExistingPhysicalDisplay(
			hwc2_display_t displayId, DisplayDevice::DisplayType type) {
			setupFakeHwcDisplay(displayId, type, 0, 0);

			sp<BBinder> displayToken = new BBinder();
			mFlinger.mutableBuiltinDisplays()[type] = displayToken;
			mFlinger.mutableDisplays()
			.add(displayToken,
			FakeDisplayDeviceFactory(mFlinger, displayToken, type, type).build());

			DisplayDeviceState state(type, true);
			mFlinger.mutableCurrentState().displays.add(displayToken, state);
			mFlinger.mutableDrawingState().displays.add(displayToken, state);

			return displayToken;
	}		}

	void DisplayTransactionTest::expectFramebufferQueuePairCreation(int width, int height) {		void DisplayTransactionTest::setupFakeBufferQueueFactory() {
			// This setup is only expected once per test.
			ASSERT_TRUE(mConsumer == nullptr && mProducer == nullptr);

	mConsumer = new mock::GraphicBufferConsumer();		mConsumer = new mock::GraphicBufferConsumer();
	mProducer = new mock::GraphicBufferProducer();		mProducer = new mock::GraphicBufferProducer();

	@@ -133,61 +249,187 @@ void DisplayTransactionTest::expectFramebufferQueuePairCreation(int width, int h
	*outProducer = mProducer;		*outProducer = mProducer;
	*outConsumer = mConsumer;		*outConsumer = mConsumer;
	});		});
			}

			void DisplayTransactionTest::setupFakeNativeWindowSurfaceFactory(int displayWidth,
			int displayHeight, bool critical,
			bool async) {
			// This setup is only expected once per test.
			ASSERT_TRUE(mNativeWindowSurface == nullptr);

			mNativeWindowSurface = new mock::NativeWindowSurface();
			mNativeWindow = new mock::NativeWindow();

			mFlinger.setCreateNativeWindowSurface(
			[this](auto) { return std::unique_ptr<NativeWindowSurface>(mNativeWindowSurface); });

			EXPECT_CALL(*mNativeWindowSurface, getNativeWindow()).WillOnce(Return(mNativeWindow));

			EXPECT_CALL(*mNativeWindow, perform(19)).Times(1);

			EXPECT_CALL(*mRenderSurface, setAsync(async)).Times(1);
			EXPECT_CALL(*mRenderSurface, setCritical(critical)).Times(1);
			EXPECT_CALL(*mRenderSurface, setNativeWindow(mNativeWindow.get())).Times(1);
			EXPECT_CALL(*mRenderSurface, queryWidth()).WillOnce(Return(displayWidth));
			EXPECT_CALL(*mRenderSurface, queryHeight()).WillOnce(Return(displayHeight));
			}

			void DisplayTransactionTest::expectFramebufferUsageSet(int width, int height, int grallocUsage) {
	EXPECT_CALL(*mConsumer, consumerConnect(_, false)).WillOnce(Return(NO_ERROR));		EXPECT_CALL(*mConsumer, consumerConnect(_, false)).WillOnce(Return(NO_ERROR));
	EXPECT_CALL(*mConsumer, setConsumerName(_)).WillRepeatedly(Return(NO_ERROR));		EXPECT_CALL(*mConsumer, setConsumerName(_)).WillRepeatedly(Return(NO_ERROR));
	EXPECT_CALL(*mConsumer,		EXPECT_CALL(*mConsumer, setConsumerUsageBits(grallocUsage)).WillRepeatedly(Return(NO_ERROR));
	setConsumerUsageBits(GRALLOC_USAGE_HW_RENDER \| GRALLOC_USAGE_HW_COMPOSER \|
	GRALLOC_USAGE_HW_FB))
	.WillRepeatedly(Return(NO_ERROR));
	EXPECT_CALL(*mConsumer, setDefaultBufferSize(width, height)).WillRepeatedly(Return(NO_ERROR));		EXPECT_CALL(*mConsumer, setDefaultBufferSize(width, height)).WillRepeatedly(Return(NO_ERROR));
	EXPECT_CALL(*mConsumer, setMaxAcquiredBufferCount(_)).WillRepeatedly(Return(NO_ERROR));		EXPECT_CALL(*mConsumer, setMaxAcquiredBufferCount(_)).WillRepeatedly(Return(NO_ERROR));

	EXPECT_CALL(*mProducer, allocateBuffers(0, 0, 0, 0)).WillRepeatedly(Return());		EXPECT_CALL(*mProducer, allocateBuffers(0, 0, 0, 0)).WillRepeatedly(Return());
	}		}

	TEST_F(DisplayTransactionTest, processDisplayChangesLockedProcessesPrimaryDisplayConnected) {		void DisplayTransactionTest::expectHwcHotplugCalls(hwc2_display_t displayId, int displayWidth,
	using android::hardware::graphics::common::V1_0::ColorMode;		int displayHeight) {
			EXPECT_CALL(*mComposer, getDisplayType(displayId, _))
			.WillOnce(DoAll(SetArgPointee<1>(IComposerClient::DisplayType::PHYSICAL),
			Return(Error::NONE)));
			EXPECT_CALL(*mComposer, setClientTargetSlotCount(_)).WillOnce(Return(Error::NONE));
			EXPECT_CALL(*mComposer, getDisplayConfigs(_, _))
			.WillOnce(DoAll(SetArgPointee<1>(std::vector<unsigned>{0}), Return(Error::NONE)));
			EXPECT_CALL(*mComposer, getDisplayAttribute(displayId, 0, IComposerClient::Attribute::WIDTH, _))
			.WillOnce(DoAll(SetArgPointee<3>(displayWidth), Return(Error::NONE)));
			EXPECT_CALL(*mComposer,
			getDisplayAttribute(displayId, 0, IComposerClient::Attribute::HEIGHT, _))
			.WillOnce(DoAll(SetArgPointee<3>(displayHeight), Return(Error::NONE)));
			EXPECT_CALL(*mComposer,
			getDisplayAttribute(displayId, 0, IComposerClient::Attribute::VSYNC_PERIOD, _))
			.WillOnce(DoAll(SetArgPointee<3>(DEFAULT_REFRESH_RATE), Return(Error::NONE)));
			EXPECT_CALL(*mComposer, getDisplayAttribute(displayId, 0, IComposerClient::Attribute::DPI_X, _))
			.WillOnce(DoAll(SetArgPointee<3>(DEFAULT_DPI), Return(Error::NONE)));
			EXPECT_CALL(*mComposer, getDisplayAttribute(displayId, 0, IComposerClient::Attribute::DPI_Y, _))
			.WillOnce(DoAll(SetArgPointee<3>(DEFAULT_DPI), Return(Error::NONE)));
			}

	setupPrimaryDisplay(1920, 1080);		void DisplayTransactionTest::expectRESurfaceCreationCalls() {
			// This setup is only expected once per test.
			ASSERT_TRUE(mRenderSurface == nullptr);

	sp<BBinder> token = new BBinder();		mRenderSurface = new RE::mock::Surface();
	mFlinger.mutableCurrentState().displays.add(token, {DisplayDevice::DISPLAY_PRIMARY, true});		EXPECT_CALL(*mRenderEngine, createSurface())
			.WillOnce(Return(ByMove(std::unique_ptr<RE::Surface>(mRenderSurface))));
			}

	EXPECT_CALL(*mComposer, getActiveConfig(DisplayDevice::DISPLAY_PRIMARY, _))		void DisplayTransactionTest::expectPhysicalDisplayDeviceCreationCalls(hwc2_display_t displayId,
	.WillOnce(DoAll(SetArgPointee<1>(0), Return(Error::NONE)));		int displayWidth,
	EXPECT_CALL(*mComposer, getColorModes(DisplayDevice::DISPLAY_PRIMARY, _)).Times(0);		int displayHeight,
	EXPECT_CALL(*mComposer, getHdrCapabilities(DisplayDevice::DISPLAY_PRIMARY, _, _, _, _))		bool critical, bool async) {
			EXPECT_CALL(*mComposer, getActiveConfig(displayId, _))
			.WillOnce(DoAll(SetArgPointee<1>(DEFAULT_CONFIG_ID), Return(Error::NONE)));
			EXPECT_CALL(*mComposer, getColorModes(displayId, _)).Times(0);
			EXPECT_CALL(*mComposer, getHdrCapabilities(displayId, _, _, _, _))
	.WillOnce(DoAll(SetArgPointee<1>(std::vector<Hdr>()), Return(Error::NONE)));		.WillOnce(DoAll(SetArgPointee<1>(std::vector<Hdr>()), Return(Error::NONE)));

	expectFramebufferQueuePairCreation(1920, 1080);		setupFakeBufferQueueFactory();
			expectFramebufferUsageSet(displayWidth, displayHeight,
			GRALLOC_USAGE_HW_RENDER \| GRALLOC_USAGE_HW_COMPOSER \|
			GRALLOC_USAGE_HW_FB);

	auto reSurface = new RE::mock::Surface();		setupFakeNativeWindowSurfaceFactory(displayWidth, displayHeight, critical, async);
	EXPECT_CALL(*mRenderEngine, createSurface())		}
	.WillOnce(Return(ByMove(std::unique_ptr<RE::Surface>(reSurface))));
	EXPECT_CALL(*reSurface, setAsync(false)).Times(1);		bool DisplayTransactionTest::hasTransactionFlagSet(int flag) {
	EXPECT_CALL(*reSurface, setCritical(true)).Times(1);		return mFlinger.mutableTransactionFlags() & flag;
	EXPECT_CALL(*reSurface, setNativeWindow(_)).Times(1);		}
	EXPECT_CALL(*reSurface, queryWidth()).WillOnce(Return(1920));
	EXPECT_CALL(*reSurface, queryHeight()).WillOnce(Return(1080));		bool DisplayTransactionTest::hasDisplayDevice(sp<IBinder> displayToken) {
			return mFlinger.mutableDisplays().indexOfKey(displayToken) >= 0;
			}

			sp<DisplayDevice> DisplayTransactionTest::getDisplayDevice(sp<IBinder> displayToken) {
			return mFlinger.mutableDisplays().valueFor(displayToken);
			}

			bool DisplayTransactionTest::hasCurrentDisplayState(sp<IBinder> displayToken) {
			return mFlinger.mutableCurrentState().displays.indexOfKey(displayToken) >= 0;
			}

			const DisplayDeviceState& DisplayTransactionTest::getCurrentDisplayState(sp<IBinder> displayToken) {
			return mFlinger.mutableCurrentState().displays.valueFor(displayToken);
			}

			bool DisplayTransactionTest::hasDrawingDisplayState(sp<IBinder> displayToken) {
			return mFlinger.mutableDrawingState().displays.indexOfKey(displayToken) >= 0;
			}

			const DisplayDeviceState& DisplayTransactionTest::getDrawingDisplayState(sp<IBinder> displayToken) {
			return mFlinger.mutableDrawingState().displays.valueFor(displayToken);
			}

			/* ------------------------------------------------------------------------
			* SurfaceFlinger::handleTransactionLocked(eDisplayTransactionNeeded)
			*/

			TEST_F(DisplayTransactionTest, handleTransactionLockedProcessesHotplugConnectPrimary) {
			constexpr hwc2_display_t externalDisplayId = 102;
			constexpr hwc2_display_t displayId = 123;
			constexpr int displayWidth = 1920;
			constexpr int displayHeight = 1080;

			// --------------------------------------------------------------------
			// Preconditions

			// An external display may already be set up
			setupFakeHwcDisplay(externalDisplayId, DisplayDevice::DISPLAY_EXTERNAL, 3840, 2160);

			// A hotplug connect comes in for a new display
			mFlinger.mutablePendingHotplugEvents().emplace_back(
			HotplugEvent{displayId, HWC2::Connection::Connected});

			// --------------------------------------------------------------------
			// Call Expectations

			EXPECT_CALL(*mComposer, isUsingVrComposer()).WillOnce(Return(false));
			expectHwcHotplugCalls(displayId, displayWidth, displayHeight);
			expectRESurfaceCreationCalls();
			expectPhysicalDisplayDeviceCreationCalls(displayId, displayWidth, displayHeight, true, false);

			EXPECT_CALL(*mSurfaceInterceptor, saveDisplayCreation(_)).Times(1);

	EXPECT_CALL(*mEventThread, onHotplugReceived(DisplayDevice::DISPLAY_PRIMARY, true)).Times(1);		EXPECT_CALL(*mEventThread, onHotplugReceived(DisplayDevice::DISPLAY_PRIMARY, true)).Times(1);

	mFlinger.processDisplayChangesLocked();		// --------------------------------------------------------------------
			// Invocation

			mFlinger.handleTransactionLocked(eDisplayTransactionNeeded);

	ASSERT_TRUE(mFlinger.mutableDisplays().indexOfKey(token) >= 0);		// --------------------------------------------------------------------
			// Postconditions

	const auto& device = mFlinger.mutableDisplays().valueFor(token);		// HWComposer should have an entry for the display
	ASSERT_TRUE(device.get());		EXPECT_TRUE(mFlinger.mutableHwcDisplaySlots().count(displayId) == 1);

			// The display should have set up as a primary built-in display.
			auto displayToken = mFlinger.mutableBuiltinDisplays()[DisplayDevice::DISPLAY_PRIMARY];
			ASSERT_TRUE(displayToken != nullptr);

			// The display device should have been set up in the list of displays.
			ASSERT_TRUE(hasDisplayDevice(displayToken));
			const auto& device = getDisplayDevice(displayToken);
	EXPECT_TRUE(device->isSecure());		EXPECT_TRUE(device->isSecure());
	EXPECT_TRUE(device->isPrimary());		EXPECT_TRUE(device->isPrimary());

	ssize_t i = mFlinger.mutableDrawingState().displays.indexOfKey(token);		// The display should have been set up in the current display state
	ASSERT_GE(0, i);		ASSERT_TRUE(hasCurrentDisplayState(displayToken));
	const auto& draw = mFlinger.mutableDrawingState().displays[i];		const auto& current = getCurrentDisplayState(displayToken);
			EXPECT_EQ(DisplayDevice::DISPLAY_PRIMARY, current.type);

			// The display should have been set up in the drawing display state
			ASSERT_TRUE(hasDrawingDisplayState(displayToken));
			const auto& draw = getDrawingDisplayState(displayToken);
	EXPECT_EQ(DisplayDevice::DISPLAY_PRIMARY, draw.type);		EXPECT_EQ(DisplayDevice::DISPLAY_PRIMARY, draw.type);

	EXPECT_CALL(*mConsumer, consumerDisconnect()).Times(1);		// --------------------------------------------------------------------
			// Cleanup conditions

			EXPECT_CALL(*mComposer, setVsyncEnabled(displayId, IComposerClient::Vsync::DISABLE))
			.WillOnce(Return(Error::NONE));
			EXPECT_CALL(*mConsumer, consumerDisconnect()).WillOnce(Return(NO_ERROR));
	}		}

	} // namespace		} // namespace

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+21 −4

Original line number	Original line	Diff line number	Diff line
	@@ -45,26 +45,40 @@ public:
	}		}

	using CreateBufferQueueFunction = SurfaceFlinger::CreateBufferQueueFunction;		using CreateBufferQueueFunction = SurfaceFlinger::CreateBufferQueueFunction;

	void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {		void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
	mFlinger->mCreateBufferQueue = f;		mFlinger->mCreateBufferQueue = f;
	}		}

			using CreateNativeWindowSurfaceFunction = SurfaceFlinger::CreateNativeWindowSurfaceFunction;
			void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
			mFlinger->mCreateNativeWindowSurface = f;
			}

			using HotplugEvent = SurfaceFlinger::HotplugEvent;

	/* ------------------------------------------------------------------------		/* ------------------------------------------------------------------------
	* Forwarding for functions being tested		* Forwarding for functions being tested
	*/		*/
	auto processDisplayChangesLocked() { return mFlinger->processDisplayChangesLocked(); }
			auto handleTransactionLocked(uint32_t transactionFlags) {
			return mFlinger->handleTransactionLocked(transactionFlags);
			}

	/* ------------------------------------------------------------------------		/* ------------------------------------------------------------------------
	* Read-write access to private data to set up preconditions and assert		* Read-write access to private data to set up preconditions and assert
	* post-conditions.		* post-conditions.
	*/		*/

	auto& mutableBuiltinDisplays() { return mFlinger->mBuiltinDisplays; }		auto& mutableBuiltinDisplays() { return mFlinger->mBuiltinDisplays; }
	auto& mutableDisplays() { return mFlinger->mDisplays; }
	auto& mutableCurrentState() { return mFlinger->mCurrentState; }		auto& mutableCurrentState() { return mFlinger->mCurrentState; }
			auto& mutableDisplays() { return mFlinger->mDisplays; }
	auto& mutableDrawingState() { return mFlinger->mDrawingState; }		auto& mutableDrawingState() { return mFlinger->mDrawingState; }
	auto& mutableEventThread() { return mFlinger->mEventThread; }		auto& mutableEventControlThread() { return mFlinger->mEventControlThread; }
	auto& mutableEventQueue() { return mFlinger->mEventQueue; }		auto& mutableEventQueue() { return mFlinger->mEventQueue; }
			auto& mutableEventThread() { return mFlinger->mEventThread; }
			auto& mutableInterceptor() { return mFlinger->mInterceptor; }
			auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
			auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }

	auto& mutableHwcDisplayData() { return mFlinger->getBE().mHwc->mDisplayData; }		auto& mutableHwcDisplayData() { return mFlinger->getBE().mHwc->mDisplayData; }
	auto& mutableHwcDisplaySlots() { return mFlinger->getBE().mHwc->mHwcDisplaySlots; }		auto& mutableHwcDisplaySlots() { return mFlinger->getBE().mHwc->mHwcDisplaySlots; }
	@@ -75,7 +89,10 @@ public:
	// still be referenced by something despite our best efforts to destroy		// still be referenced by something despite our best efforts to destroy
	// it after each test is done.		// it after each test is done.
	mutableDisplays().clear();		mutableDisplays().clear();
			mutableEventControlThread().reset();
			mutableEventQueue().reset();
	mutableEventThread().reset();		mutableEventThread().reset();
			mutableInterceptor().reset();
	mFlinger->getBE().mHwc.reset();		mFlinger->getBE().mHwc.reset();
	mFlinger->getBE().mRenderEngine.reset();		mFlinger->getBE().mRenderEngine.reset();
	}		}