Make more unit tests run on Vulkan

tests/ImageTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <functional>
 #include <initializer_list>
 #include "DMGpuSupport.h"
@@ skipping 158 matching lines @@
     decoded = SkImage::MakeFromEncoded(origEncoded, &ir);
     REPORTER_ASSERT(reporter, decoded);
     assert_equal(reporter, image, &ir, decoded.get());
 }
 
 DEF_TEST(ImageEncode, reporter) {
     test_encode(reporter, create_image().get());
 }
 
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, ctxInfo) {
     test_encode(reporter, create_gpu_image(ctxInfo.fGrContext).get());
 }
 #endif
 
 namespace {
 
 const char* kSerializedData = "serialized";
 
 class MockSerializer : public SkPixelSerializer {
 public:
@@ skipping 172 matching lines @@
 #include "SkBitmapCache.h"
 
 /*
  *  This tests the caching (and preemptive purge) of the raster equivalent of a gpu-image.
  *  We cache it for performance when drawing into a raster surface.
  *
  *  A cleaner test would know if each drawImage call triggered a read-back from the gpu,
  *  but we don't have that facility (at the moment) so we use a little internal knowledge
  *  of *how* the raster version is cached, and look for that.
  */
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkImage_Gpu2Cpu, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(c, reporter, ctxInfo) {
     SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
     sk_sp<SkImage> image(create_gpu_image(ctxInfo.fGrContext));
     const uint32_t uniqueID = image->uniqueID();
 
     auto surface(SkSurface::MakeRaster(info));
 
     // now we can test drawing a gpu-backed image into a cpu-backed surface
 
     {
         SkBitmap cachedBitmap;
@@ skipping 250 matching lines @@
         image = create_rasterproc_image(&dataHolder);
         test_legacy_bitmap(reporter, image.get(), mode);
         image.reset();
         REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
 
         image = create_codec_image();
         test_legacy_bitmap(reporter, image.get(), mode);
     }
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ImageLegacyBitmap_Gpu, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageLegacyBitmap_Gpu, reporter, ctxInfo) {
     const SkImage::LegacyBitmapMode modes[] = {
         SkImage::kRO_LegacyBitmapMode,
         SkImage::kRW_LegacyBitmapMode,
     };
     for (auto& mode : modes) {
         sk_sp<SkImage> image(create_gpu_image(ctxInfo.fGrContext));
         test_legacy_bitmap(reporter, image.get(), mode);
     }
 }
 #endif
@@ skipping 237 matching lines @@
                         otherContextInfo.fGrContext, buffer, budgeted));
                     REPORTER_ASSERT(reporter, !newImage2);
                     glContext->makeCurrent();
                 }
             }
             sk_free(buffer);
         }
     }
 }
 #endif