| /* | |
| * Copyright 2019 Google Inc. | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| // This is a Vulkan protected memory specific test. | |
| #include "include/core/SkTypes.h" | |
| #if SK_SUPPORT_GPU && defined(SK_VULKAN) | |
| #include "include/core/SkAlphaType.h" | |
| #include "include/core/SkBlendMode.h" | |
| #include "include/core/SkBlurTypes.h" | |
| #include "include/core/SkCanvas.h" | |
| #include "include/core/SkColor.h" | |
| #include "include/core/SkColorSpace.h" | |
| #include "include/core/SkColorType.h" | |
| #include "include/core/SkImageInfo.h" | |
| #include "include/core/SkMaskFilter.h" | |
| #include "include/core/SkPaint.h" | |
| #include "include/core/SkPath.h" | |
| #include "include/core/SkRect.h" | |
| #include "include/core/SkRefCnt.h" | |
| #include "include/core/SkSurface.h" | |
| #include "include/core/SkSurfaceProps.h" | |
| #include "include/core/SkTypes.h" | |
| #include "include/gpu/GrBackendSurface.h" | |
| #include "include/gpu/GrDirectContext.h" | |
| #include "include/gpu/GrTypes.h" | |
| #include "tests/CtsEnforcement.h" | |
| #include "tests/Test.h" | |
| #include "tools/gpu/BackendSurfaceFactory.h" | |
| #include "tools/gpu/vk/VkTestHelper.h" | |
| #include <memory> | |
| #include <utility> | |
| struct GrContextOptions; | |
| static sk_sp<SkSurface> create_protected_sksurface(GrDirectContext* dContext, | |
| skiatest::Reporter* reporter, | |
| bool textureable = true) { | |
| const int kW = 8; | |
| const int kH = 8; | |
| SkSurfaceProps surfaceProps = SkSurfaceProps(0, kRGB_H_SkPixelGeometry); | |
| sk_sp<SkSurface> surface; | |
| if (textureable) { | |
| surface = sk_gpu_test::MakeBackendTextureSurface(dContext, | |
| {kW, kH}, | |
| kTopLeft_GrSurfaceOrigin, | |
| 1, | |
| kRGBA_8888_SkColorType, | |
| /* color space */ nullptr, | |
| GrMipmapped::kNo, | |
| GrProtected::kYes, | |
| &surfaceProps); | |
| } else { | |
| surface = sk_gpu_test::MakeBackendRenderTargetSurface(dContext, | |
| {kW, kH}, | |
| kTopLeft_GrSurfaceOrigin, | |
| 1, | |
| kRGBA_8888_SkColorType, | |
| /* color space */ nullptr, | |
| GrProtected::kYes, | |
| &surfaceProps); | |
| } | |
| if (!surface) { | |
| ERRORF(reporter, "Could not create protected surface."); | |
| return nullptr; | |
| } | |
| if (textureable) { | |
| GrBackendTexture backendTex = | |
| surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess); | |
| REPORTER_ASSERT(reporter, backendTex.isValid()); | |
| REPORTER_ASSERT(reporter, backendTex.isProtected()); | |
| } else { | |
| GrBackendRenderTarget backendRT = | |
| surface->getBackendRenderTarget(SkSurface::kFlushRead_BackendHandleAccess); | |
| REPORTER_ASSERT(reporter, backendRT.isValid()); | |
| REPORTER_ASSERT(reporter, backendRT.isProtected()); | |
| } | |
| return surface; | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_CreateNonprotectedContext, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto nonprotectedTestHelper = std::make_unique<VkTestHelper>(false); | |
| REPORTER_ASSERT(reporter, nonprotectedTestHelper->init()); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_CreateProtectedContext, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_CreateProtectedSkSurface, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| auto dContext = protectedTestHelper->directContext(); | |
| REPORTER_ASSERT(reporter, dContext != nullptr); | |
| create_protected_sksurface(dContext, reporter, /*textureable*/ true); | |
| create_protected_sksurface(dContext, reporter, /*textureable*/ false); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_CreateNonprotectedTextureInProtectedContext, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| const int kW = 8; | |
| const int kH = 8; | |
| GrBackendTexture backendTex = | |
| protectedTestHelper->directContext()->createBackendTexture( | |
| kW, kH, kRGBA_8888_SkColorType, GrMipmapped::kNo, GrRenderable::kNo, | |
| GrProtected::kNo); | |
| REPORTER_ASSERT(reporter, !backendTex.isValid()); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_CreateProtectedTextureInNonprotectedContext, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(false); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| const int kW = 8; | |
| const int kH = 8; | |
| GrBackendTexture backendTex = | |
| protectedTestHelper->directContext()->createBackendTexture(kW, | |
| kH, | |
| kRGBA_8888_SkColorType, | |
| GrMipmapped::kNo, | |
| GrRenderable::kNo, | |
| GrProtected::kYes); | |
| REPORTER_ASSERT(reporter, !backendTex.isValid()); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_ReadFromProtectedSurface, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface); | |
| REPORTER_ASSERT(reporter, !surface->readPixels(SkImageInfo(), nullptr, 8, 0, 0)); | |
| } | |
| namespace { | |
| struct AsyncContext { | |
| bool fCalled = false; | |
| std::unique_ptr<const SkSurface::AsyncReadResult> fResult; | |
| }; | |
| static void async_callback(void* c, std::unique_ptr<const SkSurface::AsyncReadResult> result) { | |
| auto context = static_cast<AsyncContext*>(c); | |
| context->fResult = std::move(result); | |
| context->fCalled = true; | |
| } | |
| } // anonymous namespace | |
| DEF_GANESH_TEST(VkProtectedContext_AsyncReadFromProtectedSurface, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| auto dContext = protectedTestHelper->directContext(); | |
| REPORTER_ASSERT(reporter, dContext != nullptr); | |
| auto surface = create_protected_sksurface(dContext, reporter); | |
| REPORTER_ASSERT(reporter, surface); | |
| AsyncContext cbContext; | |
| const auto image_info = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType, | |
| SkColorSpace::MakeSRGB()); | |
| surface->asyncRescaleAndReadPixelsYUV420(kIdentity_SkYUVColorSpace, SkColorSpace::MakeSRGB(), | |
| image_info.bounds(), image_info.dimensions(), | |
| SkSurface::RescaleGamma::kSrc, | |
| SkSurface::RescaleMode::kNearest, | |
| &async_callback, &cbContext); | |
| dContext->submit(); | |
| while (!cbContext.fCalled) { | |
| dContext->checkAsyncWorkCompletion(); | |
| } | |
| REPORTER_ASSERT(reporter, !cbContext.fResult); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_DrawRectangle, reporter, options, CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface); | |
| SkCanvas* canvas = surface->getCanvas(); | |
| REPORTER_ASSERT(reporter, canvas); | |
| SkPaint paint; | |
| paint.setColor(SK_ColorBLACK); | |
| canvas->drawRect(SkRect::MakeWH(4, 4), paint); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_DrawRectangleWithAntiAlias, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface); | |
| SkCanvas* canvas = surface->getCanvas(); | |
| REPORTER_ASSERT(reporter, canvas); | |
| SkPaint paint; | |
| paint.setColor(SK_ColorBLACK); | |
| paint.setAntiAlias(true); | |
| canvas->drawRect(SkRect::MakeWH(4, 4), paint); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_DrawRectangleWithBlendMode, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface); | |
| SkCanvas* canvas = surface->getCanvas(); | |
| REPORTER_ASSERT(reporter, canvas); | |
| SkPaint paint; | |
| paint.setColor(SK_ColorBLACK); | |
| paint.setBlendMode(SkBlendMode::kColorDodge); | |
| canvas->drawRect(SkRect::MakeWH(4, 4), paint); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_DrawRectangleWithFilter, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface); | |
| SkCanvas* canvas = surface->getCanvas(); | |
| REPORTER_ASSERT(reporter, canvas); | |
| SkPaint paint; | |
| paint.setColor(SK_ColorBLACK); | |
| paint.setStyle(SkPaint::kFill_Style); | |
| paint.setMaskFilter(SkMaskFilter::MakeBlur( | |
| SkBlurStyle::kOuter_SkBlurStyle, 1.1f)); | |
| canvas->drawRect(SkRect::MakeWH(4, 4), paint); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_DrawThinPath, reporter, options, CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface); | |
| SkCanvas* canvas = surface->getCanvas(); | |
| REPORTER_ASSERT(reporter, canvas); | |
| SkPaint paint; | |
| paint.setColor(SK_ColorBLACK); | |
| paint.setStyle(SkPaint::kStroke_Style); | |
| paint.setAntiAlias(true); | |
| paint.setStrokeWidth(.4f); | |
| canvas->drawPath(SkPath().moveTo(4, 4).lineTo(6, 6), paint); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_SaveLayer, reporter, options, CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface); | |
| SkCanvas* canvas = surface->getCanvas(); | |
| REPORTER_ASSERT(reporter, canvas); | |
| canvas->saveLayer(nullptr, nullptr); | |
| SkPaint paint; | |
| paint.setColor(SK_ColorBLACK); | |
| canvas->drawRect(SkRect::MakeWH(4, 4), paint); | |
| canvas->restore(); | |
| } | |
| DEF_GANESH_TEST(VkProtectedContext_DrawProtectedImageOnProtectedSurface, | |
| reporter, | |
| options, | |
| CtsEnforcement::kNever) { | |
| auto protectedTestHelper = std::make_unique<VkTestHelper>(true); | |
| if (!protectedTestHelper->init()) { | |
| return; | |
| } | |
| REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); | |
| // Create protected image. | |
| auto surface1 = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface1); | |
| auto image = surface1->makeImageSnapshot(); | |
| REPORTER_ASSERT(reporter, image); | |
| // Create protected canvas. | |
| auto surface2 = create_protected_sksurface(protectedTestHelper->directContext(), reporter); | |
| REPORTER_ASSERT(reporter, surface2); | |
| SkCanvas* canvas = surface2->getCanvas(); | |
| REPORTER_ASSERT(reporter, canvas); | |
| canvas->drawImage(image, 0, 0); | |
| } | |
| #endif // SK_SUPPORT_GPU && defined(SK_VULKAN) |