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

Commit 90768fc1 authored by Vishnu Nair's avatar Vishnu Nair Committed by Android (Google) Code Review
Browse files

Merge changes Ib260521d,I1363277c into main 

* changes:
  Migrate LayerTest to LayerSnapshotTests
  Remove legacy snapshot updates
parents 27bc2087 384ba8aa

services/surfaceflinger/SurfaceFlinger.cpp

+0 −635

File changed.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/SurfaceFlinger.h

+0 −32
Original line number Diff line number Diff line
@@ -313,7 +313,6 @@ public: 
    // Disables expensive rendering for all displays

    // This is scheduled on the main thread

    void disableExpensiveRendering();

    FloatRect getMaxDisplayBounds();



    // If set, composition engine tries to predict the composition strategy provided by HWC

    // based on the previous frame. If the strategy can be predicted, gpu composition will
@@ -764,16 +763,11 @@ private: 
                                            const scheduler::RefreshRateSelector&)

            REQUIRES(mStateLock, kMainThreadContext);



    void commitTransactionsLegacy() EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);

    void commitTransactions() REQUIRES(kMainThreadContext, mStateLock);

    void commitTransactionsLocked(uint32_t transactionFlags)

            REQUIRES(mStateLock, kMainThreadContext);

    void doCommitTransactions() REQUIRES(mStateLock);



    // Returns whether a new buffer has been latched.

    bool latchBuffers();



    void updateLayerGeometry();

    void updateLayerMetadataSnapshot();

    std::vector<std::pair<Layer*, LayerFE*>> moveSnapshotsToCompositionArgs(

            compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly)
@@ -782,13 +776,9 @@ private: 
                                          const std::vector<std::pair<Layer*, LayerFE*>>& layers)

            REQUIRES(kMainThreadContext);

    // Return true if we must composite this frame

    bool updateLayerSnapshotsLegacy(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,

                                    bool& out) REQUIRES(kMainThreadContext);

    // Return true if we must composite this frame

    bool updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,

                              bool& out) REQUIRES(kMainThreadContext);

    void updateLayerHistory(nsecs_t now) REQUIRES(kMainThreadContext);

    frontend::Update flushLifecycleUpdates() REQUIRES(kMainThreadContext);



    void updateInputFlinger(VsyncId vsyncId, TimePoint frameTime) REQUIRES(kMainThreadContext);

    void persistDisplayBrightness(bool needsComposite) REQUIRES(kMainThreadContext);
@@ -831,9 +821,6 @@ private: 
            const TransactionHandler::TransactionFlushState& flushState)

            REQUIRES(kMainThreadContext);



    uint32_t setClientStateLocked(const FrameTimelineInfo&, ResolvedComposerState&,

                                  int64_t desiredPresentTime, bool isAutoTimestamp,

                                  int64_t postTime, uint64_t transactionId) REQUIRES(mStateLock);

    uint32_t updateLayerCallbacksAndStats(const FrameTimelineInfo&, ResolvedComposerState&,

                                          int64_t desiredPresentTime, bool isAutoTimestamp,

                                          int64_t postTime, uint64_t transactionId)
@@ -883,9 +870,6 @@ private: 
                            const sp<Layer>& layer, const wp<Layer>& parentLayer,

                            uint32_t* outTransformHint);



    // Traverse through all the layers and compute and cache its bounds.

    void computeLayerBounds();



    // Creates a promise for a future release fence for a layer. This allows for

    // the layer to keep track of when its buffer can be released.

    void attachReleaseFenceFutureToLayer(Layer* layer, LayerFE* layerFE, ui::LayerStack layerStack);
@@ -1301,8 +1285,6 @@ private: 
    std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithBuffersRemoved;

    std::unordered_set<uint32_t> mLayersIdsWithQueuedFrames;



    // Tracks layers that need to update a display's dirty region.

    std::vector<sp<Layer>> mLayersPendingRefresh;

    // Sorted list of layers that were composed during previous frame. This is used to

    // avoid an expensive traversal of the layer hierarchy when there are no

    // visible region changes. Because this is a list of strong pointers, this will
@@ -1447,22 +1429,8 @@ private: 
    // A temporay pool that store the created layers and will be added to current state in main

    // thread.

    std::vector<LayerCreatedState> mCreatedLayers GUARDED_BY(mCreatedLayersLock);

    bool commitCreatedLayers(VsyncId, std::vector<LayerCreatedState>& createdLayers);

    void handleLayerCreatedLocked(const LayerCreatedState&, VsyncId) REQUIRES(mStateLock);



    mutable std::mutex mMirrorDisplayLock;

    struct MirrorDisplayState {

        MirrorDisplayState(ui::LayerStack layerStack, sp<IBinder>& rootHandle,

                           const sp<Client>& client)

              : layerStack(layerStack), rootHandle(rootHandle), client(client) {}



        ui::LayerStack layerStack;

        sp<IBinder> rootHandle;

        const sp<Client> client;

    };

    std::vector<MirrorDisplayState> mMirrorDisplays GUARDED_BY(mMirrorDisplayLock);

    bool commitMirrorDisplays(VsyncId);



    std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;



    // Must only be accessed on the main thread.

services/surfaceflinger/tests/unittests/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -94,7 +94,6 @@ cc_test { 
        "LayerHierarchyTest.cpp",

        "LayerLifecycleManagerTest.cpp",

        "LayerSnapshotTest.cpp",

        "LayerTest.cpp",

        "LayerTestUtils.cpp",

        "MessageQueueTest.cpp",

        "PowerAdvisorTest.cpp",

services/surfaceflinger/tests/unittests/LayerSnapshotTest.cpp

+44 −0
Original line number Diff line number Diff line
@@ -1539,4 +1539,48 @@ TEST_F(LayerSnapshotTest, doNotOverrideParentTrustedOverlayState) { 
            gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));

}



static constexpr const FloatRect LARGE_FLOAT_RECT{std::numeric_limits<float>::min(),

                                                  std::numeric_limits<float>::min(),

                                                  std::numeric_limits<float>::max(),

                                                  std::numeric_limits<float>::max()};

TEST_F(LayerSnapshotTest, layerVisibleByDefault) {

    DisplayInfo info;

    info.info.logicalHeight = 1000000;

    info.info.logicalWidth = 1000000;

    mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);

    UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);

    EXPECT_FALSE(getSnapshot(1)->isHiddenByPolicy());

}



TEST_F(LayerSnapshotTest, hideLayerWithZeroMatrix) {

    DisplayInfo info;

    info.info.logicalHeight = 1000000;

    info.info.logicalWidth = 1000000;

    mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);

    setMatrix(1, 0.f, 0.f, 0.f, 0.f);

    UPDATE_AND_VERIFY(mSnapshotBuilder, {2});

    EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());

}



TEST_F(LayerSnapshotTest, hideLayerWithInfMatrix) {

    DisplayInfo info;

    info.info.logicalHeight = 1000000;

    info.info.logicalWidth = 1000000;

    mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);

    setMatrix(1, std::numeric_limits<float>::infinity(), 0.f, 0.f,

              std::numeric_limits<float>::infinity());

    UPDATE_AND_VERIFY(mSnapshotBuilder, {2});

    EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());

}



TEST_F(LayerSnapshotTest, hideLayerWithNanMatrix) {

    DisplayInfo info;

    info.info.logicalHeight = 1000000;

    info.info.logicalWidth = 1000000;

    mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);

    setMatrix(1, std::numeric_limits<float>::quiet_NaN(), 0.f, 0.f,

              std::numeric_limits<float>::quiet_NaN());

    UPDATE_AND_VERIFY(mSnapshotBuilder, {2});

    EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());

}

} // namespace android::surfaceflinger::frontend

services/surfaceflinger/tests/unittests/LayerTest.cpp

deleted100644 → 0
+0 −86
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#undef LOG_TAG

#define LOG_TAG "LibSurfaceFlingerUnittests"



#include <gtest/gtest.h>

#include <ui/FloatRect.h>

#include <ui/Transform.h>

#include <limits>



#include "LayerTestUtils.h"

#include "TestableSurfaceFlinger.h"



namespace android {

namespace {



class LayerTest : public BaseLayerTest {

protected:

    static constexpr const float MIN_FLOAT = std::numeric_limits<float>::min();

    static constexpr const float MAX_FLOAT = std::numeric_limits<float>::max();

    static constexpr const FloatRect LARGE_FLOAT_RECT{MIN_FLOAT, MIN_FLOAT, MAX_FLOAT, MAX_FLOAT};

};



INSTANTIATE_TEST_SUITE_P(PerLayerType, LayerTest,

                         testing::Values(std::make_shared<BufferStateLayerFactory>(),

                                         std::make_shared<EffectLayerFactory>()),

                         PrintToStringParamName);



TEST_P(LayerTest, layerVisibleByDefault) {

    sp<Layer> layer = GetParam()->createLayer(mFlinger);

    layer->updateGeometry();

    layer->computeBounds(LARGE_FLOAT_RECT, ui::Transform(), 0.f);

    ASSERT_FALSE(layer->isHiddenByPolicy());

}



TEST_P(LayerTest, hideLayerWithZeroMatrix) {

    sp<Layer> layer = GetParam()->createLayer(mFlinger);



    layer_state_t::matrix22_t matrix{0, 0, 0, 0};

    layer->setMatrix(matrix);

    layer->updateGeometry();

    layer->computeBounds(LARGE_FLOAT_RECT, ui::Transform(), 0.f);



    ASSERT_TRUE(layer->isHiddenByPolicy());

}



TEST_P(LayerTest, hideLayerWithInfMatrix) {

    sp<Layer> layer = GetParam()->createLayer(mFlinger);



    constexpr const float INF = std::numeric_limits<float>::infinity();

    layer_state_t::matrix22_t matrix{INF, 0, 0, INF};

    layer->setMatrix(matrix);

    layer->updateGeometry();

    layer->computeBounds(LARGE_FLOAT_RECT, ui::Transform(), 0.f);



    ASSERT_TRUE(layer->isHiddenByPolicy());

}



TEST_P(LayerTest, hideLayerWithNanMatrix) {

    sp<Layer> layer = GetParam()->createLayer(mFlinger);



    constexpr const float QUIET_NAN = std::numeric_limits<float>::quiet_NaN();

    layer_state_t::matrix22_t matrix{QUIET_NAN, 0, 0, QUIET_NAN};

    layer->setMatrix(matrix);

    layer->updateGeometry();

    layer->computeBounds(LARGE_FLOAT_RECT, ui::Transform(), 0.f);



    ASSERT_TRUE(layer->isHiddenByPolicy());

}



} // namespace

} // namespace android