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

Commit 147626ab authored by Gil Dekel's avatar Gil Dekel
Browse files

SF: Remove *DisplayId::tryCast and DisplayId::isVirtual() 

Work towards DisplayId opaqueness by eliminating call-sites to APIs that
parse the display ID values directly.

This CL removes *DisplayId::tryCast from the DislayId interface entirely
and replaces it with SF APIs that check for the existence of the
displays before casting. This removes direct dependency on ID value
bits. It also removes DisplayId::isVirtual().

Flag: com.android.graphics.surfaceflinger.flags.stable_edid_ids
Bug: 390690584
Bug: 390689313
Test: libsurfaceflinger_unittest
Change-Id: I918a6b361784e41165837234b82eed027dc46673
parent de4ce29c

libs/ui/include/ui/DisplayId.h

+12 −37
Original line number Diff line number Diff line
@@ -37,7 +37,6 @@ struct DisplayId { 
    DisplayId& operator=(const DisplayId&) = default;



    static constexpr DisplayId fromValue(uint64_t value) { return DisplayId(value); }

    constexpr bool isVirtual() const { return value & FLAG_VIRTUAL; }



    uint64_t value;
@@ -67,13 +66,6 @@ struct PhysicalDisplayId : DisplayId { 
    // TODO: b/162612135 - Remove default constructor.

    PhysicalDisplayId() = default;



    static constexpr ftl::Optional<PhysicalDisplayId> tryCast(DisplayId id) {

        if (id.isVirtual()) {

            return std::nullopt;

        }

        return PhysicalDisplayId(id);

    }



    // Returns a stable ID based on EDID and port information.

    static constexpr PhysicalDisplayId fromEdid(uint8_t port, uint16_t manufacturerId,

                                                uint32_t modelHash) {
@@ -113,13 +105,6 @@ struct VirtualDisplayId : DisplayId { 
    // Flag indicating that this virtual display is backed by the GPU.

    static constexpr uint64_t FLAG_GPU = 1ULL << 61;



    static constexpr std::optional<VirtualDisplayId> tryCast(DisplayId id) {

        if (id.isVirtual()) {

            return VirtualDisplayId(id);

        }

        return std::nullopt;

    }



    static constexpr VirtualDisplayId fromValue(uint64_t value) {

        return VirtualDisplayId(SkipVirtualFlag{}, value);

    }
@@ -135,13 +120,6 @@ protected: 
struct HalVirtualDisplayId : VirtualDisplayId {

    explicit constexpr HalVirtualDisplayId(BaseId baseId) : VirtualDisplayId(baseId) {}



    static constexpr std::optional<HalVirtualDisplayId> tryCast(DisplayId id) {

        if (id.isVirtual() && !(id.value & FLAG_GPU)) {

            return HalVirtualDisplayId(id);

        }

        return std::nullopt;

    }



    static constexpr HalVirtualDisplayId fromValue(uint64_t value) {

        return HalVirtualDisplayId(SkipVirtualFlag{}, value);

    }
@@ -153,13 +131,6 @@ private: 
struct GpuVirtualDisplayId : VirtualDisplayId {

    explicit constexpr GpuVirtualDisplayId(BaseId baseId) : VirtualDisplayId(FLAG_GPU | baseId) {}



    static constexpr std::optional<GpuVirtualDisplayId> tryCast(DisplayId id) {

        if (id.isVirtual() && (id.value & FLAG_GPU)) {

            return GpuVirtualDisplayId(id);

        }

        return std::nullopt;

    }



    static constexpr GpuVirtualDisplayId fromValue(uint64_t value) {

        return GpuVirtualDisplayId(SkipVirtualFlag{}, value);

    }
@@ -173,14 +144,6 @@ private: 
struct HalDisplayId : DisplayId {

    constexpr HalDisplayId(HalVirtualDisplayId other) : DisplayId(other) {}

    constexpr HalDisplayId(PhysicalDisplayId other) : DisplayId(other) {}



    static constexpr std::optional<HalDisplayId> tryCast(DisplayId id) {

        if (GpuVirtualDisplayId::tryCast(id)) {

            return std::nullopt;

        }

        return HalDisplayId(id);

    }



    static constexpr HalDisplayId fromValue(uint64_t value) { return HalDisplayId(value); }



private:
@@ -213,6 +176,18 @@ inline auto asPhysicalDisplayId(DisplayIdVariant variant) -> ftl::Optional<Physi 
    return asDisplayIdOfType<PhysicalDisplayId>(variant);

}



inline auto asVirtualDisplayId(DisplayIdVariant variant) -> ftl::Optional<VirtualDisplayId> {

    return ftl::match(

            variant,

            [](GpuVirtualDisplayId id) -> ftl::Optional<VirtualDisplayId> {

                return ftl::Optional(static_cast<VirtualDisplayId>(id));

            },

            [](HalVirtualDisplayId id) -> ftl::Optional<VirtualDisplayId> {

                return ftl::Optional(static_cast<VirtualDisplayId>(id));

            },

            [](auto) -> ftl::Optional<VirtualDisplayId> { return std::nullopt; });

}



inline auto asDisplayId(DisplayIdVariant variant) -> DisplayId {

    return ftl::match(variant, [](auto id) -> DisplayId { return static_cast<DisplayId>(id); });

}

libs/ui/tests/Android.bp

+0 −10
Original line number Diff line number Diff line
@@ -44,16 +44,6 @@ cc_test { 
    ],

}



cc_test {

    name: "DisplayId_test",

    shared_libs: ["libui"],

    srcs: ["DisplayId_test.cpp"],

    cflags: [

        "-Wall",

        "-Werror",

    ],

}



cc_test {

    name: "DisplayIdentification_test",

    shared_libs: ["libui"],

libs/ui/tests/DisplayId_test.cpp

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

 * Copyright 2020 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.

 */



#include <ui/DisplayId.h>



#include <gtest/gtest.h>



namespace android::ui {



TEST(DisplayIdTest, createPhysicalIdFromEdid) {

    constexpr uint8_t port = 1;

    constexpr uint16_t manufacturerId = 13;

    constexpr uint32_t modelHash = 42;

    const PhysicalDisplayId id = PhysicalDisplayId::fromEdid(port, manufacturerId, modelHash);

    EXPECT_EQ(port, id.getPort());

    EXPECT_FALSE(VirtualDisplayId::tryCast(id));

    EXPECT_FALSE(HalVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(GpuVirtualDisplayId::tryCast(id));

    EXPECT_TRUE(PhysicalDisplayId::tryCast(id));

    EXPECT_TRUE(HalDisplayId::tryCast(id));



    EXPECT_EQ(id, DisplayId::fromValue(id.value));

    EXPECT_EQ(id, PhysicalDisplayId::fromValue(id.value));

}



TEST(DisplayIdTest, createPhysicalIdFromPort) {

    constexpr uint8_t port = 3;

    const PhysicalDisplayId id = PhysicalDisplayId::fromPort(port);

    EXPECT_EQ(port, id.getPort());

    EXPECT_FALSE(VirtualDisplayId::tryCast(id));

    EXPECT_FALSE(HalVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(GpuVirtualDisplayId::tryCast(id));

    EXPECT_TRUE(PhysicalDisplayId::tryCast(id));

    EXPECT_TRUE(HalDisplayId::tryCast(id));



    EXPECT_EQ(id, DisplayId::fromValue(id.value));

    EXPECT_EQ(id, PhysicalDisplayId::fromValue(id.value));

}



TEST(DisplayIdTest, createGpuVirtualId) {

    const GpuVirtualDisplayId id(42);

    EXPECT_TRUE(VirtualDisplayId::tryCast(id));

    EXPECT_TRUE(GpuVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(HalVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(PhysicalDisplayId::tryCast(id));

    EXPECT_FALSE(HalDisplayId::tryCast(id));



    EXPECT_EQ(id, DisplayId::fromValue(id.value));

    EXPECT_EQ(id, GpuVirtualDisplayId::fromValue(id.value));

}



TEST(DisplayIdTest, createVirtualIdFromGpuVirtualId) {

    const VirtualDisplayId id(GpuVirtualDisplayId(42));

    EXPECT_TRUE(VirtualDisplayId::tryCast(id));

    EXPECT_TRUE(GpuVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(HalVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(PhysicalDisplayId::tryCast(id));

    EXPECT_FALSE(HalDisplayId::tryCast(id));



    const bool isGpuVirtualId = (id.value & VirtualDisplayId::FLAG_GPU);

    EXPECT_EQ((id.isVirtual() && isGpuVirtualId), GpuVirtualDisplayId::tryCast(id).has_value());

}



TEST(DisplayIdTest, createHalVirtualId) {

    const HalVirtualDisplayId id(42);

    EXPECT_TRUE(VirtualDisplayId::tryCast(id));

    EXPECT_TRUE(HalVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(GpuVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(PhysicalDisplayId::tryCast(id));

    EXPECT_TRUE(HalDisplayId::tryCast(id));



    EXPECT_EQ(id, DisplayId::fromValue(id.value));

    EXPECT_EQ(id, HalVirtualDisplayId::fromValue(id.value));

}



TEST(DisplayIdTest, createVirtualIdFromHalVirtualId) {

    const VirtualDisplayId id(HalVirtualDisplayId(42));

    EXPECT_TRUE(VirtualDisplayId::tryCast(id));

    EXPECT_TRUE(HalVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(GpuVirtualDisplayId::tryCast(id));

    EXPECT_FALSE(PhysicalDisplayId::tryCast(id));

    EXPECT_TRUE(HalDisplayId::tryCast(id));



    const bool isGpuVirtualId = (id.value & VirtualDisplayId::FLAG_GPU);

    EXPECT_EQ((id.isVirtual() && !isGpuVirtualId), HalVirtualDisplayId::tryCast(id).has_value());

}



} // namespace android::ui

services/surfaceflinger/DisplayDevice.cpp

+4 −1
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ 


#include <common/trace.h>

#include <compositionengine/CompositionEngine.h>

#include <compositionengine/Display.h>

#include <compositionengine/DisplayColorProfile.h>

#include <compositionengine/DisplayColorProfileCreationArgs.h>

#include <compositionengine/DisplayCreationArgs.h>
@@ -308,6 +307,10 @@ DisplayId DisplayDevice::getId() const { 
    return mCompositionDisplay->getId();

}



bool DisplayDevice::isVirtual() const {

    return mCompositionDisplay->isVirtual();

}



bool DisplayDevice::isSecure() const {

    return mCompositionDisplay->isSecure();

}

services/surfaceflinger/DisplayDevice.h

+14 −7
Original line number Diff line number Diff line
@@ -82,7 +82,7 @@ public: 
        return mCompositionDisplay;

    }



    bool isVirtual() const { return getId().isVirtual(); }

    bool isVirtual() const;

    bool isPrimary() const { return mIsPrimary; }



    // isSecure indicates whether this display can be trusted to display
@@ -126,17 +126,24 @@ public: 
        return *idVariant;

    }



    std::optional<VirtualDisplayIdVariant> getVirtualDisplayIdVariant() const {

        return ftl::match(

                getDisplayIdVariant(),

                [](PhysicalDisplayId) { return std::optional<VirtualDisplayIdVariant>(); },

                [](auto id) { return std::optional<VirtualDisplayIdVariant>(id); });

    }



    // Shorthand to upcast the ID of a display whose type is known as a precondition.

    PhysicalDisplayId getPhysicalId() const {

        const auto id = PhysicalDisplayId::tryCast(getId());

        LOG_FATAL_IF(!id);

        return *id;

        const auto physicalDisplayId = asPhysicalDisplayId(getDisplayIdVariant());

        LOG_FATAL_IF(!physicalDisplayId);

        return *physicalDisplayId;

    }



    VirtualDisplayId getVirtualId() const {

        const auto id = VirtualDisplayId::tryCast(getId());

        LOG_FATAL_IF(!id);

        return *id;

        const auto virtualDisplayId = asVirtualDisplayId(getDisplayIdVariant());

        LOG_FATAL_IF(!virtualDisplayId);

        return *virtualDisplayId;

    }



    const wp<IBinder>& getDisplayToken() const { return mDisplayToken; }