Merge "SF: Handle all HWComposer::getActiveMode errors" (bac4b527) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/DisplayHardware/HWComposer.cpp

+3 −8

Original line number	Diff line number	Diff line
		@@ -286,17 +286,12 @@ std::vector<HWComposer::HWCDisplayMode> HWComposer::getModes(PhysicalDisplayId d

		std::optional<hal::HWConfigId> HWComposer::getActiveMode(PhysicalDisplayId displayId) const {
		RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);

		const auto hwcId = *fromPhysicalDisplayId(displayId);
		ALOGV("[%" PRIu64 "] getActiveMode", hwcId);
		hal::HWConfigId configId;
		auto error = static_cast<hal::Error>(mComposer->getActiveConfig(hwcId, &configId));

		if (error == hal::Error::BAD_CONFIG) {
		LOG_DISPLAY_ERROR(displayId, "No active mode");
		return std::nullopt;
		}
		hal::HWConfigId configId;
		const auto error = static_cast<hal::Error>(mComposer->getActiveConfig(hwcId, &configId));

		RETURN_IF_HWC_ERROR_FOR("getActiveConfig", error, displayId, std::nullopt);
		return configId;
		}

services/surfaceflinger/tests/unittests/HWComposerTest.cpp

+56 −24

Original line number	Diff line number	Diff line
		@@ -59,27 +59,62 @@ using ::testing::Return;
		using ::testing::SetArgPointee;
		using ::testing::StrictMock;

		TEST(HWComposerTest, isHeadless) {
		Hwc2::mock::Composer* mHal = new StrictMock<Hwc2::mock::Composer>();
		impl::HWComposer hwc{std::unique_ptr<Hwc2::Composer>(mHal)};
		ASSERT_TRUE(hwc.isHeadless());
		struct HWComposerTest : testing::Test {
		using HalError = hardware::graphics::composer::V2_1::Error;

		const hal::HWDisplayId hwcId = 1;
		Hwc2::mock::Composer* const mHal = new StrictMock<Hwc2::mock::Composer>();
		impl::HWComposer mHwc{std::unique_ptr<Hwc2::Composer>(mHal)};

		EXPECT_CALL(*mHal, getDisplayIdentificationData(_, _, _))
		.WillOnce(DoAll(SetArgPointee<2>(getExternalEdid()),
		Return(hardware::graphics::composer::V2_1::Error::NONE)));
		void expectHotplugConnect(hal::HWDisplayId hwcDisplayId) {
		constexpr uint8_t kPort = 255;
		EXPECT_CALL(*mHal, getDisplayIdentificationData(hwcDisplayId, _, _))
		.WillOnce(DoAll(SetArgPointee<1>(kPort),
		SetArgPointee<2>(getExternalEdid()), Return(HalError::NONE)));

		EXPECT_CALL(*mHal, setVsyncEnabled(_, _));
		EXPECT_CALL(*mHal, setClientTargetSlotCount(_));
		EXPECT_CALL(*mHal, setVsyncEnabled(hwcDisplayId, Hwc2::IComposerClient::Vsync::DISABLE));
		}
		};

		TEST_F(HWComposerTest, isHeadless) {
		ASSERT_TRUE(mHwc.isHeadless());

		constexpr hal::HWDisplayId kHwcDisplayId = 1;
		expectHotplugConnect(kHwcDisplayId);

		auto info = hwc.onHotplug(hwcId, hal::Connection::CONNECTED);
		const auto info = mHwc.onHotplug(kHwcDisplayId, hal::Connection::CONNECTED);
		ASSERT_TRUE(info);
		auto displayId = info->id;
		ASSERT_FALSE(hwc.isHeadless());

		hwc.disconnectDisplay(displayId);
		ASSERT_TRUE(hwc.isHeadless());
		ASSERT_FALSE(mHwc.isHeadless());

		mHwc.disconnectDisplay(info->id);
		ASSERT_TRUE(mHwc.isHeadless());
		}

		TEST_F(HWComposerTest, getActiveMode) {
		// Unknown display.
		EXPECT_EQ(mHwc.getActiveMode(PhysicalDisplayId::fromPort(0)), std::nullopt);

		constexpr hal::HWDisplayId kHwcDisplayId = 2;
		expectHotplugConnect(kHwcDisplayId);

		const auto info = mHwc.onHotplug(kHwcDisplayId, hal::Connection::CONNECTED);
		ASSERT_TRUE(info);

		{
		// Display is known to SF but not HWC, e.g. the hotplug disconnect is pending.
		EXPECT_CALL(*mHal, getActiveConfig(kHwcDisplayId, _))
		.WillOnce(Return(HalError::BAD_DISPLAY));

		EXPECT_EQ(mHwc.getActiveMode(info->id), std::nullopt);
		}
		{
		constexpr hal::HWConfigId kConfigId = 42;
		EXPECT_CALL(*mHal, getActiveConfig(kHwcDisplayId, _))
		.WillOnce(DoAll(SetArgPointee<1>(kConfigId), Return(HalError::NONE)));

		EXPECT_EQ(mHwc.getActiveMode(info->id), kConfigId);
		}
		}

		struct MockHWC2ComposerCallback final : StrictMock<HWC2::ComposerCallback> {
		@@ -93,8 +128,7 @@ struct MockHWC2ComposerCallback final : StrictMock<HWC2::ComposerCallback> {
		MOCK_METHOD1(onComposerHalVsyncIdle, void(hal::HWDisplayId));
		};

		struct HWComposerSetCallbackTest : testing::Test {
		Hwc2::mock::Composer* mHal = new StrictMock<Hwc2::mock::Composer>();
		struct HWComposerSetCallbackTest : HWComposerTest {
		MockHWC2ComposerCallback mCallback;
		};

		@@ -113,10 +147,9 @@ TEST_F(HWComposerSetCallbackTest, loadsLayerMetadataSupport) {
		Return(hardware::graphics::composer::V2_4::Error::NONE)));
		EXPECT_CALL(*mHal, registerCallback(_));

		impl::HWComposer hwc{std::unique_ptr<Hwc2::Composer>(mHal)};
		hwc.setCallback(mCallback);
		mHwc.setCallback(mCallback);

		const auto& supported = hwc.getSupportedLayerGenericMetadata();
		const auto& supported = mHwc.getSupportedLayerGenericMetadata();
		EXPECT_EQ(2u, supported.size());
		EXPECT_EQ(1u, supported.count(kMetadata1Name));
		EXPECT_EQ(kMetadata1Mandatory, supported.find(kMetadata1Name)->second);
		@@ -130,11 +163,10 @@ TEST_F(HWComposerSetCallbackTest, handlesUnsupportedCallToGetLayerGenericMetadat
		.WillOnce(Return(hardware::graphics::composer::V2_4::Error::UNSUPPORTED));
		EXPECT_CALL(*mHal, registerCallback(_));

		impl::HWComposer hwc{std::unique_ptr<Hwc2::Composer>(mHal)};
		hwc.setCallback(mCallback);
		mHwc.setCallback(mCallback);

		const auto& supported = hwc.getSupportedLayerGenericMetadata();
		EXPECT_EQ(0u, supported.size());
		const auto& supported = mHwc.getSupportedLayerGenericMetadata();
		EXPECT_TRUE(supported.empty());
		}

		struct HWComposerLayerTest : public testing::Test {