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

Commit 8b20c5c8 authored by Chia-I Wu's avatar Chia-I Wu
Browse files

graphics: clang-format composer VTS 

Test: make VtsHalGraphicsComposerV2_1TargetTest
Change-Id: I8df7090dd3cebbf36257f3df76f0e8aced0c60bd
parent 5ff97474

graphics/composer/2.1/utils/vts/GraphicsComposerCallback.cpp

+32 −33
Original line number Diff line number Diff line
@@ -48,8 +48,7 @@ int GraphicsComposerCallback::getInvalidVsyncCount() const { 
    return mInvalidVsyncCount;

}



Return<void> GraphicsComposerCallback::onHotplug(Display display,

                                                 Connection connection) {

Return<void> GraphicsComposerCallback::onHotplug(Display display, Connection connection) {

    std::lock_guard<std::mutex> lock(mMutex);



    if (connection == Connection::CONNECTED) {

graphics/composer/2.1/utils/vts/VtsHalGraphicsComposerTestUtils.cpp

+168 −189
Original line number Diff line number Diff line
@@ -42,7 +42,9 @@ void Composer::init() { 
    mCapabilities.insert(capabilities.begin(), capabilities.end());

}



sp<IComposer> Composer::getRaw() const { return mComposer; }

sp<IComposer> Composer::getRaw() const {

    return mComposer;

}



bool Composer::hasCapability(IComposer::Capability capability) const {

    return mCapabilities.count(capability) > 0;
@@ -58,8 +60,7 @@ std::vector<IComposer::Capability> Composer::getCapabilities() { 


std::string Composer::dumpDebugInfo() {

    std::string debugInfo;

  mComposer->dumpDebugInfo(

      [&](const auto& tmpDebugInfo) { debugInfo = tmpDebugInfo.c_str(); });

    mComposer->dumpDebugInfo([&](const auto& tmpDebugInfo) { debugInfo = tmpDebugInfo.c_str(); });



    return debugInfo;

}
@@ -74,8 +75,7 @@ std::unique_ptr<ComposerClient> Composer::createClient() { 
    return client;

}



ComposerClient::ComposerClient(const sp<IComposerClient>& client)

    : mClient(client) {}

ComposerClient::ComposerClient(const sp<IComposerClient>& client) : mClient(client) {}



ComposerClient::~ComposerClient() {

    for (auto it : mDisplayResources) {
@@ -95,7 +95,9 @@ ComposerClient::~ComposerClient() { 
    mDisplayResources.clear();

}



sp<IComposerClient> ComposerClient::getRaw() const { return mClient; }

sp<IComposerClient> ComposerClient::getRaw() const {

    return mClient;

}



void ComposerClient::registerCallback(const sp<IComposerCallback>& callback) {

    mClient->registerCallback(callback);
@@ -106,8 +108,7 @@ uint32_t ComposerClient::getMaxVirtualDisplayCount() { 
}



Display ComposerClient::createVirtualDisplay(uint32_t width, uint32_t height,

                                             PixelFormat formatHint,

                                             uint32_t outputBufferSlotCount,

                                             PixelFormat formatHint, uint32_t outputBufferSlotCount,

                                             PixelFormat* outFormat) {

    Display display = 0;

    mClient->createVirtualDisplay(
@@ -117,8 +118,7 @@ Display ComposerClient::createVirtualDisplay(uint32_t width, uint32_t height, 
            display = tmpDisplay;

            *outFormat = tmpFormat;



        ASSERT_TRUE(

            mDisplayResources.insert({display, DisplayResource(true)}).second)

            ASSERT_TRUE(mDisplayResources.insert({display, DisplayResource(true)}).second)

                << "duplicated virtual display id " << display;

        });
@@ -127,24 +127,20 @@ Display ComposerClient::createVirtualDisplay(uint32_t width, uint32_t height, 


void ComposerClient::destroyVirtualDisplay(Display display) {

    Error error = mClient->destroyVirtualDisplay(display);

  ASSERT_EQ(Error::NONE, error)

      << "failed to destroy virtual display " << display;

    ASSERT_EQ(Error::NONE, error) << "failed to destroy virtual display " << display;



    mDisplayResources.erase(display);

}



Layer ComposerClient::createLayer(Display display, uint32_t bufferSlotCount) {

    Layer layer = 0;

  mClient->createLayer(

      display, bufferSlotCount,

      [&](const auto& tmpError, const auto& tmpLayer) {

    mClient->createLayer(display, bufferSlotCount, [&](const auto& tmpError, const auto& tmpLayer) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to create layer";

        layer = tmpLayer;



        auto resourceIt = mDisplayResources.find(display);

        if (resourceIt == mDisplayResources.end()) {

          resourceIt =

              mDisplayResources.insert({display, DisplayResource(false)}).first;

            resourceIt = mDisplayResources.insert({display, DisplayResource(false)}).first;

        }



        ASSERT_TRUE(resourceIt->second.layers.insert(layer).second)
@@ -165,8 +161,7 @@ void ComposerClient::destroyLayer(Display display, Layer layer) { 


Config ComposerClient::getActiveConfig(Display display) {

    Config config = 0;

  mClient->getActiveConfig(

      display, [&](const auto& tmpError, const auto& tmpConfig) {

    mClient->getActiveConfig(display, [&](const auto& tmpError, const auto& tmpConfig) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to get active config";

        config = tmpConfig;

    });
@@ -174,18 +169,15 @@ Config ComposerClient::getActiveConfig(Display display) { 
    return config;

}



bool ComposerClient::getClientTargetSupport(Display display, uint32_t width,

                                            uint32_t height, PixelFormat format,

                                            Dataspace dataspace) {

  Error error = mClient->getClientTargetSupport(display, width, height, format,

                                                dataspace);

bool ComposerClient::getClientTargetSupport(Display display, uint32_t width, uint32_t height,

                                            PixelFormat format, Dataspace dataspace) {

    Error error = mClient->getClientTargetSupport(display, width, height, format, dataspace);

    return error == Error::NONE;

}



std::vector<ColorMode> ComposerClient::getColorModes(Display display) {

    std::vector<ColorMode> modes;

  mClient->getColorModes(

      display, [&](const auto& tmpError, const auto& tmpMode) {

    mClient->getColorModes(display, [&](const auto& tmpError, const auto& tmpMode) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to get color mode";

        modes = tmpMode;

    });
@@ -193,13 +185,12 @@ std::vector<ColorMode> ComposerClient::getColorModes(Display display) { 
    return modes;

}



int32_t ComposerClient::getDisplayAttribute(

    Display display, Config config, IComposerClient::Attribute attribute) {

int32_t ComposerClient::getDisplayAttribute(Display display, Config config,

                                            IComposerClient::Attribute attribute) {

    int32_t value = 0;

  mClient->getDisplayAttribute(display, config, attribute,

                               [&](const auto& tmpError, const auto& tmpValue) {

                                 ASSERT_EQ(Error::NONE, tmpError)

                                     << "failed to get display attribute";

    mClient->getDisplayAttribute(

        display, config, attribute, [&](const auto& tmpError, const auto& tmpValue) {

            ASSERT_EQ(Error::NONE, tmpError) << "failed to get display attribute";

            value = tmpValue;

        });
@@ -208,8 +199,7 @@ int32_t ComposerClient::getDisplayAttribute( 


std::vector<Config> ComposerClient::getDisplayConfigs(Display display) {

    std::vector<Config> configs;

  mClient->getDisplayConfigs(

      display, [&](const auto& tmpError, const auto& tmpConfigs) {

    mClient->getDisplayConfigs(display, [&](const auto& tmpError, const auto& tmpConfigs) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to get display configs";

        configs = tmpConfigs;

    });
@@ -219,8 +209,7 @@ std::vector<Config> ComposerClient::getDisplayConfigs(Display display) { 


std::string ComposerClient::getDisplayName(Display display) {

    std::string name;

  mClient->getDisplayName(

      display, [&](const auto& tmpError, const auto& tmpName) {

    mClient->getDisplayName(display, [&](const auto& tmpError, const auto& tmpName) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to get display name";

        name = tmpName.c_str();

    });
@@ -230,8 +219,7 @@ std::string ComposerClient::getDisplayName(Display display) { 


IComposerClient::DisplayType ComposerClient::getDisplayType(Display display) {

    IComposerClient::DisplayType type = IComposerClient::DisplayType::INVALID;

  mClient->getDisplayType(

      display, [&](const auto& tmpError, const auto& tmpType) {

    mClient->getDisplayType(display, [&](const auto& tmpError, const auto& tmpType) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to get display type";

        type = tmpType;

    });
@@ -241,8 +229,7 @@ IComposerClient::DisplayType ComposerClient::getDisplayType(Display display) { 


bool ComposerClient::getDozeSupport(Display display) {

    bool support = false;

  mClient->getDozeSupport(

      display, [&](const auto& tmpError, const auto& tmpSupport) {

    mClient->getDozeSupport(display, [&](const auto& tmpError, const auto& tmpSupport) {

        ASSERT_EQ(Error::NONE, tmpError) << "failed to get doze support";

        support = tmpSupport;

    });
@@ -250,15 +237,13 @@ bool ComposerClient::getDozeSupport(Display display) { 
    return support;

}



std::vector<Hdr> ComposerClient::getHdrCapabilities(

    Display display, float* outMaxLuminance, float* outMaxAverageLuminance,

std::vector<Hdr> ComposerClient::getHdrCapabilities(Display display, float* outMaxLuminance,

                                                    float* outMaxAverageLuminance,

                                                    float* outMinLuminance) {

    std::vector<Hdr> types;

    mClient->getHdrCapabilities(

      display,

      [&](const auto& tmpError, const auto& tmpTypes,

          const auto& tmpMaxLuminance, const auto& tmpMaxAverageLuminance,

          const auto& tmpMinLuminance) {

        display, [&](const auto& tmpError, const auto& tmpTypes, const auto& tmpMaxLuminance,

                     const auto& tmpMaxAverageLuminance, const auto& tmpMinLuminance) {

            ASSERT_EQ(Error::NONE, tmpError) << "failed to get HDR capabilities";

            types = tmpTypes;

            *outMaxLuminance = tmpMaxLuminance;
@@ -269,10 +254,8 @@ std::vector<Hdr> ComposerClient::getHdrCapabilities( 
    return types;

}



void ComposerClient::setClientTargetSlotCount(Display display,

                                              uint32_t clientTargetSlotCount) {

  Error error =

      mClient->setClientTargetSlotCount(display, clientTargetSlotCount);

void ComposerClient::setClientTargetSlotCount(Display display, uint32_t clientTargetSlotCount) {

    Error error = mClient->setClientTargetSlotCount(display, clientTargetSlotCount);

    ASSERT_EQ(Error::NONE, error) << "failed to set client target slot count";

}
@@ -286,15 +269,14 @@ void ComposerClient::setColorMode(Display display, ColorMode mode) { 
    ASSERT_EQ(Error::NONE, error) << "failed to set color mode";

}



void ComposerClient::setPowerMode(Display display,

                                  IComposerClient::PowerMode mode) {

void ComposerClient::setPowerMode(Display display, IComposerClient::PowerMode mode) {

    Error error = mClient->setPowerMode(display, mode);

    ASSERT_EQ(Error::NONE, error) << "failed to set power mode";

}



void ComposerClient::setVsyncEnabled(Display display, bool enabled) {

  IComposerClient::Vsync vsync = (enabled) ? IComposerClient::Vsync::ENABLE

                                           : IComposerClient::Vsync::DISABLE;

    IComposerClient::Vsync vsync =

        (enabled) ? IComposerClient::Vsync::ENABLE : IComposerClient::Vsync::DISABLE;

    Error error = mClient->setVsyncEnabled(display, vsync);

    ASSERT_EQ(Error::NONE, error) << "failed to set vsync mode";
@@ -304,13 +286,11 @@ void ComposerClient::setVsyncEnabled(Display display, bool enabled) { 
    }

}



void ComposerClient::execute(TestCommandReader* reader,

                             CommandWriterBase* writer) {

void ComposerClient::execute(TestCommandReader* reader, CommandWriterBase* writer) {

    bool queueChanged = false;

    uint32_t commandLength = 0;

    hidl_vec<hidl_handle> commandHandles;

  ASSERT_TRUE(

      writer->writeQueue(&queueChanged, &commandLength, &commandHandles));

    ASSERT_TRUE(writer->writeQueue(&queueChanged, &commandLength, &commandHandles));



    if (queueChanged) {

        auto ret = mClient->setInputCommandQueue(*writer->getMQDescriptor());
@@ -318,8 +298,7 @@ void ComposerClient::execute(TestCommandReader* reader, 
        return;

    }



  mClient->executeCommands(

      commandLength, commandHandles,

    mClient->executeCommands(commandLength, commandHandles,

                             [&](const auto& tmpError, const auto& tmpOutQueueChanged,

                                 const auto& tmpOutLength, const auto& tmpOutHandles) {

                                 ASSERT_EQ(Error::NONE, tmpError);

graphics/composer/2.1/utils/vts/include/composer-vts/2.1/VtsHalGraphicsComposerTestUtils.h

+63 −67
Original line number Diff line number Diff line
@@ -78,10 +78,8 @@ class ComposerClient { 
    void registerCallback(const sp<IComposerCallback>& callback);

    uint32_t getMaxVirtualDisplayCount();



  Display createVirtualDisplay(uint32_t width, uint32_t height,

                               PixelFormat formatHint,

                               uint32_t outputBufferSlotCount,

                               PixelFormat* outFormat);

    Display createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat formatHint,

                                 uint32_t outputBufferSlotCount, PixelFormat* outFormat);

    void destroyVirtualDisplay(Display display);



    Layer createLayer(Display display, uint32_t bufferSlotCount);
@@ -98,11 +96,9 @@ class ComposerClient { 
    IComposerClient::DisplayType getDisplayType(Display display);

    bool getDozeSupport(Display display);

    std::vector<Hdr> getHdrCapabilities(Display display, float* outMaxLuminance,

                                      float* outMaxAverageLuminance,

                                      float* outMinLuminance);

                                        float* outMaxAverageLuminance, float* outMinLuminance);



  void setClientTargetSlotCount(Display display,

                                uint32_t clientTargetSlotCount);

    void setClientTargetSlotCount(Display display, uint32_t clientTargetSlotCount);

    void setActiveConfig(Display display, Config config);

    void setColorMode(Display display, ColorMode mode);

    void setPowerMode(Display display, IComposerClient::PowerMode mode);

graphics/composer/2.1/vts/functional/VtsHalGraphicsComposerV2_1TargetTest.cpp

+329 −340

File changed.

Preview size limit exceeded, changes collapsed.

graphics/composer/2.2/utils/vts/VtsHalGraphicsComposerTestUtils.cpp

+2 −2
Original line number Diff line number Diff line
@@ -27,9 +27,9 @@ namespace composer { 
namespace V2_2 {

namespace tests {



using android::hardware::graphics::composer::V2_2::IComposerClient;

using android::hardware::details::getDescriptor;

using android::hardware::details::canCastInterface;

using android::hardware::details::getDescriptor;

using android::hardware::graphics::composer::V2_2::IComposerClient;



std::unique_ptr<ComposerClient_v2_2> Composer_v2_2::createClient_v2_2() {

    std::unique_ptr<ComposerClient_v2_2> client;

graphics/composer/2.1/utils/vts/TestCommandReader.cpp

+24 −24

File changed.

Contains only whitespace changes.

graphics/composer/2.1/utils/vts/include/composer-vts/2.1/GraphicsComposerCallback.h

+19 −19

File changed.

Contains only whitespace changes.

graphics/composer/2.1/utils/vts/include/composer-vts/2.1/TestCommandReader.h

+4 −4

File changed.

Contains only whitespace changes.