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

Commit ddfe5cd9 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 8599125 from 4ff178c5 to tm-qpr1-release 

Change-Id: Ib82fa46008eecb3427d2df11c9905aa1792440dd
parents 922282ab 4ff178c5

services/inputflinger/TEST_MAPPING

+17 −0
Original line number Diff line number Diff line
@@ -23,6 +23,14 @@ 
    {

      "name": "libinputservice_test"

    },

    {

      "name": "CtsHardwareTestCases",

      "options": [

        {

          "include-filter": "android.hardware.input.cts.tests"

        }

      ]

    },

    {

      "name": "CtsInputTestCases"

    },
@@ -31,6 +39,7 @@ 
      "options": [

        {

          "include-filter": "android.view.cts.MotionEventTest",

          "include-filter": "android.view.cts.PointerCaptureTest",

          "include-filter": "android.view.cts.VerifyInputEventTest"

        }

      ]
@@ -44,6 +53,14 @@ 
        }

      ]

    },

    {

      "name": "FrameworksServicesTests",

      "options": [

        {

          "include-filter": "com.android.server.input"

        }

      ]

    },

    {

      "name": "CtsSecurityTestCases",

      "options": [

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

+3 −0
Original line number Diff line number Diff line
@@ -164,6 +164,9 @@ struct OutputCompositionState { 


    bool treat170mAsSrgb = false;



    uint64_t lastOutputLayerHash = 0;

    uint64_t outputLayerHash = 0;



    // Debugging

    void dump(std::string& result) const;

};

services/surfaceflinger/CompositionEngine/src/Output.cpp

+22 −6
Original line number Diff line number Diff line
@@ -763,6 +763,7 @@ void Output::writeCompositionState(const compositionengine::CompositionRefreshAr 
    bool includeGeometry = refreshArgs.updatingGeometryThisFrame;

    uint32_t z = 0;

    bool overrideZ = false;

    uint64_t outputLayerHash = 0;

    for (auto* layer : getOutputLayersOrderedByZ()) {

        if (layer == peekThroughLayer) {

            // No longer needed, although it should not show up again, so
@@ -789,6 +790,10 @@ void Output::writeCompositionState(const compositionengine::CompositionRefreshAr 
                    constexpr bool isPeekingThrough = true;

                    peekThroughLayer->writeStateToHWC(includeGeometry, false, z++, overrideZ,

                                                      isPeekingThrough);

                    outputLayerHash ^= android::hashCombine(

                            reinterpret_cast<uint64_t>(&peekThroughLayer->getLayerFE()),

                            z, includeGeometry, overrideZ, isPeekingThrough,

                            peekThroughLayer->requiresClientComposition());

                }



                previousOverride = overrideInfo.buffer->getBuffer();
@@ -797,8 +802,15 @@ void Output::writeCompositionState(const compositionengine::CompositionRefreshAr 


        constexpr bool isPeekingThrough = false;

        layer->writeStateToHWC(includeGeometry, skipLayer, z++, overrideZ, isPeekingThrough);

        if (!skipLayer) {

            outputLayerHash ^= android::hashCombine(

                    reinterpret_cast<uint64_t>(&layer->getLayerFE()),

                    z, includeGeometry, overrideZ, isPeekingThrough,

                    layer->requiresClientComposition());

        }

    }

    editState().outputLayerHash = outputLayerHash;

}



compositionengine::OutputLayer* Output::findLayerRequestingBackgroundComposition() const {

    compositionengine::OutputLayer* layerRequestingBgComposition = nullptr;
@@ -1505,6 +1517,10 @@ void Output::setTreat170mAsSrgb(bool enable) { 
}



bool Output::canPredictCompositionStrategy(const CompositionRefreshArgs& refreshArgs) {

    uint64_t lastOutputLayerHash = getState().lastOutputLayerHash;

    uint64_t outputLayerHash = getState().outputLayerHash;

    editState().lastOutputLayerHash = outputLayerHash;



    if (!getState().isEnabled || !mHwComposerAsyncWorker) {

        ALOGV("canPredictCompositionStrategy disabled");

        return false;
@@ -1525,6 +1541,11 @@ bool Output::canPredictCompositionStrategy(const CompositionRefreshArgs& refresh 
        return false;

    }



    if (lastOutputLayerHash != outputLayerHash) {

        ALOGV("canPredictCompositionStrategy output layers changed");

        return false;

    }



    // If no layer uses clientComposition, then don't predict composition strategy

    // because we have less work to do in parallel.

    if (!anyLayersRequireClientComposition()) {
@@ -1532,14 +1553,9 @@ bool Output::canPredictCompositionStrategy(const CompositionRefreshArgs& refresh 
        return false;

    }



    if (!refreshArgs.updatingOutputGeometryThisFrame) {

    return true;

}



    ALOGV("canPredictCompositionStrategy updatingOutputGeometryThisFrame");

    return false;

}



bool Output::anyLayersRequireClientComposition() const {

    const auto layers = getOutputLayersOrderedByZ();

    return std::any_of(layers.begin(), layers.end(),

services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp

+45 −0
Original line number Diff line number Diff line
@@ -850,14 +850,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, updatesLayerContentForAllLayers 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_180));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_180));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    injectOutputLayer(layer1);

    injectOutputLayer(layer2);
@@ -884,14 +890,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, updatesLayerGeometryAndContentF 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    injectOutputLayer(layer1);

    injectOutputLayer(layer2);
@@ -917,14 +929,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, forcesClientCompositionForAllLa 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    injectOutputLayer(layer1);

    injectOutputLayer(layer2);
@@ -950,6 +968,8 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, peekThroughLayerChangesOrder) { 
    InSequence seq;

    EXPECT_CALL(*layer0.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer1.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

        EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

                .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
@@ -957,6 +977,9 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, peekThroughLayerChangesOrder) { 
    EXPECT_CALL(*layer0.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer0.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));





    // After calling planComposition (which clears overrideInfo), this test sets

    // layer3 to be the peekThroughLayer for layer1 and layer2. As a result, it
@@ -966,12 +989,18 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, peekThroughLayerChangesOrder) { 
                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

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

                                true));

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ true, z++,

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

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    injectOutputLayer(layer0);

    injectOutputLayer(layer1);
@@ -4801,10 +4830,14 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, noBackgroundBlurWhenOpaque) { 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    layer2.layerFEState.backgroundBlurRadius = 10;

    layer2.layerFEState.isOpaque = true;
@@ -4833,14 +4866,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, handlesBackgroundBlurRequests) 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    layer2.layerFEState.backgroundBlurRadius = 10;

    layer2.layerFEState.isOpaque = false;
@@ -4870,14 +4909,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, handlesBlurRegionRequests) { 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

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

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    BlurRegion region;

    layer2.layerFEState.blurRegions.push_back(region);

services/surfaceflinger/Scheduler/Scheduler.cpp

+5 −4
Original line number Diff line number Diff line
@@ -167,18 +167,19 @@ impl::EventThread::ThrottleVsyncCallback Scheduler::makeThrottleVsyncCallback() 
impl::EventThread::GetVsyncPeriodFunction Scheduler::makeGetVsyncPeriodFunction() const {

    return [this](uid_t uid) {

        const Fps refreshRate = holdRefreshRateConfigs()->getActiveMode()->getFps();

        const nsecs_t basePeriod = refreshRate.getPeriodNsecs();

        const auto currentPeriod =

                mVsyncSchedule->getTracker().currentPeriod() ?: refreshRate.getPeriodNsecs();



        const auto frameRate = getFrameRateOverride(uid);

        if (!frameRate.has_value()) {

            return basePeriod;

            return currentPeriod;

        }



        const auto divisor = RefreshRateConfigs::getFrameRateDivisor(refreshRate, *frameRate);

        if (divisor <= 1) {

            return basePeriod;

            return currentPeriod;

        }

        return basePeriod * divisor;

        return currentPeriod * divisor;

    };

}