#include <ContextFactory.h>

Public Member Functions
	ContextFactory (const TestOptions &)

	ContextFactory ()=default

	ContextFactory (const ContextFactory &)=delete

ContextFactory &	operator= (const ContextFactory &)=delete

	~ContextFactory ()=default

ContextInfo	getContextInfo (skgpu::ContextType)

Detailed Description

Definition at line 30 of file ContextFactory.h.

Constructor & Destructor Documentation

◆ ContextFactory() [1/3]

skiatest::graphite::ContextFactory::ContextFactory ( const TestOptions & options )

explicit

Definition at line 47 of file ContextFactory.cpp.

48 : fOptions(options) {}

options

const char * options

Definition: CommonFlagsConfig.cpp:43

◆ ContextFactory() [2/3]

skiatest::graphite::ContextFactory::ContextFactory ( )

default

◆ ContextFactory() [3/3]

skiatest::graphite::ContextFactory::ContextFactory ( const ContextFactory & )

delete

◆ ~ContextFactory()

skiatest::graphite::ContextFactory::~ContextFactory ( )

default

Member Function Documentation

◆ getContextInfo()

ContextInfo skiatest::graphite::ContextFactory::getContextInfo ( skgpu::ContextType type )

Definition at line 54 of file ContextFactory.cpp.

                                                                {
    if (!skgpu::IsDawnBackend(type) && fOptions.fNeverYieldToWebGPU) {
        return {};
    }
 
    // Look for an existing ContextInfo that we can re-use.
    for (const OwnedContextInfo& ctxInfo : fContexts) {
        if (ctxInfo.fType == type) {
            return AsContextInfo(ctxInfo);
        }
    }
 
    // Create a new ContextInfo from this context type.
    std::unique_ptr<GraphiteTestContext> testCtx;
 
    switch (type) {
        case skgpu::ContextType::kMetal: {
#ifdef SK_METAL
            testCtx = graphite::MtlTestContext::Make();
#endif
        } break;
        case skgpu::ContextType::kVulkan: {
#ifdef SK_VULKAN
            testCtx = graphite::VulkanTestContext::Make();
#endif
        } break;
#ifdef SK_DAWN
 
#define CASE(TYPE)                                                          \
    case skgpu::ContextType::kDawn_##TYPE:                                  \
        testCtx = graphite::DawnTestContext::Make(wgpu::BackendType::TYPE); \
        break;
#else
#define CASE(TYPE)                         \
    case skgpu::ContextType::kDawn_##TYPE: \
        break;
#endif // SK_DAWN
        CASE(D3D11)
        CASE(D3D12)
        CASE(Metal)
        CASE(Vulkan)
        CASE(OpenGL)
        CASE(OpenGLES)
#undef CASE
 
        default:
            break;
    }
 
    if (!testCtx) {
        return ContextInfo{};
    }
 
    std::unique_ptr<skgpu::graphite::Context> context = testCtx->makeContext(fOptions);
    if (!context) {
        return ContextInfo{};
    }
 
    fContexts.push_back({type, std::move(testCtx), std::move(context)});
    return AsContextInfo(fContexts.back());
}

◆ operator=()

ContextFactory & skiatest::graphite::ContextFactory::operator= ( const ContextFactory & )