• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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"
23  #include "tools/gpu/vk/VkTestUtils.h"
24  
25  namespace {
26  
27  #define DECLARE_VK_PROC(name) PFN_vk##name fVk##name
28  
29  #define ACQUIRE_INST_VK_PROC(name)                                                           \
30      fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, fBackendContext.fInstance,\
31                                                         VK_NULL_HANDLE));                     \
32      if (fVk##name == nullptr) {                                                              \
33          ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name);            \
34          return false;                                                                        \
35      }
36  
37  #define ACQUIRE_DEVICE_VK_PROC(name)                                                          \
38      fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, VK_NULL_HANDLE, fDevice)); \
39      if (fVk##name == nullptr) {                                                               \
40          ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name);             \
41          return false;                                                                         \
42      }
43  
44  class VulkanTestHelper {
45  public:
VulkanTestHelper(bool isProtected)46      VulkanTestHelper(bool isProtected) : fIsProtected(isProtected) {}
47  
~VulkanTestHelper()48      ~VulkanTestHelper() {
49          cleanup();
50      }
51  
52      bool init(skiatest::Reporter* reporter);
53  
grContext()54      GrContext* grContext() { return fGrContext.get(); }
55  
56      sk_sp<SkSurface> createSkSurface(skiatest::Reporter* reporter);
57  
58     private:
59      void cleanup();
60  
61      DECLARE_VK_PROC(DestroyInstance);
62      DECLARE_VK_PROC(DeviceWaitIdle);
63      DECLARE_VK_PROC(DestroyDevice);
64  
65      bool fIsProtected = false;
66      VkDevice fDevice = VK_NULL_HANDLE;
67  
68      GrVkExtensions* fExtensions = nullptr;
69      VkPhysicalDeviceFeatures2* fFeatures = nullptr;
70      VkDebugReportCallbackEXT fDebugCallback = VK_NULL_HANDLE;
71      PFN_vkDestroyDebugReportCallbackEXT fDestroyDebugCallback = nullptr;
72      GrVkBackendContext fBackendContext;
73      sk_sp<GrContext> fGrContext;
74  };
75  
76  } // namespace
77  
init(skiatest::Reporter * reporter)78  bool VulkanTestHelper::init(skiatest::Reporter* reporter) {
79      PFN_vkGetInstanceProcAddr instProc;
80      PFN_vkGetDeviceProcAddr devProc;
81      if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc, &devProc)) {
82          return false;
83      }
84      auto getProc = [&instProc, &devProc](const char* proc_name,
85                                           VkInstance instance, VkDevice device) {
86          if (device != VK_NULL_HANDLE) {
87              return devProc(device, proc_name);
88          }
89          return instProc(instance, proc_name);
90      };
91  
92      fExtensions = new GrVkExtensions();
93      fFeatures = new VkPhysicalDeviceFeatures2;
94      memset(fFeatures, 0, sizeof(VkPhysicalDeviceFeatures2));
95      fFeatures->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
96      fFeatures->pNext = nullptr;
97  
98      fBackendContext.fInstance = VK_NULL_HANDLE;
99      fBackendContext.fDevice = VK_NULL_HANDLE;
100  
101      if (!sk_gpu_test::CreateVkBackendContext(getProc, &fBackendContext, fExtensions,
102                                               fFeatures, &fDebugCallback, nullptr,
103                                               sk_gpu_test::CanPresentFn(), fIsProtected)) {
104          return false;
105      }
106      fDevice = fBackendContext.fDevice;
107  
108      if (fDebugCallback != VK_NULL_HANDLE) {
109          fDestroyDebugCallback = (PFN_vkDestroyDebugReportCallbackEXT) instProc(
110                  fBackendContext.fInstance, "vkDestroyDebugReportCallbackEXT");
111      }
112      ACQUIRE_INST_VK_PROC(DestroyInstance)
113      ACQUIRE_INST_VK_PROC(DeviceWaitIdle)
114      ACQUIRE_INST_VK_PROC(DestroyDevice)
115  
116      fGrContext = GrContext::MakeVulkan(fBackendContext);
117      if (!fGrContext) {
118          return false;
119      }
120  
121      return true;
122  }
123  
cleanup()124  void VulkanTestHelper::cleanup() {
125      fGrContext.reset();
126  
127      fBackendContext.fMemoryAllocator.reset();
128      if (fDevice != VK_NULL_HANDLE) {
129          fVkDeviceWaitIdle(fDevice);
130          fVkDestroyDevice(fDevice, nullptr);
131          fDevice = VK_NULL_HANDLE;
132      }
133      if (fDebugCallback != VK_NULL_HANDLE) {
134          fDestroyDebugCallback(fBackendContext.fInstance, fDebugCallback, nullptr);
135      }
136  
137      if (fBackendContext.fInstance != VK_NULL_HANDLE) {
138          fVkDestroyInstance(fBackendContext.fInstance, nullptr);
139          fBackendContext.fInstance = VK_NULL_HANDLE;
140      }
141  
142      delete fExtensions;
143  
144      sk_gpu_test::FreeVulkanFeaturesStructs(fFeatures);
145      delete fFeatures;
146  }
147  
createSkSurface(skiatest::Reporter * reporter)148  sk_sp<SkSurface> VulkanTestHelper::createSkSurface(skiatest::Reporter* reporter) {
149      const int kW = 8;
150      const int kH = 8;
151      GrBackendTexture backendTex = grContext()->createBackendTexture(
152          kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo,
153          fIsProtected ? GrProtected::kYes : GrProtected::kNo);
154      REPORTER_ASSERT(reporter, backendTex.isValid());
155      REPORTER_ASSERT(reporter, backendTex.isProtected() == fIsProtected);
156  
157      SkSurfaceProps surfaceProps =
158          SkSurfaceProps(0, SkSurfaceProps::kLegacyFontHost_InitType);
159      sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTextureAsRenderTarget(
160          grContext(), backendTex, kTopLeft_GrSurfaceOrigin, 1,
161          kRGBA_8888_SkColorType, nullptr, &surfaceProps);
162      REPORTER_ASSERT(reporter, surface);
163      return surface;
164  }
165  
DEF_GPUTEST(VkProtectedContext_CreateNonprotectedContext,reporter,options)166  DEF_GPUTEST(VkProtectedContext_CreateNonprotectedContext, reporter, options) {
167      auto nonprotectedTestHelper = std::make_unique<VulkanTestHelper>(false);
168      REPORTER_ASSERT(reporter, nonprotectedTestHelper->init(reporter));
169  }
170  
171  
DEF_GPUTEST(VkProtectedContext_CreateProtectedContext,reporter,options)172  DEF_GPUTEST(VkProtectedContext_CreateProtectedContext, reporter, options) {
173      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
174      if (!protectedTestHelper->init(reporter)) {
175          return;
176      }
177  }
178  
DEF_GPUTEST(VkProtectedContext_CreateProtectedSkSurface,reporter,options)179  DEF_GPUTEST(VkProtectedContext_CreateProtectedSkSurface, reporter, options) {
180      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
181      if (!protectedTestHelper->init(reporter)) {
182          return;
183      }
184      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
185  
186      const int kW = 8;
187      const int kH = 8;
188      GrBackendTexture backendTex =
189          protectedTestHelper->grContext()->createBackendTexture(
190              kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo,
191              GrProtected::kYes);
192      REPORTER_ASSERT(reporter, backendTex.isValid());
193      REPORTER_ASSERT(reporter, backendTex.isProtected());
194  
195      SkSurfaceProps surfaceProps =
196          SkSurfaceProps(0, SkSurfaceProps::kLegacyFontHost_InitType);
197      sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTextureAsRenderTarget(
198          protectedTestHelper->grContext(), backendTex, kTopLeft_GrSurfaceOrigin, 1,
199          kRGBA_8888_SkColorType, nullptr, &surfaceProps);
200      REPORTER_ASSERT(reporter, surface);
201  
202      protectedTestHelper->grContext()->deleteBackendTexture(backendTex);
203  }
204  
DEF_GPUTEST(VkProtectedContext_CreateNonprotectedTextureInProtectedContext,reporter,options)205  DEF_GPUTEST(VkProtectedContext_CreateNonprotectedTextureInProtectedContext, reporter, options) {
206      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
207      if (!protectedTestHelper->init(reporter)) {
208          return;
209      }
210      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
211  
212      const int kW = 8;
213      const int kH = 8;
214      GrBackendTexture backendTex =
215          protectedTestHelper->grContext()->createBackendTexture(
216              kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo,
217              GrProtected::kNo);
218      REPORTER_ASSERT(reporter, !backendTex.isValid());
219  }
220  
DEF_GPUTEST(VkProtectedContext_CreateProtectedTextureInNonprotectedContext,reporter,options)221  DEF_GPUTEST(VkProtectedContext_CreateProtectedTextureInNonprotectedContext, reporter, options) {
222      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(false);
223      if (!protectedTestHelper->init(reporter)) {
224          return;
225      }
226      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
227  
228      const int kW = 8;
229      const int kH = 8;
230      GrBackendTexture backendTex =
231          protectedTestHelper->grContext()->createBackendTexture(
232              kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo,
233              GrProtected::kYes);
234      REPORTER_ASSERT(reporter, !backendTex.isValid());
235  }
236  
DEF_GPUTEST(VkProtectedContext_ReadFromProtectedSurface,reporter,options)237  DEF_GPUTEST(VkProtectedContext_ReadFromProtectedSurface, reporter, options) {
238      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
239      if (!protectedTestHelper->init(reporter)) {
240          return;
241      }
242      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
243  
244      auto surface = protectedTestHelper->createSkSurface(reporter);
245      REPORTER_ASSERT(reporter, surface);
246      REPORTER_ASSERT(reporter,
247                      !surface->readPixels(SkImageInfo(), nullptr, 8, 0, 0));
248  
249      protectedTestHelper->grContext()->deleteBackendTexture(
250          surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
251  }
252  
253  namespace {
254  
255  struct AsyncContext {
256      bool fCalled = false;
257      std::unique_ptr<const SkSurface::AsyncReadResult> fResult;
258  };
259  
async_callback(void * c,std::unique_ptr<const SkSurface::AsyncReadResult> result)260  static void async_callback(void* c, std::unique_ptr<const SkSurface::AsyncReadResult> result) {
261      auto context = static_cast<AsyncContext*>(c);
262      context->fResult = std::move(result);
263      context->fCalled = true;
264  };
265  
266  }  // anonymous namespace
267  
DEF_GPUTEST(VkProtectedContext_AsyncReadFromProtectedSurface,reporter,options)268  DEF_GPUTEST(VkProtectedContext_AsyncReadFromProtectedSurface, reporter, options) {
269      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
270      if (!protectedTestHelper->init(reporter)) {
271          return;
272      }
273      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
274  
275      auto surface = protectedTestHelper->createSkSurface(reporter);
276      REPORTER_ASSERT(reporter, surface);
277      AsyncContext cbContext;
278      const auto image_info = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType,
279                                        SkColorSpace::MakeSRGB());
280      surface->asyncRescaleAndReadPixelsYUV420(kIdentity_SkYUVColorSpace, SkColorSpace::MakeSRGB(),
281                                               image_info.bounds(), image_info.dimensions(),
282                                               SkSurface::RescaleGamma::kSrc, kNone_SkFilterQuality,
283                                               &async_callback, &cbContext);
284      while (!cbContext.fCalled) {
285          surface->getCanvas()->getGrContext()->checkAsyncWorkCompletion();
286      }
287      REPORTER_ASSERT(reporter, !cbContext.fResult);
288  
289      protectedTestHelper->grContext()->deleteBackendTexture(
290          surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
291  }
292  
DEF_GPUTEST(VkProtectedContext_DrawRectangle,reporter,options)293  DEF_GPUTEST(VkProtectedContext_DrawRectangle, reporter, options) {
294      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
295      if (!protectedTestHelper->init(reporter)) {
296          return;
297      }
298      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
299  
300      auto surface = protectedTestHelper->createSkSurface(reporter);
301      REPORTER_ASSERT(reporter, surface);
302      SkCanvas* canvas = surface->getCanvas();
303      REPORTER_ASSERT(reporter, canvas);
304      SkPaint paint;
305      paint.setColor(SK_ColorBLACK);
306      canvas->drawRect(SkRect::MakeWH(4, 4), paint);
307  
308      GrFlushInfo flushInfo;
309      flushInfo.fFlags = kSyncCpu_GrFlushFlag;
310      surface->flush(SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo);
311      protectedTestHelper->grContext()->deleteBackendTexture(
312          surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
313  }
314  
DEF_GPUTEST(VkProtectedContext_DrawRectangleWithAntiAlias,reporter,options)315  DEF_GPUTEST(VkProtectedContext_DrawRectangleWithAntiAlias, reporter, options) {
316      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
317      if (!protectedTestHelper->init(reporter)) {
318          return;
319      }
320      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
321  
322      auto surface = protectedTestHelper->createSkSurface(reporter);
323      REPORTER_ASSERT(reporter, surface);
324      SkCanvas* canvas = surface->getCanvas();
325      REPORTER_ASSERT(reporter, canvas);
326      SkPaint paint;
327      paint.setColor(SK_ColorBLACK);
328      paint.setAntiAlias(true);
329      canvas->drawRect(SkRect::MakeWH(4, 4), paint);
330  
331      GrFlushInfo flushInfo;
332      flushInfo.fFlags = kSyncCpu_GrFlushFlag;
333      surface->flush(SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo);
334      protectedTestHelper->grContext()->deleteBackendTexture(
335          surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
336  }
337  
DEF_GPUTEST(VkProtectedContext_DrawRectangleWithBlendMode,reporter,options)338  DEF_GPUTEST(VkProtectedContext_DrawRectangleWithBlendMode, reporter, options) {
339      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
340      if (!protectedTestHelper->init(reporter)) {
341          return;
342      }
343      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
344  
345      auto surface = protectedTestHelper->createSkSurface(reporter);
346      REPORTER_ASSERT(reporter, surface);
347      SkCanvas* canvas = surface->getCanvas();
348      REPORTER_ASSERT(reporter, canvas);
349      SkPaint paint;
350      paint.setColor(SK_ColorBLACK);
351      paint.setBlendMode(SkBlendMode::kColorDodge);
352      canvas->drawRect(SkRect::MakeWH(4, 4), paint);
353  
354      GrFlushInfo flushInfo;
355      flushInfo.fFlags = kSyncCpu_GrFlushFlag;
356      surface->flush(SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo);
357      protectedTestHelper->grContext()->deleteBackendTexture(
358          surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
359  }
360  
DEF_GPUTEST(VkProtectedContext_DrawRectangleWithFilter,reporter,options)361  DEF_GPUTEST(VkProtectedContext_DrawRectangleWithFilter, reporter, options) {
362      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
363      if (!protectedTestHelper->init(reporter)) {
364          return;
365      }
366      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
367  
368      auto surface = protectedTestHelper->createSkSurface(reporter);
369      REPORTER_ASSERT(reporter, surface);
370      SkCanvas* canvas = surface->getCanvas();
371      REPORTER_ASSERT(reporter, canvas);
372      SkPaint paint;
373      paint.setColor(SK_ColorBLACK);
374      paint.setStyle(SkPaint::kFill_Style);
375      paint.setMaskFilter(SkMaskFilter::MakeBlur(
376            SkBlurStyle::kOuter_SkBlurStyle, 1.1f));
377      canvas->drawRect(SkRect::MakeWH(4, 4), paint);
378  
379      GrFlushInfo flushInfo;
380      flushInfo.fFlags = kSyncCpu_GrFlushFlag;
381      surface->flush(SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo);
382      protectedTestHelper->grContext()->deleteBackendTexture(
383          surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
384  }
385  
DEF_GPUTEST(VkProtectedContext_DrawThinPath,reporter,options)386  DEF_GPUTEST(VkProtectedContext_DrawThinPath, reporter, options) {
387      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
388      if (!protectedTestHelper->init(reporter)) {
389          return;
390      }
391      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
392  
393      auto surface = protectedTestHelper->createSkSurface(reporter);
394      REPORTER_ASSERT(reporter, surface);
395      SkCanvas* canvas = surface->getCanvas();
396      REPORTER_ASSERT(reporter, canvas);
397      SkPaint paint;
398      paint.setColor(SK_ColorBLACK);
399      paint.setStyle(SkPaint::kStroke_Style);
400      paint.setAntiAlias(true);
401      paint.setStrokeWidth(.4f);
402      canvas->drawPath(SkPath().moveTo(4, 4).lineTo(6, 6), paint);
403  
404      GrFlushInfo flushInfo;
405      flushInfo.fFlags = kSyncCpu_GrFlushFlag;
406      surface->flush(SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo);
407      protectedTestHelper->grContext()->deleteBackendTexture(
408          surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
409  }
410  
DEF_GPUTEST(VkProtectedContext_SaveLayer,reporter,options)411  DEF_GPUTEST(VkProtectedContext_SaveLayer, reporter, options) {
412      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
413      if (!protectedTestHelper->init(reporter)) {
414          return;
415      }
416      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
417  
418      auto surface = protectedTestHelper->createSkSurface(reporter);
419      REPORTER_ASSERT(reporter, surface);
420      SkCanvas* canvas = surface->getCanvas();
421      REPORTER_ASSERT(reporter, canvas);
422      canvas->saveLayer(nullptr, nullptr);
423      SkPaint paint;
424      paint.setColor(SK_ColorBLACK);
425      canvas->drawRect(SkRect::MakeWH(4, 4), paint);
426      canvas->restore();
427  
428      GrFlushInfo flushInfo;
429      flushInfo.fFlags = kSyncCpu_GrFlushFlag;
430      surface->flush(SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo);
431      protectedTestHelper->grContext()->deleteBackendTexture(
432          surface->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
433  }
434  
435  
DEF_GPUTEST(VkProtectedContext_DrawProtectedImageOnProtectedSurface,reporter,options)436  DEF_GPUTEST(VkProtectedContext_DrawProtectedImageOnProtectedSurface, reporter, options) {
437      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
438      if (!protectedTestHelper->init(reporter)) {
439          return;
440      }
441      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
442  
443      // Create protected image.
444      auto surface1 = protectedTestHelper->createSkSurface(reporter);
445      REPORTER_ASSERT(reporter, surface1);
446      auto image = surface1->makeImageSnapshot();
447      REPORTER_ASSERT(reporter, image);
448  
449      // Create protected canvas.
450      auto surface2 = protectedTestHelper->createSkSurface(reporter);
451      REPORTER_ASSERT(reporter, surface2);
452      SkCanvas* canvas = surface2->getCanvas();
453      REPORTER_ASSERT(reporter, canvas);
454  
455      canvas->drawImage(image, 0, 0);
456  
457      GrFlushInfo flushInfo;
458      flushInfo.fFlags = kSyncCpu_GrFlushFlag;
459      surface1->flush(SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo);
460      protectedTestHelper->grContext()->deleteBackendTexture(
461          surface1->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
462      surface2->flush(SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo);
463      protectedTestHelper->grContext()->deleteBackendTexture(
464          surface2->getBackendTexture(SkSurface::kFlushRead_BackendHandleAccess));
465  }
466  
467  //////////////////////////////////////////////////////////////////////////////////////////////////
468  // Test out DDLs using a protected Vulkan context
469  
470  void DDLMakeRenderTargetTestImpl(GrContext* context, skiatest::Reporter* reporter);
471  
DEF_GPUTEST(VkProtectedContext_DDLMakeRenderTargetTest,reporter,ctxInfo)472  DEF_GPUTEST(VkProtectedContext_DDLMakeRenderTargetTest, reporter, ctxInfo) {
473      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
474      if (!protectedTestHelper->init(reporter)) {
475          return;
476      }
477      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
478  
479      DDLMakeRenderTargetTestImpl(protectedTestHelper->grContext(), reporter);
480  }
481  
482  void DDLSurfaceCharacterizationTestImpl(GrContext* context, skiatest::Reporter* reporter);
483  
DEF_GPUTEST(VkProtectedContext_DDLSurfaceCharacterizationTest,reporter,ctxInfo)484  DEF_GPUTEST(VkProtectedContext_DDLSurfaceCharacterizationTest, reporter, ctxInfo) {
485      auto protectedTestHelper = std::make_unique<VulkanTestHelper>(true);
486      if (!protectedTestHelper->init(reporter)) {
487          return;
488      }
489      REPORTER_ASSERT(reporter, protectedTestHelper->grContext() != nullptr);
490  
491      DDLSurfaceCharacterizationTestImpl(protectedTestHelper->grContext(), reporter);
492  }
493  
494  #endif  // SK_SUPPORT_GPU && defined(SK_VULKAN)
495