Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2e74a4c6 authored by Leon Scroggins III's avatar Leon Scroggins III
Browse files

SF: Add tests for hole punch 

Bug: 186144794
Test: This

Update "peekThroughLayer"'s type to be compositionengine::OutputLayer
(the abstract base class, rather than the implementation) so that a
mock::OutputLayer pointer registers as equal to itself. Likewise, use
the same type when storing a pointer to it in
Output::writeCompositionState. Finally, use the base type as the return
value from CachedSet::getHolePunchLayer. This has the effect of updating
calls in Flattener that look like

  auto* peekThroughLayer = cachedSet->getHolePunchLayer();

to use the base class type, too. It also matches other methods, like
LayerState::getOutputLayer.

Change-Id: I53fc851eca876d44ba7cb9347f1c62d659c38932
parent 5bab9825

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayerCompositionState.h

+1 −1
Original line number Diff line number Diff line
@@ -102,7 +102,7 @@ struct OutputLayerCompositionState { 
        // behind the OutputLayer represented by this CompositionState and will

        // be visible through it. Unowned - the OutputLayer's lifetime will

        // outlast this.)

        OutputLayer* peekThroughLayer = nullptr;

        compositionengine::OutputLayer* peekThroughLayer = nullptr;

    } overrideInfo;



    /*

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/planner/CachedSet.h

+1 −1
Original line number Diff line number Diff line
@@ -121,7 +121,7 @@ public: 
    void addHolePunchLayerIfFeasible(const CachedSet&, bool isFirstLayer);



    // Retrieve the layer that will be drawn behind this one.

    OutputLayer* getHolePunchLayer() const;

    compositionengine::OutputLayer* getHolePunchLayer() const;



private:

    CachedSet() = default;

services/surfaceflinger/CompositionEngine/src/Output.cpp

+1 −1
Original line number Diff line number Diff line
@@ -707,7 +707,7 @@ void Output::writeCompositionState(const compositionengine::CompositionRefreshAr 


    editState().earliestPresentTime = refreshArgs.earliestPresentTime;



    OutputLayer* peekThroughLayer = nullptr;

    compositionengine::OutputLayer* peekThroughLayer = nullptr;

    sp<GraphicBuffer> previousOverride = nullptr;

    bool includeGeometry = refreshArgs.updatingGeometryThisFrame;

    uint32_t z = 0;

services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp

+1 −1
Original line number Diff line number Diff line
@@ -304,7 +304,7 @@ void CachedSet::addHolePunchLayerIfFeasible(const CachedSet& holePunchLayer, boo 
    }

}



OutputLayer* CachedSet::getHolePunchLayer() const {

compositionengine::OutputLayer* CachedSet::getHolePunchLayer() const {

    return mHolePunchLayer ? mHolePunchLayer->getOutputLayer() : nullptr;

}

services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp

+60 −0
Original line number Diff line number Diff line
@@ -1056,13 +1056,73 @@ TEST_F(OutputLayerWriteStateToHWCTest, includesOverrideInfoIfPresent) { 
                              kOverrideSurfaceDamage);

    expectSetHdrMetadataAndBufferCalls(kOverrideBuffer->getBuffer(), kOverrideFence);

    expectSetCompositionTypeCall(Hwc2::IComposerClient::Composition::DEVICE);

    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillOnce(Return(false));



    mOutputLayer.writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, 0,

                                 /*zIsOverridden*/ false, /*isPeekingThrough*/ false);

}



TEST_F(OutputLayerWriteStateToHWCTest, peekThroughChangesBlendMode) {

    auto peekThroughLayerFE = sp<compositionengine::mock::LayerFE>::make();

    OutputLayer peekThroughLayer{mOutput, peekThroughLayerFE};



    mOutputLayer.mState.overrideInfo.peekThroughLayer = &peekThroughLayer;



    expectGeometryCommonCalls(kDisplayFrame, kSourceCrop, kBufferTransform,

                              Hwc2::IComposerClient::BlendMode::PREMULTIPLIED);

    expectPerFrameCommonCalls();

    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillOnce(Return(false));



    mOutputLayer.writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, 0,

                                 /*zIsOverridden*/ false, /*isPeekingThrough*/ false);

}



TEST_F(OutputLayerWriteStateToHWCTest, isPeekingThroughSetsOverride) {

    expectGeometryCommonCalls();

    expectPerFrameCommonCalls();



    mOutputLayer.writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, 0,

                                 /*zIsOverridden*/ false, /*isPeekingThrough*/ true);

    EXPECT_TRUE(mOutputLayer.getState().hwc->stateOverridden);

}



TEST_F(OutputLayerWriteStateToHWCTest, zIsOverriddenSetsOverride) {

    expectGeometryCommonCalls();

    expectPerFrameCommonCalls();

    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillOnce(Return(false));



    mOutputLayer.writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, 0,

                                 /*zIsOverridden*/ true, /*isPeekingThrough*/

                                 false);

    EXPECT_TRUE(mOutputLayer.getState().hwc->stateOverridden);

}



TEST_F(OutputLayerWriteStateToHWCTest, roundedCornersForceClientComposition) {

    expectGeometryCommonCalls();

    expectPerFrameCommonCalls();

    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillOnce(Return(true));

    expectSetCompositionTypeCall(Hwc2::IComposerClient::Composition::CLIENT);



    mOutputLayer.writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, 0,

                                 /*zIsOverridden*/ false, /*isPeekingThrough*/

                                 false);

}



TEST_F(OutputLayerWriteStateToHWCTest, roundedCornersPeekingThroughAllowsDeviceComposition) {

    expectGeometryCommonCalls();

    expectPerFrameCommonCalls();

    expectSetHdrMetadataAndBufferCalls();

    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(true));

    expectSetCompositionTypeCall(Hwc2::IComposerClient::Composition::DEVICE);



    mLayerFEState.compositionType = Hwc2::IComposerClient::Composition::DEVICE;

    mOutputLayer.writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, 0,

                                 /*zIsOverridden*/ false, /*isPeekingThrough*/

                                 true);

    EXPECT_EQ(Hwc2::IComposerClient::Composition::DEVICE,

              mOutputLayer.getState().hwc->hwcCompositionType);

}



/*

 * OutputLayer::writeCursorPositionToHWC()

 */