Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2019 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | // This is a Vulkan protected memory specific test. |
| 9 | |
| 10 | #include "include/core/SkTypes.h" |
| 11 | |
| 12 | #if SK_SUPPORT_GPU && defined(SK_VULKAN) |
| 13 | |
| 14 | #include "include/core/SkCanvas.h" |
| 15 | #include "include/core/SkMaskFilter.h" |
| 16 | #include "include/core/SkPaint.h" |
| 17 | #include "include/core/SkSurface.h" |
| 18 | #include "include/gpu/GrBackendSurface.h" |
| 19 | #include "include/gpu/vk/GrVkBackendContext.h" |
| 20 | #include "include/gpu/vk/GrVkExtensions.h" |
| 21 | #include "tests/Test.h" |
| 22 | #include "tools/gpu/GrContextFactory.h" |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 23 | #include "tools/gpu/vk/VkTestHelper.h" |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 24 | |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 25 | static sk_sp<SkSurface> create_protected_sksurface(GrDirectContext* dContext, |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 26 | skiatest::Reporter* reporter) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 27 | const int kW = 8; |
| 28 | const int kH = 8; |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 29 | GrBackendTexture backendTex = dContext->createBackendTexture( |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 30 | kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kYes); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 31 | REPORTER_ASSERT(reporter, backendTex.isValid()); |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 32 | REPORTER_ASSERT(reporter, backendTex.isProtected()); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 33 | |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 34 | SkSurfaceProps surfaceProps = SkSurfaceProps(0, SkSurfaceProps::kLegacyFontHost_InitType); |
Greg Daniel | dd68b78 | 2020-05-12 14:17:44 -0400 | [diff] [blame] | 35 | sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture( |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 36 | dContext, backendTex, kTopLeft_GrSurfaceOrigin, 1, |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 37 | kRGBA_8888_SkColorType, nullptr, &surfaceProps); |
| 38 | REPORTER_ASSERT(reporter, surface); |
| 39 | return surface; |
| 40 | } |
| 41 | |
| 42 | DEF_GPUTEST(VkProtectedContext_CreateNonprotectedContext, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 43 | auto nonprotectedTestHelper = std::make_unique<VkTestHelper>(false); |
| 44 | REPORTER_ASSERT(reporter, nonprotectedTestHelper->init()); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 45 | } |
| 46 | |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 47 | DEF_GPUTEST(VkProtectedContext_CreateProtectedContext, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 48 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 49 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 50 | return; |
| 51 | } |
| 52 | } |
| 53 | |
| 54 | DEF_GPUTEST(VkProtectedContext_CreateProtectedSkSurface, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 55 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 56 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 57 | return; |
| 58 | } |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 59 | |
| 60 | auto dContext = protectedTestHelper->directContext(); |
| 61 | REPORTER_ASSERT(reporter, dContext != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 62 | |
| 63 | const int kW = 8; |
| 64 | const int kH = 8; |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 65 | GrBackendTexture backendTex = dContext->createBackendTexture(kW, kH, kRGBA_8888_SkColorType, |
| 66 | GrMipMapped::kNo, |
| 67 | GrRenderable::kNo, |
| 68 | GrProtected::kYes); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 69 | REPORTER_ASSERT(reporter, backendTex.isValid()); |
| 70 | REPORTER_ASSERT(reporter, backendTex.isProtected()); |
| 71 | |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 72 | SkSurfaceProps surfaceProps = SkSurfaceProps(0, SkSurfaceProps::kLegacyFontHost_InitType); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 73 | sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTextureAsRenderTarget( |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 74 | dContext, backendTex, kTopLeft_GrSurfaceOrigin, 1, |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 75 | kRGBA_8888_SkColorType, nullptr, &surfaceProps); |
| 76 | REPORTER_ASSERT(reporter, surface); |
| 77 | |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 78 | dContext->deleteBackendTexture(backendTex); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 79 | } |
| 80 | |
| 81 | DEF_GPUTEST(VkProtectedContext_CreateNonprotectedTextureInProtectedContext, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 82 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 83 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 84 | return; |
| 85 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 86 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 87 | |
| 88 | const int kW = 8; |
| 89 | const int kH = 8; |
| 90 | GrBackendTexture backendTex = |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 91 | protectedTestHelper->directContext()->createBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 92 | kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo, |
| 93 | GrProtected::kNo); |
| 94 | REPORTER_ASSERT(reporter, !backendTex.isValid()); |
| 95 | } |
| 96 | |
| 97 | DEF_GPUTEST(VkProtectedContext_CreateProtectedTextureInNonprotectedContext, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 98 | auto protectedTestHelper = std::make_unique<VkTestHelper>(false); |
| 99 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 100 | return; |
| 101 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 102 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 103 | |
| 104 | const int kW = 8; |
| 105 | const int kH = 8; |
| 106 | GrBackendTexture backendTex = |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 107 | protectedTestHelper->directContext()->createBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 108 | kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo, |
| 109 | GrProtected::kYes); |
| 110 | REPORTER_ASSERT(reporter, !backendTex.isValid()); |
| 111 | } |
| 112 | |
| 113 | DEF_GPUTEST(VkProtectedContext_ReadFromProtectedSurface, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 114 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 115 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 116 | return; |
| 117 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 118 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 119 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 120 | auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 121 | REPORTER_ASSERT(reporter, surface); |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 122 | REPORTER_ASSERT(reporter, !surface->readPixels(SkImageInfo(), nullptr, 8, 0, 0)); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 123 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 124 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 125 | surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
| 126 | } |
| 127 | |
Emircan Uysaler | 7697476 | 2019-10-25 13:28:54 -0400 | [diff] [blame] | 128 | namespace { |
| 129 | |
| 130 | struct AsyncContext { |
| 131 | bool fCalled = false; |
| 132 | std::unique_ptr<const SkSurface::AsyncReadResult> fResult; |
| 133 | }; |
| 134 | |
| 135 | static void async_callback(void* c, std::unique_ptr<const SkSurface::AsyncReadResult> result) { |
| 136 | auto context = static_cast<AsyncContext*>(c); |
| 137 | context->fResult = std::move(result); |
| 138 | context->fCalled = true; |
| 139 | }; |
| 140 | |
| 141 | } // anonymous namespace |
| 142 | |
| 143 | DEF_GPUTEST(VkProtectedContext_AsyncReadFromProtectedSurface, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 144 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 145 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 7697476 | 2019-10-25 13:28:54 -0400 | [diff] [blame] | 146 | return; |
| 147 | } |
Emircan Uysaler | 7697476 | 2019-10-25 13:28:54 -0400 | [diff] [blame] | 148 | |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 149 | auto dContext = protectedTestHelper->directContext(); |
Robert Phillips | b27b38b | 2020-07-10 16:23:47 -0400 | [diff] [blame] | 150 | |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 151 | REPORTER_ASSERT(reporter, dContext != nullptr); |
Robert Phillips | b27b38b | 2020-07-10 16:23:47 -0400 | [diff] [blame] | 152 | |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 153 | auto surface = create_protected_sksurface(dContext, reporter); |
Emircan Uysaler | 7697476 | 2019-10-25 13:28:54 -0400 | [diff] [blame] | 154 | REPORTER_ASSERT(reporter, surface); |
| 155 | AsyncContext cbContext; |
| 156 | const auto image_info = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType, |
| 157 | SkColorSpace::MakeSRGB()); |
| 158 | surface->asyncRescaleAndReadPixelsYUV420(kIdentity_SkYUVColorSpace, SkColorSpace::MakeSRGB(), |
| 159 | image_info.bounds(), image_info.dimensions(), |
| 160 | SkSurface::RescaleGamma::kSrc, kNone_SkFilterQuality, |
| 161 | &async_callback, &cbContext); |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 162 | dContext->submit(); |
Emircan Uysaler | 7697476 | 2019-10-25 13:28:54 -0400 | [diff] [blame] | 163 | while (!cbContext.fCalled) { |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 164 | dContext->checkAsyncWorkCompletion(); |
Emircan Uysaler | 7697476 | 2019-10-25 13:28:54 -0400 | [diff] [blame] | 165 | } |
| 166 | REPORTER_ASSERT(reporter, !cbContext.fResult); |
| 167 | |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 168 | dContext->deleteBackendTexture( |
Robert Phillips | b27b38b | 2020-07-10 16:23:47 -0400 | [diff] [blame] | 169 | surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
Emircan Uysaler | 7697476 | 2019-10-25 13:28:54 -0400 | [diff] [blame] | 170 | } |
| 171 | |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 172 | DEF_GPUTEST(VkProtectedContext_DrawRectangle, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 173 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 174 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 175 | return; |
| 176 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 177 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 178 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 179 | auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 180 | REPORTER_ASSERT(reporter, surface); |
| 181 | SkCanvas* canvas = surface->getCanvas(); |
| 182 | REPORTER_ASSERT(reporter, canvas); |
| 183 | SkPaint paint; |
| 184 | paint.setColor(SK_ColorBLACK); |
| 185 | canvas->drawRect(SkRect::MakeWH(4, 4), paint); |
| 186 | |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 187 | surface->flush(); |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 188 | protectedTestHelper->directContext()->submit(true); |
| 189 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 190 | surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
| 191 | } |
| 192 | |
| 193 | DEF_GPUTEST(VkProtectedContext_DrawRectangleWithAntiAlias, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 194 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 195 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 196 | return; |
| 197 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 198 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 199 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 200 | auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 201 | REPORTER_ASSERT(reporter, surface); |
| 202 | SkCanvas* canvas = surface->getCanvas(); |
| 203 | REPORTER_ASSERT(reporter, canvas); |
| 204 | SkPaint paint; |
| 205 | paint.setColor(SK_ColorBLACK); |
| 206 | paint.setAntiAlias(true); |
| 207 | canvas->drawRect(SkRect::MakeWH(4, 4), paint); |
| 208 | |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 209 | surface->flush(); |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 210 | protectedTestHelper->directContext()->submit(true); |
| 211 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 212 | surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
| 213 | } |
| 214 | |
| 215 | DEF_GPUTEST(VkProtectedContext_DrawRectangleWithBlendMode, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 216 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 217 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 218 | return; |
| 219 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 220 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 221 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 222 | auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 223 | REPORTER_ASSERT(reporter, surface); |
| 224 | SkCanvas* canvas = surface->getCanvas(); |
| 225 | REPORTER_ASSERT(reporter, canvas); |
| 226 | SkPaint paint; |
| 227 | paint.setColor(SK_ColorBLACK); |
| 228 | paint.setBlendMode(SkBlendMode::kColorDodge); |
| 229 | canvas->drawRect(SkRect::MakeWH(4, 4), paint); |
| 230 | |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 231 | surface->flush(); |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 232 | protectedTestHelper->directContext()->submit(true); |
| 233 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 234 | surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
| 235 | } |
| 236 | |
| 237 | DEF_GPUTEST(VkProtectedContext_DrawRectangleWithFilter, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 238 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 239 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 240 | return; |
| 241 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 242 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 243 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 244 | auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 245 | REPORTER_ASSERT(reporter, surface); |
| 246 | SkCanvas* canvas = surface->getCanvas(); |
| 247 | REPORTER_ASSERT(reporter, canvas); |
| 248 | SkPaint paint; |
| 249 | paint.setColor(SK_ColorBLACK); |
| 250 | paint.setStyle(SkPaint::kFill_Style); |
| 251 | paint.setMaskFilter(SkMaskFilter::MakeBlur( |
| 252 | SkBlurStyle::kOuter_SkBlurStyle, 1.1f)); |
| 253 | canvas->drawRect(SkRect::MakeWH(4, 4), paint); |
| 254 | |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 255 | surface->flush(); |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 256 | protectedTestHelper->directContext()->submit(true); |
| 257 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 258 | surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
| 259 | } |
| 260 | |
| 261 | DEF_GPUTEST(VkProtectedContext_DrawThinPath, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 262 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 263 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 264 | return; |
| 265 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 266 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 267 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 268 | auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 269 | REPORTER_ASSERT(reporter, surface); |
| 270 | SkCanvas* canvas = surface->getCanvas(); |
| 271 | REPORTER_ASSERT(reporter, canvas); |
| 272 | SkPaint paint; |
| 273 | paint.setColor(SK_ColorBLACK); |
| 274 | paint.setStyle(SkPaint::kStroke_Style); |
| 275 | paint.setAntiAlias(true); |
| 276 | paint.setStrokeWidth(.4f); |
| 277 | canvas->drawPath(SkPath().moveTo(4, 4).lineTo(6, 6), paint); |
| 278 | |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 279 | surface->flush(); |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 280 | protectedTestHelper->directContext()->submit(true); |
| 281 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 282 | surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
| 283 | } |
| 284 | |
| 285 | DEF_GPUTEST(VkProtectedContext_SaveLayer, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 286 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 287 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 288 | return; |
| 289 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 290 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 291 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 292 | auto surface = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 293 | REPORTER_ASSERT(reporter, surface); |
| 294 | SkCanvas* canvas = surface->getCanvas(); |
| 295 | REPORTER_ASSERT(reporter, canvas); |
| 296 | canvas->saveLayer(nullptr, nullptr); |
| 297 | SkPaint paint; |
| 298 | paint.setColor(SK_ColorBLACK); |
| 299 | canvas->drawRect(SkRect::MakeWH(4, 4), paint); |
| 300 | canvas->restore(); |
| 301 | |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 302 | surface->flush(); |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 303 | protectedTestHelper->directContext()->submit(true); |
| 304 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 305 | surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
| 306 | } |
| 307 | |
| 308 | |
| 309 | DEF_GPUTEST(VkProtectedContext_DrawProtectedImageOnProtectedSurface, reporter, options) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 310 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 311 | if (!protectedTestHelper->init()) { |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 312 | return; |
| 313 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 314 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 315 | |
| 316 | // Create protected image. |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 317 | auto surface1 = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 318 | REPORTER_ASSERT(reporter, surface1); |
| 319 | auto image = surface1->makeImageSnapshot(); |
| 320 | REPORTER_ASSERT(reporter, image); |
| 321 | |
| 322 | // Create protected canvas. |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 323 | auto surface2 = create_protected_sksurface(protectedTestHelper->directContext(), reporter); |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 324 | REPORTER_ASSERT(reporter, surface2); |
| 325 | SkCanvas* canvas = surface2->getCanvas(); |
| 326 | REPORTER_ASSERT(reporter, canvas); |
| 327 | |
| 328 | canvas->drawImage(image, 0, 0); |
| 329 | |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 330 | surface1->flush(); |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 331 | protectedTestHelper->directContext()->submit(true); |
| 332 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 333 | surface1->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 334 | surface2->flush(); |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 335 | protectedTestHelper->directContext()->submit(true); |
| 336 | protectedTestHelper->directContext()->deleteBackendTexture( |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 337 | surface2->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess)); |
| 338 | } |
| 339 | |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 340 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 341 | // Test out DDLs using a protected Vulkan context |
| 342 | |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 343 | void DDLMakeRenderTargetTestImpl(GrDirectContext*, skiatest::Reporter*); |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 344 | |
| 345 | DEF_GPUTEST(VkProtectedContext_DDLMakeRenderTargetTest, reporter, ctxInfo) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 346 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 347 | if (!protectedTestHelper->init()) { |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 348 | return; |
| 349 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 350 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 351 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 352 | DDLMakeRenderTargetTestImpl(protectedTestHelper->directContext(), reporter); |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 353 | } |
| 354 | |
Robert Phillips | c8ae494 | 2020-07-20 10:56:01 -0400 | [diff] [blame] | 355 | void DDLSurfaceCharacterizationTestImpl(GrDirectContext*, skiatest::Reporter*); |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 356 | |
| 357 | DEF_GPUTEST(VkProtectedContext_DDLSurfaceCharacterizationTest, reporter, ctxInfo) { |
Robert Phillips | 0d6ce7c | 2020-06-11 08:51:50 -0400 | [diff] [blame] | 358 | auto protectedTestHelper = std::make_unique<VkTestHelper>(true); |
| 359 | if (!protectedTestHelper->init()) { |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 360 | return; |
| 361 | } |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 362 | REPORTER_ASSERT(reporter, protectedTestHelper->directContext() != nullptr); |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 363 | |
Robert Phillips | 2a4acf3 | 2020-07-06 15:50:15 -0400 | [diff] [blame] | 364 | DDLSurfaceCharacterizationTestImpl(protectedTestHelper->directContext(), reporter); |
Robert Phillips | 3cd5432 | 2019-07-10 09:28:59 -0400 | [diff] [blame] | 365 | } |
| 366 | |
Emircan Uysaler | 23ca4e7 | 2019-06-24 10:53:09 -0400 | [diff] [blame] | 367 | #endif // SK_SUPPORT_GPU && defined(SK_VULKAN) |