blob: 957f720e918aa49465b0c6501326a59255fdc38a [file] [log] [blame]
/*
* 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 defined(SK_GANESH) && 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/GpuTypes.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 // defined(SK_GANESH) && defined(SK_VULKAN)