path: root/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h

/*
 * Copyright 2021 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.
 */

#pragma once

#include <compositionengine/Display.h>
#include <compositionengine/LayerFECompositionState.h>
#include <compositionengine/OutputLayer.h>
#include <compositionengine/impl/CompositionEngine.h>
#include <compositionengine/impl/Display.h>
#include <compositionengine/impl/OutputLayerCompositionState.h>
#include <ftl/fake_guard.h>
#include <gui/LayerDebugInfo.h>
#include <gui/ScreenCaptureResults.h>
#include <gui/SurfaceComposerClient.h>
#include <gui/mock/GraphicBufferProducer.h>
#include <ui/DisplayStatInfo.h>
#include <ui/DynamicDisplayInfo.h>

#include "DisplayDevice.h"
#include "DisplayHardware/ComposerHal.h"
#include "FrameTimeline/FrameTimeline.h"
#include "FrameTracer/FrameTracer.h"
#include "FrontEnd/LayerHandle.h"
#include "Layer.h"
#include "NativeWindowSurface.h"
#include "Scheduler/EventThread.h"
#include "Scheduler/MessageQueue.h"
#include "Scheduler/RefreshRateSelector.h"
#include "Scheduler/VSyncTracker.h"
#include "Scheduler/VsyncConfiguration.h"
#include "Scheduler/VsyncController.h"
#include "Scheduler/VsyncModulator.h"
#include "StartPropertySetThread.h"
#include "SurfaceFlinger.h"
#include "SurfaceFlingerDefaultFactory.h"
#include "ThreadContext.h"
#include "TimeStats/TimeStats.h"
#include "surfaceflinger_scheduler_fuzzer.h"

#include "renderengine/mock/RenderEngine.h"
#include "scheduler/TimeKeeper.h"
#include "tests/unittests/mock/DisplayHardware/MockComposer.h"
#include "tests/unittests/mock/DisplayHardware/MockDisplayMode.h"
#include "tests/unittests/mock/DisplayHardware/MockHWC2.h"
#include "tests/unittests/mock/DisplayHardware/MockPowerAdvisor.h"
#include "tests/unittests/mock/MockEventThread.h"
#include "tests/unittests/mock/MockFrameTimeline.h"
#include "tests/unittests/mock/MockFrameTracer.h"
#include "tests/unittests/mock/MockNativeWindowSurface.h"
#include "tests/unittests/mock/MockTimeStats.h"
#include "tests/unittests/mock/MockVSyncTracker.h"
#include "tests/unittests/mock/MockVsyncController.h"

namespace android {
namespace Hwc2 {

class Composer;

namespace types = hardware::graphics::common;

namespace V2_1 = hardware::graphics::composer::V2_1;
namespace V2_2 = hardware::graphics::composer::V2_2;
namespace V2_3 = hardware::graphics::composer::V2_3;
namespace V2_4 = hardware::graphics::composer::V2_4;

using types::V1_0::ColorTransform;
using types::V1_0::Transform;
using types::V1_1::RenderIntent;
using types::V1_2::ColorMode;
using types::V1_2::Dataspace;
using types::V1_2::PixelFormat;

using V2_1::Config;
using V2_1::Display;
using V2_1::Error;
using V2_1::Layer;
using V2_4::CommandReaderBase;
using V2_4::CommandWriterBase;
using V2_4::IComposer;
using V2_4::IComposerCallback;
using V2_4::IComposerClient;
using V2_4::VsyncPeriodChangeTimeline;
using V2_4::VsyncPeriodNanos;
using DisplayCapability = IComposerClient::DisplayCapability;
using PerFrameMetadata = IComposerClient::PerFrameMetadata;
using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey;
using PerFrameMetadataBlob = IComposerClient::PerFrameMetadataBlob;
}; // namespace Hwc2

static constexpr hal::HWDisplayId kHwDisplayId = 1000;

static constexpr ui::Hdr kHdrTypes[] = {ui::Hdr::DOLBY_VISION, ui::Hdr::HDR10, ui::Hdr::HLG,
                                        ui::Hdr::HDR10_PLUS};

static constexpr ui::ColorMode kColormodes[] = {ui::ColorMode::NATIVE,
                                                ui::ColorMode::STANDARD_BT601_625,
                                                ui::ColorMode::STANDARD_BT601_625_UNADJUSTED,
                                                ui::ColorMode::STANDARD_BT601_525,
                                                ui::ColorMode::STANDARD_BT601_525_UNADJUSTED,
                                                ui::ColorMode::STANDARD_BT709,
                                                ui::ColorMode::DCI_P3,
                                                ui::ColorMode::SRGB,
                                                ui::ColorMode::ADOBE_RGB,
                                                ui::ColorMode::DISPLAY_P3,
                                                ui::ColorMode::BT2020,
                                                ui::ColorMode::BT2100_PQ,
                                                ui::ColorMode::BT2100_HLG,
                                                ui::ColorMode::DISPLAY_BT2020};

static constexpr ui::PixelFormat kPixelFormats[] = {ui::PixelFormat::RGBA_8888,
                                                    ui::PixelFormat::RGBX_8888,
                                                    ui::PixelFormat::RGB_888,
                                                    ui::PixelFormat::RGB_565,
                                                    ui::PixelFormat::BGRA_8888,
                                                    ui::PixelFormat::YCBCR_422_SP,
                                                    ui::PixelFormat::YCRCB_420_SP,
                                                    ui::PixelFormat::YCBCR_422_I,
                                                    ui::PixelFormat::RGBA_FP16,
                                                    ui::PixelFormat::RAW16,
                                                    ui::PixelFormat::BLOB,
                                                    ui::PixelFormat::IMPLEMENTATION_DEFINED,
                                                    ui::PixelFormat::YCBCR_420_888,
                                                    ui::PixelFormat::RAW_OPAQUE,
                                                    ui::PixelFormat::RAW10,
                                                    ui::PixelFormat::RAW12,
                                                    ui::PixelFormat::RGBA_1010102,
                                                    ui::PixelFormat::Y8,
                                                    ui::PixelFormat::Y16,
                                                    ui::PixelFormat::YV12,
                                                    ui::PixelFormat::DEPTH_16,
                                                    ui::PixelFormat::DEPTH_24,
                                                    ui::PixelFormat::DEPTH_24_STENCIL_8,
                                                    ui::PixelFormat::DEPTH_32F,
                                                    ui::PixelFormat::DEPTH_32F_STENCIL_8,
                                                    ui::PixelFormat::STENCIL_8,
                                                    ui::PixelFormat::YCBCR_P010,
                                                    ui::PixelFormat::HSV_888};

inline VsyncId getFuzzedVsyncId(FuzzedDataProvider& fdp) {
    return VsyncId{fdp.ConsumeIntegral<int64_t>()};
}

inline TimePoint getFuzzedTimePoint(FuzzedDataProvider& fdp) {
    return TimePoint::fromNs(fdp.ConsumeIntegral<nsecs_t>());
}

inline Duration getFuzzedDuration(FuzzedDataProvider& fdp) {
    return Duration::fromNs(fdp.ConsumeIntegral<nsecs_t>());
}

inline FloatRect getFuzzedFloatRect(FuzzedDataProvider* fdp) {
    return FloatRect(fdp->ConsumeFloatingPoint<float>() /*left*/,
                     fdp->ConsumeFloatingPoint<float>() /*right*/,
                     fdp->ConsumeFloatingPoint<float>() /*top*/,
                     fdp->ConsumeFloatingPoint<float>() /*bottom*/);
}

inline HdrMetadata getFuzzedHdrMetadata(FuzzedDataProvider* fdp) {
    HdrMetadata hdrMetadata;
    if (fdp->ConsumeBool()) {
        hdrMetadata.cta8613.maxContentLightLevel = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.cta8613.maxFrameAverageLightLevel = fdp->ConsumeFloatingPoint<float>();

        hdrMetadata.validTypes |= HdrMetadata::CTA861_3;
    } else {
        hdrMetadata.smpte2086.displayPrimaryRed.x = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.displayPrimaryRed.y = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.displayPrimaryGreen.x = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.displayPrimaryGreen.y = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.displayPrimaryBlue.x = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.displayPrimaryBlue.y = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.whitePoint.x = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.whitePoint.y = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.minLuminance = fdp->ConsumeFloatingPoint<float>();
        hdrMetadata.smpte2086.maxLuminance = fdp->ConsumeFloatingPoint<float>();

        hdrMetadata.validTypes |= HdrMetadata::SMPTE2086;
    }
    return hdrMetadata;
}

class EventThread;

namespace hal = android::hardware::graphics::composer::hal;

struct FakePhaseOffsets : scheduler::VsyncConfiguration {
    static constexpr nsecs_t FAKE_PHASE_OFFSET_NS = 0;
    static constexpr auto FAKE_DURATION_OFFSET_NS = std::chrono::nanoseconds(0);

    scheduler::VsyncConfigSet getConfigsForRefreshRate(Fps) const override {
        return getCurrentConfigs();
    }

    scheduler::VsyncConfigSet getCurrentConfigs() const override {
        return {{FAKE_PHASE_OFFSET_NS, FAKE_PHASE_OFFSET_NS, FAKE_DURATION_OFFSET_NS,
                 FAKE_DURATION_OFFSET_NS},
                {FAKE_PHASE_OFFSET_NS, FAKE_PHASE_OFFSET_NS, FAKE_DURATION_OFFSET_NS,
                 FAKE_DURATION_OFFSET_NS},
                {FAKE_PHASE_OFFSET_NS, FAKE_PHASE_OFFSET_NS, FAKE_DURATION_OFFSET_NS,
                 FAKE_DURATION_OFFSET_NS},
                FAKE_DURATION_OFFSET_NS};
    }

    void reset() override {}
    void setRefreshRateFps(Fps) override {}
    void dump(std::string &) const override {}
};

namespace scheduler {

class TestableScheduler : public Scheduler, private ICompositor {
public:
    TestableScheduler(const std::shared_ptr<scheduler::RefreshRateSelector>& selectorPtr,
                      sp<VsyncModulator> modulatorPtr, ISchedulerCallback& callback,
                      IVsyncTrackerCallback& vsyncTrackerCallback)
          : TestableScheduler(std::make_unique<android::mock::VsyncController>(),
                              std::make_shared<android::mock::VSyncTracker>(), selectorPtr,
                              std::move(modulatorPtr), callback, vsyncTrackerCallback) {}

    TestableScheduler(std::unique_ptr<VsyncController> controller,
                      VsyncSchedule::TrackerPtr tracker,
                      std::shared_ptr<RefreshRateSelector> selectorPtr,
                      sp<VsyncModulator> modulatorPtr, ISchedulerCallback& callback,
                      IVsyncTrackerCallback& vsyncTrackerCallback)
          : Scheduler(*this, callback, Feature::kContentDetection, std::move(modulatorPtr),
                      vsyncTrackerCallback) {
        const auto displayId = selectorPtr->getActiveMode().modePtr->getPhysicalDisplayId();
        registerDisplayInternal(displayId, std::move(selectorPtr),
                                std::shared_ptr<VsyncSchedule>(
                                        new VsyncSchedule(displayId, std::move(tracker),
                                                          std::make_shared<FuzzImplVSyncDispatch>(),
                                                          std::move(controller))));
    }

    ConnectionHandle createConnection(std::unique_ptr<EventThread> eventThread) {
        return Scheduler::createConnection(std::move(eventThread));
    }

    auto &mutableLayerHistory() { return mLayerHistory; }

    auto refreshRateSelector() { return pacesetterSelectorPtr(); }

    void replaceTouchTimer(int64_t millis) {
        if (mTouchTimer) {
            mTouchTimer.reset();
        }
        mTouchTimer.emplace(
                "Testable Touch timer", std::chrono::milliseconds(millis),
                [this] { touchTimerCallback(TimerState::Reset); },
                [this] { touchTimerCallback(TimerState::Expired); });
        mTouchTimer->start();
    }

    bool isTouchActive() {
        std::lock_guard<std::mutex> lock(mPolicyLock);
        return mPolicy.touch == Scheduler::TouchState::Active;
    }

    void dispatchCachedReportedMode() {
        std::lock_guard<std::mutex> lock(mPolicyLock);
        return Scheduler::dispatchCachedReportedMode();
    }

    void clearCachedReportedMode() {
        std::lock_guard<std::mutex> lock(mPolicyLock);
        mPolicy.cachedModeChangedParams.reset();
    }

    void onNonPrimaryDisplayModeChanged(ConnectionHandle handle, const FrameRateMode &mode) {
        return Scheduler::onNonPrimaryDisplayModeChanged(handle, mode);
    }

    using Scheduler::setVsyncConfig;

private:
    // ICompositor overrides:
    void configure() override {}
    bool commit(PhysicalDisplayId, const scheduler::FrameTargets&) override { return false; }
    CompositeResultsPerDisplay composite(PhysicalDisplayId,
                                         const scheduler::FrameTargeters&) override {
        return {};
    }
    void sample() override {}

    // MessageQueue overrides:
    void scheduleFrame() override {}
    void postMessage(sp<MessageHandler>&& handler) override { handler->handleMessage(Message()); }
};

} // namespace scheduler

namespace surfaceflinger::test {

class Factory final : public surfaceflinger::Factory {
    struct NoOpMessageQueue : android::impl::MessageQueue {
        using android::impl::MessageQueue::MessageQueue;
        void onFrameSignal(ICompositor&, VsyncId, TimePoint) override {}
    };

public:
    ~Factory() = default;

    std::unique_ptr<HWComposer> createHWComposer(const std::string&) override { return nullptr; }

    std::unique_ptr<MessageQueue> createMessageQueue(ICompositor& compositor) {
        return std::make_unique<NoOpMessageQueue>(compositor);
    }

    std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
            Fps /*currentRefreshRate*/) override {
        return std::make_unique<FakePhaseOffsets>();
    }

    std::unique_ptr<scheduler::Scheduler> createScheduler(
            const std::shared_ptr<scheduler::RefreshRateSelector>&,
            scheduler::ISchedulerCallback&) {
        return nullptr;
    }

    sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
        return sp<StartPropertySetThread>::make(timestampPropertyValue);
    }

    sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs &creationArgs) override {
        return sp<DisplayDevice>::make(creationArgs);
    }

    sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
                                          uint32_t layerCount, uint64_t usage,
                                          std::string requestorName) override {
        return sp<GraphicBuffer>::make(width, height, format, layerCount, usage, requestorName);
    }

    void createBufferQueue(sp<IGraphicBufferProducer> *outProducer,
                           sp<IGraphicBufferConsumer> *outConsumer,
                           bool consumerIsSurfaceFlinger) override {
        if (!mCreateBufferQueue) {
            BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
            return;
        }
        mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
    }

    std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
            const sp<IGraphicBufferProducer> &producer) override {
        if (!mCreateNativeWindowSurface) return nullptr;
        return mCreateNativeWindowSurface(producer);
    }

    std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
        return compositionengine::impl::createCompositionEngine();
    }

    sp<Layer> createBufferStateLayer(const LayerCreationArgs &) override { return nullptr; }

    sp<Layer> createEffectLayer(const LayerCreationArgs &args) override {
        return sp<Layer>::make(args);
    }

    sp<LayerFE> createLayerFE(const std::string &layerName) override {
        return sp<LayerFE>::make(layerName);
    }

    std::unique_ptr<FrameTracer> createFrameTracer() override {
        return std::make_unique<android::mock::FrameTracer>();
    }

    std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
            std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
        return std::make_unique<android::mock::FrameTimeline>(timeStats, surfaceFlingerPid);
    }

    using CreateBufferQueueFunction =
            std::function<void(sp<IGraphicBufferProducer> * /* outProducer */,
                               sp<IGraphicBufferConsumer> * /* outConsumer */,
                               bool /* consumerIsSurfaceFlinger */)>;
    CreateBufferQueueFunction mCreateBufferQueue;

    using CreateNativeWindowSurfaceFunction =
            std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
                    const sp<IGraphicBufferProducer> &)>;
    CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;

    using CreateCompositionEngineFunction =
            std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
    CreateCompositionEngineFunction mCreateCompositionEngine;
};

} // namespace surfaceflinger::test

// TODO(b/189053744) : Create a common test/mock library for surfaceflinger
class TestableSurfaceFlinger final : private scheduler::ISchedulerCallback,
                                     private scheduler::IVsyncTrackerCallback {
public:
    using HotplugEvent = SurfaceFlinger::HotplugEvent;

    SurfaceFlinger *flinger() { return mFlinger.get(); }
    scheduler::TestableScheduler *scheduler() { return mScheduler; }

    void initializeDisplays() {
        FTL_FAKE_GUARD(kMainThreadContext, mFlinger->initializeDisplays());
    }

    void setGlobalShadowSettings(FuzzedDataProvider *fdp) {
        const half4 ambientColor{fdp->ConsumeFloatingPoint<float>(),
                                 fdp->ConsumeFloatingPoint<float>(),
                                 fdp->ConsumeFloatingPoint<float>(),
                                 fdp->ConsumeFloatingPoint<float>()};
        const half4 spotColor{fdp->ConsumeFloatingPoint<float>(),
                              fdp->ConsumeFloatingPoint<float>(),
                              fdp->ConsumeFloatingPoint<float>(),
                              fdp->ConsumeFloatingPoint<float>()};
        float lightPosY = fdp->ConsumeFloatingPoint<float>();
        float lightPosZ = fdp->ConsumeFloatingPoint<float>();
        float lightRadius = fdp->ConsumeFloatingPoint<float>();
        mFlinger->setGlobalShadowSettings(ambientColor, spotColor, lightPosY, lightPosZ,
                                          lightRadius);
    }

    void onPullAtom(FuzzedDataProvider *fdp) {
        const int32_t atomId = fdp->ConsumeIntegral<uint8_t>();
        std::vector<uint8_t> pulledData = fdp->ConsumeRemainingBytes<uint8_t>();
        bool success = fdp->ConsumeBool();
        mFlinger->onPullAtom(atomId, &pulledData, &success);
    }

    void fuzzDumpsysAndDebug(FuzzedDataProvider *fdp) {
        std::string result = fdp->ConsumeRandomLengthString().c_str();
        mFlinger->appendSfConfigString(result);
        result = fdp->ConsumeRandomLengthString().c_str();
        mFlinger->listLayersLocked(result);

        using DumpArgs = Vector<String16>;
        DumpArgs dumpArgs;
        dumpArgs.push_back(String16(fdp->ConsumeRandomLengthString().c_str()));
        mFlinger->clearStatsLocked(dumpArgs, result);

        mFlinger->dumpTimeStats(dumpArgs, fdp->ConsumeBool(), result);
        FTL_FAKE_GUARD(kMainThreadContext,
                       mFlinger->logFrameStats(TimePoint::fromNs(fdp->ConsumeIntegral<nsecs_t>())));

        result = fdp->ConsumeRandomLengthString().c_str();
        mFlinger->dumpFrameTimeline(dumpArgs, result);

        result = fdp->ConsumeRandomLengthString().c_str();
        mFlinger->dumpRawDisplayIdentificationData(dumpArgs, result);

        perfetto::protos::LayersProto layersProto =
                mFlinger->dumpDrawingStateProto(fdp->ConsumeIntegral<uint32_t>());
        mFlinger->dumpOffscreenLayersProto(layersProto);
        mFlinger->dumpDisplayProto();

        result = fdp->ConsumeRandomLengthString().c_str();
        mFlinger->dumpHwc(result);

        mFlinger->calculateColorMatrix(fdp->ConsumeFloatingPoint<float>());
        mFlinger->updateColorMatrixLocked();
        mFlinger->CheckTransactCodeCredentials(fdp->ConsumeIntegral<uint32_t>());
    }

    void getCompositionPreference() {
        ui::Dataspace outDataspace;
        ui::PixelFormat outPixelFormat;
        ui::Dataspace outWideColorGamutDataspace;
        ui::PixelFormat outWideColorGamutPixelFormat;
        mFlinger->getCompositionPreference(&outDataspace, &outPixelFormat,
                                           &outWideColorGamutDataspace,
                                           &outWideColorGamutPixelFormat);
    }

    void overrideHdrTypes(const sp<IBinder>& display, FuzzedDataProvider* fdp) {
        std::vector<ui::Hdr> hdrTypes;
        hdrTypes.push_back(fdp->PickValueInArray(kHdrTypes));
        mFlinger->overrideHdrTypes(display, hdrTypes);
    }

    void getDisplayedContentSample(const sp<IBinder>& display, FuzzedDataProvider* fdp) {
        DisplayedFrameStats outDisplayedFrameStats;
        mFlinger->getDisplayedContentSample(display, fdp->ConsumeIntegral<uint64_t>(),
                                            fdp->ConsumeIntegral<uint64_t>(),
                                            &outDisplayedFrameStats);
    }

    void getDisplayStats(const sp<IBinder>& display) {
        android::DisplayStatInfo stats;
        mFlinger->getDisplayStats(display, &stats);
    }

    void getDisplayState(const sp<IBinder>& display) {
        ui::DisplayState displayState;
        mFlinger->getDisplayState(display, &displayState);
    }

    void getStaticDisplayInfo(int64_t displayId) {
        ui::StaticDisplayInfo staticDisplayInfo;
        mFlinger->getStaticDisplayInfo(displayId, &staticDisplayInfo);
    }

    void getDynamicDisplayInfo(int64_t displayId) {
        android::ui::DynamicDisplayInfo dynamicDisplayInfo;
        mFlinger->getDynamicDisplayInfoFromId(displayId, &dynamicDisplayInfo);
    }
    void getDisplayNativePrimaries(const sp<IBinder>& display) {
        android::ui::DisplayPrimaries displayPrimaries;
        mFlinger->getDisplayNativePrimaries(display, displayPrimaries);
    }

    void getDesiredDisplayModeSpecs(const sp<IBinder>& display) {
        gui::DisplayModeSpecs _;
        mFlinger->getDesiredDisplayModeSpecs(display, &_);
    }

    // TODO(b/248317436): extend to cover all displays for multi-display devices
    static std::optional<PhysicalDisplayId> getFirstDisplayId() {
        std::vector<PhysicalDisplayId> ids = SurfaceComposerClient::getPhysicalDisplayIds();
        if (ids.empty()) return {};
        return ids.front();
    }

    std::pair<sp<IBinder>, PhysicalDisplayId> fuzzBoot(FuzzedDataProvider* fdp) {
        mFlinger->callingThreadHasUnscopedSurfaceFlingerAccess(fdp->ConsumeBool());
        const sp<Client> client = sp<Client>::make(mFlinger);

        DisplayIdGenerator<HalVirtualDisplayId> kGenerator;
        HalVirtualDisplayId halVirtualDisplayId = kGenerator.generateId().value();

        ui::Size uiSize{fdp->ConsumeIntegral<int32_t>(), fdp->ConsumeIntegral<int32_t>()};
        ui::PixelFormat pixelFormat{};
        mFlinger->getHwComposer().allocateVirtualDisplay(halVirtualDisplayId, uiSize, &pixelFormat);

        PhysicalDisplayId physicalDisplayId = getFirstDisplayId().value_or(
                PhysicalDisplayId::fromPort(fdp->ConsumeIntegral<uint8_t>()));
        mFlinger->getHwComposer().allocatePhysicalDisplay(kHwDisplayId, physicalDisplayId);

        sp<IBinder> display =
                mFlinger->createDisplay(String8(fdp->ConsumeRandomLengthString().c_str()),
                                        fdp->ConsumeBool());

        initializeDisplays();
        mFlinger->getPhysicalDisplayToken(physicalDisplayId);

        mFlinger->mStartPropertySetThread =
                mFlinger->getFactory().createStartPropertySetThread(fdp->ConsumeBool());

        mFlinger->bootFinished();

        return {display, physicalDisplayId};
    }

    void fuzzSurfaceFlinger(const uint8_t *data, size_t size) {
        FuzzedDataProvider mFdp(data, size);

        const auto [display, displayId] = fuzzBoot(&mFdp);

        sp<IGraphicBufferProducer> bufferProducer = sp<mock::GraphicBufferProducer>::make();

        mFlinger->createDisplayEventConnection();

        getDisplayStats(display);
        getDisplayState(display);
        getStaticDisplayInfo(displayId.value);
        getDynamicDisplayInfo(displayId.value);
        getDisplayNativePrimaries(display);

        mFlinger->setAutoLowLatencyMode(display, mFdp.ConsumeBool());
        mFlinger->setGameContentType(display, mFdp.ConsumeBool());
        mFlinger->setPowerMode(display, mFdp.ConsumeIntegral<int>());

        overrideHdrTypes(display, &mFdp);

        onPullAtom(&mFdp);

        getCompositionPreference();
        getDisplayedContentSample(display, &mFdp);
        getDesiredDisplayModeSpecs(display);

        bool outSupport;
        mFlinger->getDisplayBrightnessSupport(display, &outSupport);

        mFlinger->notifyPowerBoost(mFdp.ConsumeIntegral<int32_t>());

        setGlobalShadowSettings(&mFdp);

        mFlinger->binderDied(display);
        mFlinger->onFirstRef();

        mFlinger->updateInputFlinger(VsyncId{}, TimePoint{});
        mFlinger->updateCursorAsync();

        mutableScheduler().setVsyncConfig({.sfOffset = mFdp.ConsumeIntegral<nsecs_t>(),
                                           .appOffset = mFdp.ConsumeIntegral<nsecs_t>(),
                                           .sfWorkDuration = getFuzzedDuration(mFdp),
                                           .appWorkDuration = getFuzzedDuration(mFdp)},
                                          getFuzzedDuration(mFdp));

        {
            ftl::FakeGuard guard(kMainThreadContext);

            mFlinger->commitTransactions();
            mFlinger->flushTransactionQueues(getFuzzedVsyncId(mFdp));

            scheduler::FrameTargeter frameTargeter(displayId, mFdp.ConsumeBool());
            mFlinger->onCompositionPresented(displayId, ftl::init::map(displayId, &frameTargeter),
                                             mFdp.ConsumeIntegral<nsecs_t>());
        }

        mFlinger->setTransactionFlags(mFdp.ConsumeIntegral<uint32_t>());
        mFlinger->clearTransactionFlags(mFdp.ConsumeIntegral<uint32_t>());
        mFlinger->commitOffscreenLayers();

        mFlinger->frameIsEarly(getFuzzedTimePoint(mFdp), getFuzzedVsyncId(mFdp));
        mFlinger->computeLayerBounds();
        mFlinger->startBootAnim();

        mFlinger->readPersistentProperties();

        mFlinger->exceedsMaxRenderTargetSize(mFdp.ConsumeIntegral<uint32_t>(),
                                             mFdp.ConsumeIntegral<uint32_t>());

        mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(mFdp.ConsumeIntegral<uid_t>());

        mFlinger->enableHalVirtualDisplays(mFdp.ConsumeBool());

        fuzzDumpsysAndDebug(&mFdp);

        mFlinger->destroyDisplay(display);
    }

    void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
        mFlinger->mRenderEngine = std::move(renderEngine);
        mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
    }

    void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
        mFlinger->mCompositionEngine->setHwComposer(
                std::make_unique<impl::HWComposer>(std::move(composer)));
    }

    void setupTimeStats(const std::shared_ptr<TimeStats> &timeStats) {
        mFlinger->mCompositionEngine->setTimeStats(timeStats);
    }

    // The ISchedulerCallback argument can be nullptr for a no-op implementation.
    void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
                        std::shared_ptr<scheduler::VSyncTracker> vsyncTracker,
                        std::unique_ptr<EventThread> appEventThread,
                        std::unique_ptr<EventThread> sfEventThread,
                        scheduler::ISchedulerCallback* callback = nullptr,
                        scheduler::IVsyncTrackerCallback* vsyncTrackerCallback = nullptr,
                        bool hasMultipleModes = false) {
        constexpr DisplayModeId kModeId60{0};
        DisplayModes modes = makeModes(mock::createDisplayMode(kModeId60, 60_Hz));

        if (hasMultipleModes) {
            constexpr DisplayModeId kModeId90{1};
            modes.try_emplace(kModeId90, mock::createDisplayMode(kModeId90, 90_Hz));
        }

        mRefreshRateSelector = std::make_shared<scheduler::RefreshRateSelector>(modes, kModeId60);
        const auto fps = mRefreshRateSelector->getActiveMode().modePtr->getVsyncRate();
        mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);

        mFlinger->mRefreshRateStats =
                std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
                                                              hal::PowerMode::OFF);

        auto modulatorPtr = sp<scheduler::VsyncModulator>::make(
                mFlinger->mVsyncConfiguration->getCurrentConfigs());

        mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
                                                      std::move(vsyncTracker), mRefreshRateSelector,
                                                      std::move(modulatorPtr), *(callback ?: this),
                                                      *(vsyncTrackerCallback ?: this));

        mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
        mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
        resetScheduler(mScheduler);
    }

    void resetScheduler(scheduler::Scheduler *scheduler) { mFlinger->mScheduler.reset(scheduler); }

    scheduler::TestableScheduler &mutableScheduler() const { return *mScheduler; }

    using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
    void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
        mFactory.mCreateBufferQueue = f;
    }

    using CreateNativeWindowSurfaceFunction =
            surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
    void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
        mFactory.mCreateNativeWindowSurface = f;
    }

    void setInternalDisplayPrimaries(const ui::DisplayPrimaries &primaries) {
        memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
    }

    static auto &mutableLayerDrawingState(const sp<Layer> &layer) { return layer->mDrawingState; }

    auto &mutableStateLock() { return mFlinger->mStateLock; }

    static auto findOutputLayerForDisplay(const sp<Layer> &layer,
                                          const sp<const DisplayDevice> &display) {
        return layer->findOutputLayerForDisplay(display.get());
    }

    /* ------------------------------------------------------------------------
     * Forwarding for functions being tested
     */

    void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }

    void commitTransactionsLocked(uint32_t transactionFlags) FTL_FAKE_GUARD(kMainThreadContext) {
        Mutex::Autolock lock(mFlinger->mStateLock);
        mFlinger->commitTransactionsLocked(transactionFlags);
    }

    auto setDisplayStateLocked(const DisplayState &s) {
        Mutex::Autolock lock(mFlinger->mStateLock);
        return mFlinger->setDisplayStateLocked(s);
    }

    auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }

    // Allow reading display state without locking, as if called on the SF main thread.
    auto setPowerModeInternal(const sp<DisplayDevice> &display,
                              hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
        return mFlinger->setPowerModeInternal(display, mode);
    }

    auto &getTransactionQueue() { return mFlinger->mTransactionHandler.mLocklessTransactionQueue; }
    auto &getPendingTransactionQueue() {
        return mFlinger->mTransactionHandler.mPendingTransactionQueues;
    }

    auto setTransactionState(
            const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& states,
            const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
            const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
            bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
            bool hasListenerCallbacks, std::vector<ListenerCallbacks>& listenerCallbacks,
            uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) {
        return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
                                             inputWindowCommands, desiredPresentTime,
                                             isAutoTimestamp, uncacheBuffers, hasListenerCallbacks,
                                             listenerCallbacks, transactionId,
                                             mergedTransactionIds);
    }

    auto flushTransactionQueues() {
        ftl::FakeGuard guard(kMainThreadContext);
        return mFlinger->flushTransactionQueues(VsyncId{0});
    }

    auto onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
        return mFlinger->onTransact(code, data, reply, flags);
    }

    auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); }

    auto calculateMaxAcquiredBufferCount(Fps refreshRate,
                                         std::chrono::nanoseconds presentLatency) const {
        return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
    }

    /* Read-write access to private data to set up preconditions and assert
     * post-conditions.
     */
    auto& mutableSupportsWideColor() { return mFlinger->mSupportsWideColor; }
    auto& mutableCurrentState() { return mFlinger->mCurrentState; }
    auto& mutableDisplays() { return mFlinger->mDisplays; }
    auto& mutableDrawingState() { return mFlinger->mDrawingState; }

    auto fromHandle(const sp<IBinder> &handle) { return LayerHandle::getLayer(handle); }

    ~TestableSurfaceFlinger() {
        mutableDisplays().clear();
        mutableCurrentState().displays.clear();
        mutableDrawingState().displays.clear();
        mFlinger->mScheduler.reset();
        mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
        mFlinger->mRenderEngine = std::unique_ptr<renderengine::RenderEngine>();
        mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
    }

private:
    void requestHardwareVsync(PhysicalDisplayId, bool) override {}
    void requestDisplayModes(std::vector<display::DisplayModeRequest>) override {}
    void kernelTimerChanged(bool) override {}
    void triggerOnFrameRateOverridesChanged() override {}
    void onChoreographerAttached() override {}

    // IVsyncTrackerCallback overrides
    void onVsyncGenerated(TimePoint, ftl::NonNull<DisplayModePtr>, Fps) override {}

    surfaceflinger::test::Factory mFactory;
    sp<SurfaceFlinger> mFlinger =
            sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization);
    scheduler::TestableScheduler *mScheduler = nullptr;
    std::shared_ptr<scheduler::RefreshRateSelector> mRefreshRateSelector;
};

} // namespace android