CE: Allow the final class to set the types used
Modifies the various CompositionEngine implementation classes so that
they no longer store instances of the state structures they manipulate.
Instead the implementation gets access to the state using an accessor,
which is only implemented by a final derived class type.
Doing this allows for implementation inheritance, where a derived
implementation can leverage covariance to work with a more specialized type.
Test: atest libsurfaceflinger_unittest libcompositionengine_test
Test: go/wm-smoke
Bug: 121291683
Change-Id: I26366900fc4c7869f4de91f25e43b3bec917f63d
diff --git a/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp b/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp
index 74b3ada..8401f08 100644
--- a/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp
@@ -58,7 +58,7 @@
layers.emplace_back(mLayer1);
layers.emplace_back(mLayer2);
layers.emplace_back(mLayer3);
- mDisplay.setOutputLayersOrderedByZ(std::move(layers));
+ mDisplay->setOutputLayersOrderedByZ(std::move(layers));
}
StrictMock<android::mock::HWComposer> mHwComposer;
@@ -71,11 +71,12 @@
mock::OutputLayer* mLayer1 = new StrictMock<mock::OutputLayer>();
mock::OutputLayer* mLayer2 = new StrictMock<mock::OutputLayer>();
mock::OutputLayer* mLayer3 = new StrictMock<mock::OutputLayer>();
- impl::Display mDisplay{mCompositionEngine,
- DisplayCreationArgsBuilder()
- .setDisplayId(DEFAULT_DISPLAY_ID)
- .setPowerAdvisor(&mPowerAdvisor)
- .build()};
+ std::shared_ptr<impl::Display> mDisplay =
+ impl::createDisplay(mCompositionEngine,
+ DisplayCreationArgsBuilder()
+ .setDisplayId(DEFAULT_DISPLAY_ID)
+ .setPowerAdvisor(&mPowerAdvisor)
+ .build());
};
/*
@@ -95,12 +96,10 @@
{
constexpr DisplayId display2 = DisplayId{546u};
- auto display = impl::createDisplay(mCompositionEngine,
- DisplayCreationArgsBuilder()
- .setIsSecure(true)
- .setDisplayId(display2)
- .build());
- EXPECT_TRUE(display->isSecure());
+ auto display =
+ impl::createDisplay(mCompositionEngine,
+ DisplayCreationArgsBuilder().setDisplayId(display2).build());
+ EXPECT_FALSE(display->isSecure());
EXPECT_FALSE(display->isVirtual());
EXPECT_EQ(display2, display->getId());
}
@@ -126,13 +125,13 @@
// The first call to disconnect will disconnect the display with the HWC and
// set mHwcId to -1.
EXPECT_CALL(mHwComposer, disconnectDisplay(DEFAULT_DISPLAY_ID)).Times(1);
- mDisplay.disconnect();
- EXPECT_FALSE(mDisplay.getId());
+ mDisplay->disconnect();
+ EXPECT_FALSE(mDisplay->getId());
// Subsequent calls will do nothing,
EXPECT_CALL(mHwComposer, disconnectDisplay(DEFAULT_DISPLAY_ID)).Times(0);
- mDisplay.disconnect();
- EXPECT_FALSE(mDisplay.getId());
+ mDisplay->disconnect();
+ EXPECT_FALSE(mDisplay->getId());
}
/*
@@ -143,7 +142,7 @@
// No change does nothing
CompositionRefreshArgs refreshArgs;
refreshArgs.colorTransformMatrix = std::nullopt;
- mDisplay.setColorTransform(refreshArgs);
+ mDisplay->setColorTransform(refreshArgs);
// Identity matrix sets an identity state value
const mat4 kIdentity;
@@ -151,7 +150,7 @@
EXPECT_CALL(mHwComposer, setColorTransform(DEFAULT_DISPLAY_ID, kIdentity)).Times(1);
refreshArgs.colorTransformMatrix = kIdentity;
- mDisplay.setColorTransform(refreshArgs);
+ mDisplay->setColorTransform(refreshArgs);
// Non-identity matrix sets a non-identity state value
const mat4 kNonIdentity = mat4() * 2;
@@ -159,7 +158,7 @@
EXPECT_CALL(mHwComposer, setColorTransform(DEFAULT_DISPLAY_ID, kNonIdentity)).Times(1);
refreshArgs.colorTransformMatrix = kNonIdentity;
- mDisplay.setColorTransform(refreshArgs);
+ mDisplay->setColorTransform(refreshArgs);
}
/*
@@ -170,27 +169,27 @@
using ColorProfile = Output::ColorProfile;
mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
- mDisplay.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
+ mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
- mDisplay.setDisplayColorProfileForTest(std::unique_ptr<DisplayColorProfile>(colorProfile));
+ mDisplay->setDisplayColorProfileForTest(std::unique_ptr<DisplayColorProfile>(colorProfile));
EXPECT_CALL(*colorProfile, getTargetDataspace(_, _, _))
.WillRepeatedly(Return(ui::Dataspace::UNKNOWN));
// These values are expected to be the initial state.
- ASSERT_EQ(ui::ColorMode::NATIVE, mDisplay.getState().colorMode);
- ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay.getState().dataspace);
- ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay.getState().renderIntent);
- ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay.getState().targetDataspace);
+ ASSERT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
+ ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
+ ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
+ ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
- // If the set values are unchanged, nothing happens
- mDisplay.setColorProfile(ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
- ui::RenderIntent::COLORIMETRIC, ui::Dataspace::UNKNOWN});
+ // Otherwise if the values are unchanged, nothing happens
+ mDisplay->setColorProfile(ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
+ ui::RenderIntent::COLORIMETRIC, ui::Dataspace::UNKNOWN});
- EXPECT_EQ(ui::ColorMode::NATIVE, mDisplay.getState().colorMode);
- EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay.getState().dataspace);
- EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay.getState().renderIntent);
- EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay.getState().targetDataspace);
+ EXPECT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
+ EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
+ EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
+ EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
// Otherwise if the values are different, updates happen
EXPECT_CALL(*renderSurface, setBufferDataspace(ui::Dataspace::DISPLAY_P3)).Times(1);
@@ -199,24 +198,24 @@
ui::RenderIntent::TONE_MAP_COLORIMETRIC))
.Times(1);
- mDisplay.setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
- ui::RenderIntent::TONE_MAP_COLORIMETRIC,
- ui::Dataspace::UNKNOWN});
+ mDisplay->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
+ ui::RenderIntent::TONE_MAP_COLORIMETRIC,
+ ui::Dataspace::UNKNOWN});
- EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mDisplay.getState().colorMode);
- EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mDisplay.getState().dataspace);
- EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mDisplay.getState().renderIntent);
- EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay.getState().targetDataspace);
+ EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mDisplay->getState().colorMode);
+ EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mDisplay->getState().dataspace);
+ EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mDisplay->getState().renderIntent);
+ EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
}
TEST_F(DisplayTest, setColorModeDoesNothingForVirtualDisplay) {
using ColorProfile = Output::ColorProfile;
- impl::Display virtualDisplay{mCompositionEngine,
- DisplayCreationArgs{false, true, DEFAULT_DISPLAY_ID}};
+ std::shared_ptr<impl::Display> virtualDisplay{
+ impl::createDisplay(mCompositionEngine, DisplayCreationArgs{true, DEFAULT_DISPLAY_ID})};
mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
- virtualDisplay.setDisplayColorProfileForTest(
+ virtualDisplay->setDisplayColorProfileForTest(
std::unique_ptr<DisplayColorProfile>(colorProfile));
EXPECT_CALL(*colorProfile,
@@ -224,14 +223,14 @@
ui::Dataspace::UNKNOWN))
.WillOnce(Return(ui::Dataspace::UNKNOWN));
- virtualDisplay.setColorProfile(
+ virtualDisplay->setColorProfile(
ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
ui::RenderIntent::TONE_MAP_COLORIMETRIC, ui::Dataspace::UNKNOWN});
- EXPECT_EQ(ui::ColorMode::NATIVE, virtualDisplay.getState().colorMode);
- EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay.getState().dataspace);
- EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, virtualDisplay.getState().renderIntent);
- EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay.getState().targetDataspace);
+ EXPECT_EQ(ui::ColorMode::NATIVE, virtualDisplay->getState().colorMode);
+ EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().dataspace);
+ EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, virtualDisplay->getState().renderIntent);
+ EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().targetDataspace);
}
/*
@@ -239,11 +238,11 @@
*/
TEST_F(DisplayTest, createDisplayColorProfileSetsDisplayColorProfile) {
- EXPECT_TRUE(mDisplay.getDisplayColorProfile() == nullptr);
- mDisplay.createDisplayColorProfile(
+ EXPECT_TRUE(mDisplay->getDisplayColorProfile() == nullptr);
+ mDisplay->createDisplayColorProfile(
DisplayColorProfileCreationArgs{false, HdrCapabilities(), 0,
DisplayColorProfileCreationArgs::HwcColorModes()});
- EXPECT_TRUE(mDisplay.getDisplayColorProfile() != nullptr);
+ EXPECT_TRUE(mDisplay->getDisplayColorProfile() != nullptr);
}
/*
@@ -252,9 +251,9 @@
TEST_F(DisplayTest, createRenderSurfaceSetsRenderSurface) {
EXPECT_CALL(*mNativeWindow, disconnect(NATIVE_WINDOW_API_EGL)).WillRepeatedly(Return(NO_ERROR));
- EXPECT_TRUE(mDisplay.getRenderSurface() == nullptr);
- mDisplay.createRenderSurface(RenderSurfaceCreationArgs{640, 480, mNativeWindow, nullptr});
- EXPECT_TRUE(mDisplay.getRenderSurface() != nullptr);
+ EXPECT_TRUE(mDisplay->getRenderSurface() == nullptr);
+ mDisplay->createRenderSurface(RenderSurfaceCreationArgs{640, 480, mNativeWindow, nullptr});
+ EXPECT_TRUE(mDisplay->getRenderSurface() != nullptr);
}
/*
@@ -268,7 +267,7 @@
EXPECT_CALL(mHwComposer, createLayer(DEFAULT_DISPLAY_ID)).WillOnce(Return(&hwcLayer));
- auto outputLayer = mDisplay.createOutputLayer(layer, layerFE);
+ auto outputLayer = mDisplay->createOutputLayer(layer, layerFE);
EXPECT_EQ(&hwcLayer, outputLayer->getHwcLayer());
@@ -308,13 +307,13 @@
{
Output::ReleasedLayers releasedLayers;
releasedLayers.emplace_back(layerXLayerFE);
- mDisplay.setReleasedLayers(std::move(releasedLayers));
+ mDisplay->setReleasedLayers(std::move(releasedLayers));
}
CompositionRefreshArgs refreshArgs;
- mDisplay.setReleasedLayers(refreshArgs);
+ mDisplay->setReleasedLayers(refreshArgs);
- const auto& releasedLayers = mDisplay.getReleasedLayersForTest();
+ const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
ASSERT_EQ(1, releasedLayers.size());
}
@@ -341,9 +340,9 @@
refreshArgs.layersWithQueuedFrames.push_back(&layerXLayer);
refreshArgs.layersWithQueuedFrames.push_back(nullptr);
- mDisplay.setReleasedLayers(refreshArgs);
+ mDisplay->setReleasedLayers(refreshArgs);
- const auto& releasedLayers = mDisplay.getReleasedLayersForTest();
+ const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
ASSERT_EQ(2, releasedLayers.size());
ASSERT_EQ(layer1LayerFE.get(), releasedLayers[0].promote().get());
ASSERT_EQ(layer2LayerFE.get(), releasedLayers[1].promote().get());
@@ -356,8 +355,8 @@
struct DisplayChooseCompositionStrategyTest : public testing::Test {
struct DisplayPartialMock : public impl::Display {
DisplayPartialMock(const compositionengine::CompositionEngine& compositionEngine,
- compositionengine::DisplayCreationArgs&& args)
- : impl::Display(compositionEngine, std::move(args)) {}
+ const compositionengine::DisplayCreationArgs& args)
+ : impl::Display(args), mCompositionEngine(compositionEngine) {}
// Sets up the helper functions called by chooseCompositionStrategy to
// use a mock implementations.
@@ -366,6 +365,21 @@
MOCK_METHOD1(applyChangedTypesToLayers, void(const impl::Display::ChangedTypes&));
MOCK_METHOD1(applyDisplayRequests, void(const impl::Display::DisplayRequests&));
MOCK_METHOD1(applyLayerRequestsToLayers, void(const impl::Display::LayerRequests&));
+
+ // compositionengine::Output overrides
+ const OutputCompositionState& getState() const override { return mState; }
+ OutputCompositionState& editState() override { return mState; }
+
+ // compositionengine::impl::Output overrides
+ const CompositionEngine& getCompositionEngine() const override {
+ return mCompositionEngine;
+ };
+
+ // These need implementations though are not expected to be called.
+ MOCK_CONST_METHOD1(dumpState, void(std::string&));
+
+ const compositionengine::CompositionEngine& mCompositionEngine;
+ impl::OutputCompositionState mState;
};
DisplayChooseCompositionStrategyTest() {
@@ -380,12 +394,13 @@
};
TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutIfNotAHwcDisplay) {
- impl::Display nonHwcDisplay{mCompositionEngine, DisplayCreationArgsBuilder().build()};
- EXPECT_FALSE(nonHwcDisplay.getId());
+ std::shared_ptr<impl::Display> nonHwcDisplay{
+ impl::createDisplay(mCompositionEngine, DisplayCreationArgsBuilder().build())};
+ EXPECT_FALSE(nonHwcDisplay->getId());
- nonHwcDisplay.chooseCompositionStrategy();
+ nonHwcDisplay->chooseCompositionStrategy();
- auto& state = nonHwcDisplay.getState();
+ auto& state = nonHwcDisplay->getState();
EXPECT_TRUE(state.usesClientComposition);
EXPECT_FALSE(state.usesDeviceComposition);
}
@@ -466,7 +481,7 @@
hasDisplayCapability(std::make_optional(DEFAULT_DISPLAY_ID),
HWC2::DisplayCapability::SkipClientColorTransform))
.WillOnce(Return(true));
- EXPECT_TRUE(mDisplay.getSkipColorTransform());
+ EXPECT_TRUE(mDisplay->getSkipColorTransform());
}
/*
@@ -478,14 +493,14 @@
EXPECT_CALL(*mLayer2, requiresClientComposition()).WillOnce(Return(false));
EXPECT_CALL(*mLayer3, requiresClientComposition()).WillOnce(Return(false));
- EXPECT_FALSE(mDisplay.anyLayersRequireClientComposition());
+ EXPECT_FALSE(mDisplay->anyLayersRequireClientComposition());
}
TEST_F(DisplayTest, anyLayersRequireClientCompositionReturnsTrue) {
EXPECT_CALL(*mLayer1, requiresClientComposition()).WillOnce(Return(false));
EXPECT_CALL(*mLayer2, requiresClientComposition()).WillOnce(Return(true));
- EXPECT_TRUE(mDisplay.anyLayersRequireClientComposition());
+ EXPECT_TRUE(mDisplay->anyLayersRequireClientComposition());
}
/*
@@ -497,14 +512,14 @@
EXPECT_CALL(*mLayer2, requiresClientComposition()).WillOnce(Return(true));
EXPECT_CALL(*mLayer3, requiresClientComposition()).WillOnce(Return(true));
- EXPECT_TRUE(mDisplay.allLayersRequireClientComposition());
+ EXPECT_TRUE(mDisplay->allLayersRequireClientComposition());
}
TEST_F(DisplayTest, allLayersRequireClientCompositionReturnsFalse) {
EXPECT_CALL(*mLayer1, requiresClientComposition()).WillOnce(Return(true));
EXPECT_CALL(*mLayer2, requiresClientComposition()).WillOnce(Return(false));
- EXPECT_FALSE(mDisplay.allLayersRequireClientComposition());
+ EXPECT_FALSE(mDisplay->allLayersRequireClientComposition());
}
/*
@@ -512,7 +527,7 @@
*/
TEST_F(DisplayTest, applyChangedTypesToLayersTakesEarlyOutIfNoChangedLayers) {
- mDisplay.applyChangedTypesToLayers(impl::Display::ChangedTypes());
+ mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes());
}
TEST_F(DisplayTest, applyChangedTypesToLayersAppliesChanges) {
@@ -523,7 +538,7 @@
applyDeviceCompositionTypeChange(Hwc2::IComposerClient::Composition::DEVICE))
.Times(1);
- mDisplay.applyChangedTypesToLayers(impl::Display::ChangedTypes{
+ mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes{
{&mHWC2Layer1, HWC2::Composition::Client},
{&mHWC2Layer2, HWC2::Composition::Device},
{&mHWC2LayerUnknown, HWC2::Composition::SolidColor},
@@ -535,30 +550,30 @@
*/
TEST_F(DisplayTest, applyDisplayRequestsToLayersHandlesNoRequests) {
- mDisplay.applyDisplayRequests(static_cast<HWC2::DisplayRequest>(0));
+ mDisplay->applyDisplayRequests(static_cast<HWC2::DisplayRequest>(0));
- auto& state = mDisplay.getState();
+ auto& state = mDisplay->getState();
EXPECT_FALSE(state.flipClientTarget);
}
TEST_F(DisplayTest, applyDisplayRequestsToLayersHandlesFlipClientTarget) {
- mDisplay.applyDisplayRequests(HWC2::DisplayRequest::FlipClientTarget);
+ mDisplay->applyDisplayRequests(HWC2::DisplayRequest::FlipClientTarget);
- auto& state = mDisplay.getState();
+ auto& state = mDisplay->getState();
EXPECT_TRUE(state.flipClientTarget);
}
TEST_F(DisplayTest, applyDisplayRequestsToLayersHandlesWriteClientTargetToOutput) {
- mDisplay.applyDisplayRequests(HWC2::DisplayRequest::WriteClientTargetToOutput);
+ mDisplay->applyDisplayRequests(HWC2::DisplayRequest::WriteClientTargetToOutput);
- auto& state = mDisplay.getState();
+ auto& state = mDisplay->getState();
EXPECT_FALSE(state.flipClientTarget);
}
TEST_F(DisplayTest, applyDisplayRequestsToLayersHandlesAllRequestFlagsSet) {
- mDisplay.applyDisplayRequests(static_cast<HWC2::DisplayRequest>(~0));
+ mDisplay->applyDisplayRequests(static_cast<HWC2::DisplayRequest>(~0));
- auto& state = mDisplay.getState();
+ auto& state = mDisplay->getState();
EXPECT_TRUE(state.flipClientTarget);
}
@@ -571,7 +586,7 @@
EXPECT_CALL(*mLayer2, prepareForDeviceLayerRequests()).Times(1);
EXPECT_CALL(*mLayer3, prepareForDeviceLayerRequests()).Times(1);
- mDisplay.applyLayerRequestsToLayers(impl::Display::LayerRequests());
+ mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests());
}
TEST_F(DisplayTest, applyLayerRequestsToLayers2) {
@@ -583,7 +598,7 @@
applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest::CLEAR_CLIENT_TARGET))
.Times(1);
- mDisplay.applyLayerRequestsToLayers(impl::Display::LayerRequests{
+ mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests{
{&mHWC2Layer1, HWC2::LayerRequest::ClearClientTarget},
{&mHWC2LayerUnknown, HWC2::LayerRequest::ClearClientTarget},
});
@@ -617,7 +632,7 @@
.WillOnce(Return(layer2Fence));
EXPECT_CALL(mHwComposer, clearReleaseFences(DEFAULT_DISPLAY_ID)).Times(1);
- auto result = mDisplay.presentAndGetFrameFences();
+ auto result = mDisplay->presentAndGetFrameFences();
EXPECT_EQ(presentFence, result.presentFence);
@@ -634,10 +649,10 @@
TEST_F(DisplayTest, setExpensiveRenderingExpectedForwardsToPowerAdvisor) {
EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, true)).Times(1);
- mDisplay.setExpensiveRenderingExpected(true);
+ mDisplay->setExpensiveRenderingExpected(true);
EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false)).Times(1);
- mDisplay.setExpensiveRenderingExpected(false);
+ mDisplay->setExpensiveRenderingExpected(false);
}
/*
@@ -646,20 +661,20 @@
TEST_F(DisplayTest, finishFrameDoesNotSkipCompositionIfNotDirtyOnHwcDisplay) {
mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
- mDisplay.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
+ mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
// We expect no calls to queueBuffer if composition was skipped.
EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
- mDisplay.editState().isEnabled = true;
- mDisplay.editState().usesClientComposition = false;
- mDisplay.editState().viewport = Rect(0, 0, 1, 1);
- mDisplay.editState().dirtyRegion = Region::INVALID_REGION;
+ mDisplay->editState().isEnabled = true;
+ mDisplay->editState().usesClientComposition = false;
+ mDisplay->editState().viewport = Rect(0, 0, 1, 1);
+ mDisplay->editState().dirtyRegion = Region::INVALID_REGION;
CompositionRefreshArgs refreshArgs;
refreshArgs.repaintEverything = false;
- mDisplay.finishFrame(refreshArgs);
+ mDisplay->finishFrame(refreshArgs);
}
TEST_F(DisplayTest, finishFrameSkipsCompositionIfNotDirty) {
diff --git a/services/surfaceflinger/CompositionEngine/tests/LayerTest.cpp b/services/surfaceflinger/CompositionEngine/tests/LayerTest.cpp
index 26115a3..787f973 100644
--- a/services/surfaceflinger/CompositionEngine/tests/LayerTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/LayerTest.cpp
@@ -17,6 +17,7 @@
#include <gtest/gtest.h>
#include <compositionengine/LayerCreationArgs.h>
+#include <compositionengine/LayerFECompositionState.h>
#include <compositionengine/impl/Layer.h>
#include <compositionengine/mock/CompositionEngine.h>
#include <compositionengine/mock/LayerFE.h>
@@ -26,13 +27,28 @@
using testing::StrictMock;
-class LayerTest : public testing::Test {
-public:
+struct LayerTest : public testing::Test {
+ struct Layer final : public impl::Layer {
+ explicit Layer(const LayerCreationArgs& args) : mLayerFE(args.layerFE) {}
+ ~Layer() override = default;
+
+ // compositionengine::Layer overrides
+ sp<LayerFE> getLayerFE() const { return mLayerFE.promote(); }
+ const LayerFECompositionState& getFEState() const override { return mFrontEndState; }
+ LayerFECompositionState& editFEState() override { return mFrontEndState; }
+
+ // compositionengine::impl::Layer overrides
+ void dumpFEState(std::string& out) const override { mFrontEndState.dump(out); }
+
+ const wp<LayerFE> mLayerFE;
+ LayerFECompositionState mFrontEndState;
+ };
+
~LayerTest() override = default;
StrictMock<mock::CompositionEngine> mCompositionEngine;
sp<LayerFE> mLayerFE = new StrictMock<mock::LayerFE>();
- impl::Layer mLayer{mCompositionEngine, LayerCreationArgs{mLayerFE}};
+ Layer mLayer{LayerCreationArgs{mLayerFE}};
};
/* ------------------------------------------------------------------------
diff --git a/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp b/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp
index a1c156a..0347f75 100644
--- a/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp
@@ -15,6 +15,7 @@
*/
#include <compositionengine/impl/OutputLayer.h>
+#include <compositionengine/impl/OutputLayerCompositionState.h>
#include <compositionengine/mock/CompositionEngine.h>
#include <compositionengine/mock/DisplayColorProfile.h>
#include <compositionengine/mock/Layer.h>
@@ -55,6 +56,29 @@
}
struct OutputLayerTest : public testing::Test {
+ struct OutputLayer final : public impl::OutputLayer {
+ OutputLayer(const compositionengine::Output& output,
+ std::shared_ptr<compositionengine::Layer> layer,
+ sp<compositionengine::LayerFE> layerFE)
+ : mOutput(output), mLayer(layer), mLayerFE(layerFE) {}
+ ~OutputLayer() override = default;
+
+ // compositionengine::OutputLayer overrides
+ const compositionengine::Output& getOutput() const override { return mOutput; }
+ compositionengine::Layer& getLayer() const override { return *mLayer; }
+ compositionengine::LayerFE& getLayerFE() const override { return *mLayerFE; }
+ const impl::OutputLayerCompositionState& getState() const override { return mState; }
+ impl::OutputLayerCompositionState& editState() override { return mState; }
+
+ // compositionengine::impl::OutputLayer overrides
+ void dumpState(std::string& out) const override { mState.dump(out); }
+
+ const compositionengine::Output& mOutput;
+ std::shared_ptr<compositionengine::Layer> mLayer;
+ sp<compositionengine::LayerFE> mLayerFE;
+ impl::OutputLayerCompositionState mState;
+ };
+
OutputLayerTest() {
EXPECT_CALL(*mLayerFE, getDebugName()).WillRepeatedly(Return("Test LayerFE"));
EXPECT_CALL(mOutput, getName()).WillRepeatedly(ReturnRef(kOutputName));
@@ -68,7 +92,7 @@
new StrictMock<compositionengine::mock::Layer>()};
sp<compositionengine::mock::LayerFE> mLayerFE{
new StrictMock<compositionengine::mock::LayerFE>()};
- impl::OutputLayer mOutputLayer{mOutput, mLayer, mLayerFE};
+ OutputLayer mOutputLayer{mOutput, mLayer, mLayerFE};
LayerFECompositionState mLayerFEState;
impl::OutputCompositionState mOutputState;
@@ -413,11 +437,26 @@
OutputLayerPartialMockForUpdateCompositionState(const compositionengine::Output& output,
std::shared_ptr<compositionengine::Layer> layer,
sp<compositionengine::LayerFE> layerFE)
- : impl::OutputLayer(output, layer, layerFE) {}
+ : mOutput(output), mLayer(layer), mLayerFE(layerFE) {}
// Mock everything called by updateCompositionState to simplify testing it.
MOCK_CONST_METHOD0(calculateOutputSourceCrop, FloatRect());
MOCK_CONST_METHOD0(calculateOutputDisplayFrame, Rect());
MOCK_CONST_METHOD0(calculateOutputRelativeBufferTransform, uint32_t());
+
+ // compositionengine::OutputLayer overrides
+ const compositionengine::Output& getOutput() const override { return mOutput; }
+ compositionengine::Layer& getLayer() const override { return *mLayer; }
+ compositionengine::LayerFE& getLayerFE() const override { return *mLayerFE; }
+ const impl::OutputLayerCompositionState& getState() const override { return mState; }
+ impl::OutputLayerCompositionState& editState() override { return mState; }
+
+ // These need implementations though are not expected to be called.
+ MOCK_CONST_METHOD1(dumpState, void(std::string&));
+
+ const compositionengine::Output& mOutput;
+ std::shared_ptr<compositionengine::Layer> mLayer;
+ sp<compositionengine::LayerFE> mLayerFE;
+ impl::OutputLayerCompositionState mState;
};
struct OutputLayerUpdateCompositionStateTest : public OutputLayerTest {
diff --git a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
index 70c343b..635d77b 100644
--- a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
@@ -51,11 +51,11 @@
struct OutputTest : public testing::Test {
OutputTest() {
- mOutput.setDisplayColorProfileForTest(
+ mOutput->setDisplayColorProfileForTest(
std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
- mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
+ mOutput->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
- mOutput.editState().bounds = kDefaultDisplaySize;
+ mOutput->editState().bounds = kDefaultDisplaySize;
}
static const Rect kDefaultDisplaySize;
@@ -63,7 +63,7 @@
StrictMock<mock::CompositionEngine> mCompositionEngine;
mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
- impl::Output mOutput{mCompositionEngine};
+ std::shared_ptr<impl::Output> mOutput = impl::createOutput(mCompositionEngine);
};
const Rect OutputTest::kDefaultDisplaySize{100, 200};
@@ -77,14 +77,14 @@
EXPECT_CALL(*mDisplayColorProfile, isValid()).WillOnce(Return(true));
EXPECT_CALL(*mRenderSurface, isValid()).WillOnce(Return(true));
- EXPECT_TRUE(mOutput.isValid());
+ EXPECT_TRUE(mOutput->isValid());
// If we take away the required components, it is no longer valid.
- mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>());
+ mOutput->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>());
EXPECT_CALL(*mDisplayColorProfile, isValid()).WillOnce(Return(true));
- EXPECT_FALSE(mOutput.isValid());
+ EXPECT_FALSE(mOutput->isValid());
}
/*
@@ -92,30 +92,30 @@
*/
TEST_F(OutputTest, setCompositionEnabledDoesNothingIfAlreadyEnabled) {
- mOutput.editState().isEnabled = true;
+ mOutput->editState().isEnabled = true;
- mOutput.setCompositionEnabled(true);
+ mOutput->setCompositionEnabled(true);
- EXPECT_TRUE(mOutput.getState().isEnabled);
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region()));
+ EXPECT_TRUE(mOutput->getState().isEnabled);
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region()));
}
TEST_F(OutputTest, setCompositionEnabledSetsEnabledAndDirtiesEntireOutput) {
- mOutput.editState().isEnabled = false;
+ mOutput->editState().isEnabled = false;
- mOutput.setCompositionEnabled(true);
+ mOutput->setCompositionEnabled(true);
- EXPECT_TRUE(mOutput.getState().isEnabled);
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
+ EXPECT_TRUE(mOutput->getState().isEnabled);
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
}
TEST_F(OutputTest, setCompositionEnabledSetsDisabledAndDirtiesEntireOutput) {
- mOutput.editState().isEnabled = true;
+ mOutput->editState().isEnabled = true;
- mOutput.setCompositionEnabled(false);
+ mOutput->setCompositionEnabled(false);
- EXPECT_FALSE(mOutput.getState().isEnabled);
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
+ EXPECT_FALSE(mOutput->getState().isEnabled);
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
}
/*
@@ -130,14 +130,14 @@
const Rect scissor{9, 10, 11, 12};
const bool needsFiltering = true;
- mOutput.setProjection(transform, orientation, frame, viewport, scissor, needsFiltering);
+ mOutput->setProjection(transform, orientation, frame, viewport, scissor, needsFiltering);
- EXPECT_THAT(mOutput.getState().transform, TransformEq(transform));
- EXPECT_EQ(orientation, mOutput.getState().orientation);
- EXPECT_EQ(frame, mOutput.getState().frame);
- EXPECT_EQ(viewport, mOutput.getState().viewport);
- EXPECT_EQ(scissor, mOutput.getState().scissor);
- EXPECT_EQ(needsFiltering, mOutput.getState().needsFiltering);
+ EXPECT_THAT(mOutput->getState().transform, TransformEq(transform));
+ EXPECT_EQ(orientation, mOutput->getState().orientation);
+ EXPECT_EQ(frame, mOutput->getState().frame);
+ EXPECT_EQ(viewport, mOutput->getState().viewport);
+ EXPECT_EQ(scissor, mOutput->getState().scissor);
+ EXPECT_EQ(needsFiltering, mOutput->getState().needsFiltering);
}
/*
@@ -150,11 +150,11 @@
EXPECT_CALL(*mRenderSurface, setDisplaySize(displaySize)).Times(1);
EXPECT_CALL(*mRenderSurface, getSize()).WillOnce(ReturnRef(displaySize));
- mOutput.setBounds(displaySize);
+ mOutput->setBounds(displaySize);
- EXPECT_EQ(Rect(displaySize), mOutput.getState().bounds);
+ EXPECT_EQ(Rect(displaySize), mOutput->getState().bounds);
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region(Rect(displaySize))));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(Rect(displaySize))));
}
/*
@@ -163,12 +163,12 @@
TEST_F(OutputTest, setLayerStackFilterSetsFilterAndDirtiesEntireOutput) {
const uint32_t layerStack = 123u;
- mOutput.setLayerStackFilter(layerStack, true);
+ mOutput->setLayerStackFilter(layerStack, true);
- EXPECT_TRUE(mOutput.getState().layerStackInternal);
- EXPECT_EQ(layerStack, mOutput.getState().layerStackId);
+ EXPECT_TRUE(mOutput->getState().layerStackInternal);
+ EXPECT_EQ(layerStack, mOutput->getState().layerStackId);
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
}
/*
@@ -176,84 +176,84 @@
*/
TEST_F(OutputTest, setColorTransformWithNoChangeFlaggedSkipsUpdates) {
- mOutput.editState().colorTransformMatrix = kIdentity;
+ mOutput->editState().colorTransformMatrix = kIdentity;
// If no colorTransformMatrix is set the update should be skipped.
CompositionRefreshArgs refreshArgs;
refreshArgs.colorTransformMatrix = std::nullopt;
- mOutput.setColorTransform(refreshArgs);
+ mOutput->setColorTransform(refreshArgs);
// The internal state should be unchanged
- EXPECT_EQ(kIdentity, mOutput.getState().colorTransformMatrix);
+ EXPECT_EQ(kIdentity, mOutput->getState().colorTransformMatrix);
// No dirty region should be set
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region()));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region()));
}
TEST_F(OutputTest, setColorTransformWithNoActualChangeSkipsUpdates) {
- mOutput.editState().colorTransformMatrix = kIdentity;
+ mOutput->editState().colorTransformMatrix = kIdentity;
// Attempting to set the same colorTransformMatrix that is already set should
// also skip the update.
CompositionRefreshArgs refreshArgs;
refreshArgs.colorTransformMatrix = kIdentity;
- mOutput.setColorTransform(refreshArgs);
+ mOutput->setColorTransform(refreshArgs);
// The internal state should be unchanged
- EXPECT_EQ(kIdentity, mOutput.getState().colorTransformMatrix);
+ EXPECT_EQ(kIdentity, mOutput->getState().colorTransformMatrix);
// No dirty region should be set
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region()));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region()));
}
TEST_F(OutputTest, setColorTransformPerformsUpdateToIdentity) {
- mOutput.editState().colorTransformMatrix = kNonIdentityHalf;
+ mOutput->editState().colorTransformMatrix = kNonIdentityHalf;
// Setting a different colorTransformMatrix should perform the update.
CompositionRefreshArgs refreshArgs;
refreshArgs.colorTransformMatrix = kIdentity;
- mOutput.setColorTransform(refreshArgs);
+ mOutput->setColorTransform(refreshArgs);
// The internal state should have been updated
- EXPECT_EQ(kIdentity, mOutput.getState().colorTransformMatrix);
+ EXPECT_EQ(kIdentity, mOutput->getState().colorTransformMatrix);
// The dirtyRegion should be set to the full display size
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
}
TEST_F(OutputTest, setColorTransformPerformsUpdateForIdentityToHalf) {
- mOutput.editState().colorTransformMatrix = kIdentity;
+ mOutput->editState().colorTransformMatrix = kIdentity;
// Setting a different colorTransformMatrix should perform the update.
CompositionRefreshArgs refreshArgs;
refreshArgs.colorTransformMatrix = kNonIdentityHalf;
- mOutput.setColorTransform(refreshArgs);
+ mOutput->setColorTransform(refreshArgs);
// The internal state should have been updated
- EXPECT_EQ(kNonIdentityHalf, mOutput.getState().colorTransformMatrix);
+ EXPECT_EQ(kNonIdentityHalf, mOutput->getState().colorTransformMatrix);
// The dirtyRegion should be set to the full display size
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
}
TEST_F(OutputTest, setColorTransformPerformsUpdateForHalfToQuarter) {
- mOutput.editState().colorTransformMatrix = kNonIdentityHalf;
+ mOutput->editState().colorTransformMatrix = kNonIdentityHalf;
// Setting a different colorTransformMatrix should perform the update.
CompositionRefreshArgs refreshArgs;
refreshArgs.colorTransformMatrix = kNonIdentityQuarter;
- mOutput.setColorTransform(refreshArgs);
+ mOutput->setColorTransform(refreshArgs);
// The internal state should have been updated
- EXPECT_EQ(kNonIdentityQuarter, mOutput.getState().colorTransformMatrix);
+ EXPECT_EQ(kNonIdentityQuarter, mOutput->getState().colorTransformMatrix);
// The dirtyRegion should be set to the full display size
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
}
/*
@@ -269,16 +269,16 @@
.WillOnce(Return(ui::Dataspace::UNKNOWN));
EXPECT_CALL(*mRenderSurface, setBufferDataspace(ui::Dataspace::DISPLAY_P3)).Times(1);
- mOutput.setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
- ui::RenderIntent::TONE_MAP_COLORIMETRIC,
- ui::Dataspace::UNKNOWN});
+ mOutput->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
+ ui::RenderIntent::TONE_MAP_COLORIMETRIC,
+ ui::Dataspace::UNKNOWN});
- EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mOutput.getState().colorMode);
- EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mOutput.getState().dataspace);
- EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mOutput.getState().renderIntent);
- EXPECT_EQ(ui::Dataspace::UNKNOWN, mOutput.getState().targetDataspace);
+ EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mOutput->getState().colorMode);
+ EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mOutput->getState().dataspace);
+ EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mOutput->getState().renderIntent);
+ EXPECT_EQ(ui::Dataspace::UNKNOWN, mOutput->getState().targetDataspace);
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
}
TEST_F(OutputTest, setColorModeDoesNothingIfNoChange) {
@@ -289,16 +289,16 @@
ui::Dataspace::UNKNOWN))
.WillOnce(Return(ui::Dataspace::UNKNOWN));
- mOutput.editState().colorMode = ui::ColorMode::DISPLAY_P3;
- mOutput.editState().dataspace = ui::Dataspace::DISPLAY_P3;
- mOutput.editState().renderIntent = ui::RenderIntent::TONE_MAP_COLORIMETRIC;
- mOutput.editState().targetDataspace = ui::Dataspace::UNKNOWN;
+ mOutput->editState().colorMode = ui::ColorMode::DISPLAY_P3;
+ mOutput->editState().dataspace = ui::Dataspace::DISPLAY_P3;
+ mOutput->editState().renderIntent = ui::RenderIntent::TONE_MAP_COLORIMETRIC;
+ mOutput->editState().targetDataspace = ui::Dataspace::UNKNOWN;
- mOutput.setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
- ui::RenderIntent::TONE_MAP_COLORIMETRIC,
- ui::Dataspace::UNKNOWN});
+ mOutput->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
+ ui::RenderIntent::TONE_MAP_COLORIMETRIC,
+ ui::Dataspace::UNKNOWN});
- EXPECT_THAT(mOutput.getState().dirtyRegion, RegionEq(Region()));
+ EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region()));
}
/*
@@ -311,9 +311,9 @@
mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
EXPECT_CALL(*renderSurface, getSize()).WillOnce(ReturnRef(newDisplaySize));
- mOutput.setRenderSurface(std::unique_ptr<RenderSurface>(renderSurface));
+ mOutput->setRenderSurface(std::unique_ptr<RenderSurface>(renderSurface));
- EXPECT_EQ(Rect(newDisplaySize), mOutput.getState().bounds);
+ EXPECT_EQ(Rect(newDisplaySize), mOutput->getState().bounds);
}
/*
@@ -322,11 +322,11 @@
TEST_F(OutputTest, getDirtyRegionWithRepaintEverythingTrue) {
const Rect viewport{100, 200};
- mOutput.editState().viewport = viewport;
- mOutput.editState().dirtyRegion.set(50, 300);
+ mOutput->editState().viewport = viewport;
+ mOutput->editState().dirtyRegion.set(50, 300);
{
- Region result = mOutput.getDirtyRegion(true);
+ Region result = mOutput->getDirtyRegion(true);
EXPECT_THAT(result, RegionEq(Region(viewport)));
}
@@ -334,11 +334,11 @@
TEST_F(OutputTest, getDirtyRegionWithRepaintEverythingFalse) {
const Rect viewport{100, 200};
- mOutput.editState().viewport = viewport;
- mOutput.editState().dirtyRegion.set(50, 300);
+ mOutput->editState().viewport = viewport;
+ mOutput->editState().dirtyRegion.set(50, 300);
{
- Region result = mOutput.getDirtyRegion(false);
+ Region result = mOutput->getDirtyRegion(false);
// The dirtyRegion should be clipped to the display bounds.
EXPECT_THAT(result, RegionEq(Region(Rect(50, 200))));
@@ -354,26 +354,26 @@
const uint32_t layerStack2 = 456u;
// If the output accepts layerStack1 and internal-only layers....
- mOutput.setLayerStackFilter(layerStack1, true);
+ mOutput->setLayerStackFilter(layerStack1, true);
// A layer with no layerStack does not belong to it, internal-only or not.
- EXPECT_FALSE(mOutput.belongsInOutput(std::nullopt, false));
- EXPECT_FALSE(mOutput.belongsInOutput(std::nullopt, true));
+ EXPECT_FALSE(mOutput->belongsInOutput(std::nullopt, false));
+ EXPECT_FALSE(mOutput->belongsInOutput(std::nullopt, true));
// Any layer with layerStack1 belongs to it, internal-only or not.
- EXPECT_TRUE(mOutput.belongsInOutput(layerStack1, false));
- EXPECT_TRUE(mOutput.belongsInOutput(layerStack1, true));
- EXPECT_FALSE(mOutput.belongsInOutput(layerStack2, true));
- EXPECT_FALSE(mOutput.belongsInOutput(layerStack2, false));
+ EXPECT_TRUE(mOutput->belongsInOutput(layerStack1, false));
+ EXPECT_TRUE(mOutput->belongsInOutput(layerStack1, true));
+ EXPECT_FALSE(mOutput->belongsInOutput(layerStack2, true));
+ EXPECT_FALSE(mOutput->belongsInOutput(layerStack2, false));
// If the output accepts layerStack21 but not internal-only layers...
- mOutput.setLayerStackFilter(layerStack1, false);
+ mOutput->setLayerStackFilter(layerStack1, false);
// Only non-internal layers with layerStack1 belong to it.
- EXPECT_TRUE(mOutput.belongsInOutput(layerStack1, false));
- EXPECT_FALSE(mOutput.belongsInOutput(layerStack1, true));
- EXPECT_FALSE(mOutput.belongsInOutput(layerStack2, true));
- EXPECT_FALSE(mOutput.belongsInOutput(layerStack2, false));
+ EXPECT_TRUE(mOutput->belongsInOutput(layerStack1, false));
+ EXPECT_FALSE(mOutput->belongsInOutput(layerStack1, true));
+ EXPECT_FALSE(mOutput->belongsInOutput(layerStack2, true));
+ EXPECT_FALSE(mOutput->belongsInOutput(layerStack2, false));
}
TEST_F(OutputTest, belongsInOutputFiltersLayersAsExpected) {
@@ -386,59 +386,59 @@
const uint32_t layerStack2 = 456u;
// If the output accepts layerStack1 and internal-only layers....
- mOutput.setLayerStackFilter(layerStack1, true);
+ mOutput->setLayerStackFilter(layerStack1, true);
// A null layer pointer does not belong to the output
- EXPECT_FALSE(mOutput.belongsInOutput(nullptr));
+ EXPECT_FALSE(mOutput->belongsInOutput(nullptr));
// A layer with no layerStack does not belong to it, internal-only or not.
layerFEState.layerStackId = std::nullopt;
layerFEState.internalOnly = false;
- EXPECT_FALSE(mOutput.belongsInOutput(&layer));
+ EXPECT_FALSE(mOutput->belongsInOutput(&layer));
layerFEState.layerStackId = std::nullopt;
layerFEState.internalOnly = true;
- EXPECT_FALSE(mOutput.belongsInOutput(&layer));
+ EXPECT_FALSE(mOutput->belongsInOutput(&layer));
// Any layer with layerStack1 belongs to it, internal-only or not.
layerFEState.layerStackId = layerStack1;
layerFEState.internalOnly = false;
- EXPECT_TRUE(mOutput.belongsInOutput(&layer));
+ EXPECT_TRUE(mOutput->belongsInOutput(&layer));
layerFEState.layerStackId = layerStack1;
layerFEState.internalOnly = true;
- EXPECT_TRUE(mOutput.belongsInOutput(&layer));
+ EXPECT_TRUE(mOutput->belongsInOutput(&layer));
layerFEState.layerStackId = layerStack2;
layerFEState.internalOnly = true;
- EXPECT_FALSE(mOutput.belongsInOutput(&layer));
+ EXPECT_FALSE(mOutput->belongsInOutput(&layer));
layerFEState.layerStackId = layerStack2;
layerFEState.internalOnly = false;
- EXPECT_FALSE(mOutput.belongsInOutput(&layer));
+ EXPECT_FALSE(mOutput->belongsInOutput(&layer));
// If the output accepts layerStack1 but not internal-only layers...
- mOutput.setLayerStackFilter(layerStack1, false);
+ mOutput->setLayerStackFilter(layerStack1, false);
// A null layer pointer does not belong to the output
- EXPECT_FALSE(mOutput.belongsInOutput(nullptr));
+ EXPECT_FALSE(mOutput->belongsInOutput(nullptr));
// Only non-internal layers with layerStack1 belong to it.
layerFEState.layerStackId = layerStack1;
layerFEState.internalOnly = false;
- EXPECT_TRUE(mOutput.belongsInOutput(&layer));
+ EXPECT_TRUE(mOutput->belongsInOutput(&layer));
layerFEState.layerStackId = layerStack1;
layerFEState.internalOnly = true;
- EXPECT_FALSE(mOutput.belongsInOutput(&layer));
+ EXPECT_FALSE(mOutput->belongsInOutput(&layer));
layerFEState.layerStackId = layerStack2;
layerFEState.internalOnly = true;
- EXPECT_FALSE(mOutput.belongsInOutput(&layer));
+ EXPECT_FALSE(mOutput->belongsInOutput(&layer));
layerFEState.layerStackId = layerStack2;
layerFEState.internalOnly = false;
- EXPECT_FALSE(mOutput.belongsInOutput(&layer));
+ EXPECT_FALSE(mOutput->belongsInOutput(&layer));
}
/*
@@ -453,71 +453,24 @@
outputLayers.emplace_back(std::unique_ptr<OutputLayer>(outputLayer1));
outputLayers.emplace_back(nullptr);
outputLayers.emplace_back(std::unique_ptr<OutputLayer>(outputLayer2));
- mOutput.setOutputLayersOrderedByZ(std::move(outputLayers));
+ mOutput->setOutputLayersOrderedByZ(std::move(outputLayers));
StrictMock<mock::Layer> layer;
StrictMock<mock::Layer> otherLayer;
// If the input layer matches the first OutputLayer, it will be returned.
EXPECT_CALL(*outputLayer1, getLayer()).WillOnce(ReturnRef(layer));
- EXPECT_EQ(outputLayer1, mOutput.getOutputLayerForLayer(&layer));
+ EXPECT_EQ(outputLayer1, mOutput->getOutputLayerForLayer(&layer));
// If the input layer matches the second OutputLayer, it will be returned.
EXPECT_CALL(*outputLayer1, getLayer()).WillOnce(ReturnRef(otherLayer));
EXPECT_CALL(*outputLayer2, getLayer()).WillOnce(ReturnRef(layer));
- EXPECT_EQ(outputLayer2, mOutput.getOutputLayerForLayer(&layer));
+ EXPECT_EQ(outputLayer2, mOutput->getOutputLayerForLayer(&layer));
// If the input layer does not match an output layer, null will be returned.
EXPECT_CALL(*outputLayer1, getLayer()).WillOnce(ReturnRef(otherLayer));
EXPECT_CALL(*outputLayer2, getLayer()).WillOnce(ReturnRef(otherLayer));
- EXPECT_EQ(nullptr, mOutput.getOutputLayerForLayer(&layer));
-}
-
-/*
- * Output::getOrCreateOutputLayer()
- */
-
-TEST_F(OutputTest, getOrCreateOutputLayerWorks) {
- mock::OutputLayer* existingOutputLayer = new StrictMock<mock::OutputLayer>();
-
- Output::OutputLayers outputLayers;
- outputLayers.emplace_back(nullptr);
- outputLayers.emplace_back(std::unique_ptr<OutputLayer>(existingOutputLayer));
- mOutput.setOutputLayersOrderedByZ(std::move(outputLayers));
-
- std::shared_ptr<mock::Layer> layer{new StrictMock<mock::Layer>()};
- sp<LayerFE> layerFE{new StrictMock<mock::LayerFE>()};
-
- StrictMock<mock::Layer> otherLayer;
-
- {
- // If there is no OutputLayer corresponding to the input layer, a
- // new OutputLayer is constructed and returned.
- EXPECT_CALL(*existingOutputLayer, getLayer()).WillOnce(ReturnRef(otherLayer));
- auto result = mOutput.getOrCreateOutputLayer(layer, layerFE);
- EXPECT_NE(existingOutputLayer, result.get());
- EXPECT_TRUE(result.get() != nullptr);
- EXPECT_EQ(layer.get(), &result->getLayer());
- EXPECT_EQ(layerFE.get(), &result->getLayerFE());
-
- // The entries in the ordered array should be unchanged.
- auto& outputLayers = mOutput.getOutputLayersOrderedByZ();
- EXPECT_EQ(nullptr, outputLayers[0].get());
- EXPECT_EQ(existingOutputLayer, outputLayers[1].get());
- }
-
- {
- // If there is an existing OutputLayer for the requested layer, an owned
- // pointer is returned
- EXPECT_CALL(*existingOutputLayer, getLayer()).WillOnce(ReturnRef(*layer));
- auto result = mOutput.getOrCreateOutputLayer(layer, layerFE);
- EXPECT_EQ(existingOutputLayer, result.get());
-
- // The corresponding entry in the ordered array should be cleared.
- auto& outputLayers = mOutput.getOutputLayersOrderedByZ();
- EXPECT_EQ(nullptr, outputLayers[0].get());
- EXPECT_EQ(nullptr, outputLayers[1].get());
- }
+ EXPECT_EQ(nullptr, mOutput->getOutputLayerForLayer(&layer));
}
/*
@@ -526,12 +479,19 @@
struct OutputPrepareFrameTest : public testing::Test {
struct OutputPartialMock : public impl::Output {
- OutputPartialMock(const compositionengine::CompositionEngine& compositionEngine)
- : impl::Output(compositionEngine) {}
-
// Sets up the helper functions called by prepareFrame to use a mock
// implementations.
MOCK_METHOD0(chooseCompositionStrategy, void());
+
+ // compositionengine::Output overrides
+ const OutputCompositionState& getState() const override { return mState; }
+ OutputCompositionState& editState() override { return mState; }
+
+ // These need implementations though are not expected to be called.
+ MOCK_CONST_METHOD1(dumpState, void(std::string&));
+ MOCK_CONST_METHOD0(getCompositionEngine, const CompositionEngine&());
+
+ impl::OutputCompositionState mState;
};
OutputPrepareFrameTest() {
@@ -543,7 +503,7 @@
StrictMock<mock::CompositionEngine> mCompositionEngine;
mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
- StrictMock<OutputPartialMock> mOutput{mCompositionEngine};
+ StrictMock<OutputPartialMock> mOutput;
};
TEST_F(OutputPrepareFrameTest, takesEarlyOutIfNotEnabled) {
@@ -566,16 +526,16 @@
// Note: Use OutputTest and not OutputPrepareFrameTest, so the real
// base chooseCompositionStrategy() is invoked.
TEST_F(OutputTest, prepareFrameSetsClientCompositionOnlyByDefault) {
- mOutput.editState().isEnabled = true;
- mOutput.editState().usesClientComposition = false;
- mOutput.editState().usesDeviceComposition = true;
+ mOutput->editState().isEnabled = true;
+ mOutput->editState().usesClientComposition = false;
+ mOutput->editState().usesDeviceComposition = true;
EXPECT_CALL(*mRenderSurface, prepareFrame(true, false));
- mOutput.prepareFrame();
+ mOutput->prepareFrame();
- EXPECT_TRUE(mOutput.getState().usesClientComposition);
- EXPECT_FALSE(mOutput.getState().usesDeviceComposition);
+ EXPECT_TRUE(mOutput->getState().usesClientComposition);
+ EXPECT_FALSE(mOutput->getState().usesDeviceComposition);
}
/*
@@ -592,9 +552,6 @@
static const mat4 kDefaultColorTransformMat;
struct OutputPartialMock : public impl::Output {
- OutputPartialMock(const compositionengine::CompositionEngine& compositionEngine)
- : impl::Output(compositionEngine) {}
-
// Sets up the helper functions called by composeSurfaces to use a mock
// implementations.
MOCK_CONST_METHOD0(getSkipColorTransform, bool());
@@ -603,6 +560,16 @@
MOCK_METHOD2(appendRegionFlashRequests,
void(const Region&, std::vector<renderengine::LayerSettings>&));
MOCK_METHOD1(setExpensiveRenderingExpected, void(bool));
+
+ // compositionengine::Output overrides
+ const OutputCompositionState& getState() const override { return mState; }
+ OutputCompositionState& editState() override { return mState; }
+
+ // These need implementations though are not expected to be called.
+ MOCK_CONST_METHOD1(dumpState, void(std::string&));
+ MOCK_CONST_METHOD0(getCompositionEngine, const CompositionEngine&());
+
+ impl::OutputCompositionState mState;
};
OutputComposeSurfacesTest() {
@@ -627,6 +594,7 @@
mOutput.editState().usesClientComposition = true;
mOutput.editState().usesDeviceComposition = false;
+ EXPECT_CALL(mOutput, getCompositionEngine()).WillRepeatedly(ReturnRef(mCompositionEngine));
EXPECT_CALL(mCompositionEngine, getRenderEngine()).WillRepeatedly(ReturnRef(mRenderEngine));
}
@@ -636,7 +604,7 @@
mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
mock::OutputLayer* mOutputLayer1 = new StrictMock<mock::OutputLayer>();
mock::OutputLayer* mOutputLayer2 = new StrictMock<mock::OutputLayer>();
- StrictMock<OutputPartialMock> mOutput{mCompositionEngine};
+ StrictMock<OutputPartialMock> mOutput;
sp<GraphicBuffer> mOutputBuffer = new GraphicBuffer();
};
@@ -691,14 +659,22 @@
struct GenerateClientCompositionRequestsTest : public testing::Test {
struct OutputPartialMock : public impl::Output {
- OutputPartialMock(const compositionengine::CompositionEngine& compositionEngine)
- : impl::Output(compositionEngine) {}
+ // compositionengine::Output overrides
std::vector<renderengine::LayerSettings> generateClientCompositionRequests(
bool supportsProtectedContent, Region& clearRegion) override {
return impl::Output::generateClientCompositionRequests(supportsProtectedContent,
clearRegion);
}
+
+ const OutputCompositionState& getState() const override { return mState; }
+ OutputCompositionState& editState() override { return mState; }
+
+ // These need implementations though are not expected to be called.
+ MOCK_CONST_METHOD1(dumpState, void(std::string&));
+ MOCK_CONST_METHOD0(getCompositionEngine, const CompositionEngine&());
+
+ impl::OutputCompositionState mState;
};
GenerateClientCompositionRequestsTest() {
@@ -707,10 +683,9 @@
mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
}
- StrictMock<mock::CompositionEngine> mCompositionEngine;
mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
- StrictMock<OutputPartialMock> mOutput{mCompositionEngine};
+ StrictMock<OutputPartialMock> mOutput;
};
// TODO(b/121291683): Add more unit test coverage for generateClientCompositionRequests