Merge "Snap for 11400057 from 850a9c245314ce364a8625feb458eaf7e18663b8 to simpleperf-release" into simpleperf-releasesimpleperf-release

18 files changed, 238 insertions, 100 deletions

diff --git a/include/gpu/vk/GrVkTypes.h b/include/gpu/vk/GrVkTypes.h
index 9d0a4c2c60..0c1547da3c 100644
--- a/include/gpu/vk/GrVkTypes.h
+++ b/include/gpu/vk/GrVkTypes.h
@@ -34,7 +34,10 @@ struct GrVkYcbcrConversionInfo {
     }
     bool operator!=(const GrVkYcbcrConversionInfo& that) const { return !(*this == that); }
 
-    bool isValid() const { return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; }
+    bool isValid() const {
+        return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY ||
+               fExternalFormat != 0;
+    }
 
     // Format of the source image. Must be set to VK_FORMAT_UNDEFINED for external images or
     // a valid image format otherwise.
diff --git a/src/gpu/ganesh/effects/GrAtlasedShaderHelpers.h b/src/gpu/ganesh/effects/GrAtlasedShaderHelpers.h
index 2a2fce7782..1e9ae1b5f1 100644
--- a/src/gpu/ganesh/effects/GrAtlasedShaderHelpers.h
+++ b/src/gpu/ganesh/effects/GrAtlasedShaderHelpers.h
@@ -90,11 +90,13 @@ static inline void append_multitexture_lookup(GrGeometryProcessor::ProgramImpl::
     // conditionally load from the indexed texture sampler
     for (int i = 0; i < numTextureSamplers-1; ++i) {
         args.fFragBuilder->codeAppendf("if (%s == %d) { %s = ", texIdx.fsIn(), i, colorName);
-        args.fFragBuilder->appendTextureLookup(args.fTexSamplers[i], coordName);
+        args.fFragBuilder->appendTextureLookup(args.fTexSamplers[i],
+                                               coordName);
         args.fFragBuilder->codeAppend("; } else ");
     }
     args.fFragBuilder->codeAppendf("{ %s = ", colorName);
-    args.fFragBuilder->appendTextureLookup(args.fTexSamplers[numTextureSamplers - 1], coordName);
+    args.fFragBuilder->appendTextureLookup(args.fTexSamplers[numTextureSamplers - 1],
+                                           coordName);
     args.fFragBuilder->codeAppend("; }");
 }
 
diff --git a/src/gpu/ganesh/effects/GrBitmapTextGeoProc.cpp b/src/gpu/ganesh/effects/GrBitmapTextGeoProc.cpp
index 59e4870808..4168152af2 100644
--- a/src/gpu/ganesh/effects/GrBitmapTextGeoProc.cpp
+++ b/src/gpu/ganesh/effects/GrBitmapTextGeoProc.cpp
@@ -12,6 +12,7 @@
 #include "src/gpu/ganesh/GrShaderCaps.h"
 #include "src/gpu/ganesh/GrTexture.h"
 #include "src/gpu/ganesh/effects/GrAtlasedShaderHelpers.h"
+#include "src/gpu/ganesh/glsl/GrGLSLColorSpaceXformHelper.h"
 #include "src/gpu/ganesh/glsl/GrGLSLFragmentShaderBuilder.h"
 #include "src/gpu/ganesh/glsl/GrGLSLProgramDataManager.h"
 #include "src/gpu/ganesh/glsl/GrGLSLUniformHandler.h"
@@ -42,6 +43,7 @@ public:
         }
 
         SetTransform(pdman, shaderCaps, fLocalMatrixUniform, btgp.fLocalMatrix, &fLocalMatrix);
+        fColorSpaceXformHelper.setData(pdman, btgp.fColorSpaceXform.get());
     }
 
 private:
@@ -52,6 +54,9 @@ private:
         GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
         GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
+        fColorSpaceXformHelper.emitCode(uniformHandler,
+                                        btgp.fColorSpaceXform.get());
+
         // emit attributes
         varyingHandler->emitAttributes(btgp);
 
@@ -91,6 +96,11 @@ private:
         fragBuilder->codeAppend("half4 texColor;");
         append_multitexture_lookup(args, btgp.numTextureSamplers(),
                                    texIdx, uv.fsIn(), "texColor");
+        if (!fColorSpaceXformHelper.isNoop()) {
+            fragBuilder->codeAppend("texColor = ");
+            fragBuilder->appendColorGamutXform("texColor", &fColorSpaceXformHelper);
+            fragBuilder->codeAppend(";");
+        }
 
         if (btgp.fMaskFormat == MaskFormat::kARGB) {
             // modulate by color
@@ -109,6 +119,8 @@ private:
     UniformHandle fColorUniform;
     UniformHandle fAtlasDimensionsInvUniform;
     UniformHandle fLocalMatrixUniform;
+
+    GrGLSLColorSpaceXformHelper fColorSpaceXformHelper;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -116,6 +128,7 @@ private:
 GrBitmapTextGeoProc::GrBitmapTextGeoProc(const GrShaderCaps& caps,
                                          const SkPMColor4f& color,
                                          bool wideColor,
+                                         sk_sp<GrColorSpaceXform> colorSpaceXform,
                                          const GrSurfaceProxyView* views,
                                          int numActiveViews,
                                          GrSamplerState params,
@@ -124,6 +137,7 @@ GrBitmapTextGeoProc::GrBitmapTextGeoProc(const GrShaderCaps& caps,
                                          bool usesW)
         : INHERITED(kGrBitmapTextGeoProc_ClassID)
         , fColor(color)
+        , fColorSpaceXform(std::move(colorSpaceXform))
         , fLocalMatrix(localMatrix)
         , fUsesW(usesW)
         , fMaskFormat(format) {
@@ -187,6 +201,7 @@ void GrBitmapTextGeoProc::addToKey(const GrShaderCaps& caps, skgpu::KeyBuilder*
                ProgramImpl::ComputeMatrixKey(caps, fLocalMatrix),
                "localMatrixType");
     b->add32(this->numTextureSamplers(), "numTextures");
+    b->add32(GrColorSpaceXform::XformKey(fColorSpaceXform.get()), "colorSpaceXform");
 }
 
 std::unique_ptr<GrGeometryProcessor::ProgramImpl> GrBitmapTextGeoProc::makeProgramImpl(
@@ -229,7 +244,7 @@ GrGeometryProcessor* GrBitmapTextGeoProc::TestCreate(GrProcessorTestData* d) {
     bool usesW = d->fRandom->nextBool();
     return GrBitmapTextGeoProc::Make(d->allocator(), *d->caps()->shaderCaps(),
                                      SkPMColor4f::FromBytes_RGBA(color),
-                                     wideColor,
+                                     wideColor, /*colorSpaceXform=*/nullptr,
                                      &view, 1, samplerState, format,
                                      localMatrix, usesW);
 }
diff --git a/src/gpu/ganesh/effects/GrBitmapTextGeoProc.h b/src/gpu/ganesh/effects/GrBitmapTextGeoProc.h
index b406da3e23..a0cfcada3e 100644
--- a/src/gpu/ganesh/effects/GrBitmapTextGeoProc.h
+++ b/src/gpu/ganesh/effects/GrBitmapTextGeoProc.h
@@ -8,12 +8,16 @@
 #ifndef GrBitmapTextGeoProc_DEFINED
 #define GrBitmapTextGeoProc_DEFINED
 
+#include "include/core/SkRefCnt.h"
 #include "src/base/SkArenaAlloc.h"
 #include "src/gpu/AtlasTypes.h"
+#include "src/gpu/ganesh/GrColorSpaceXform.h"
 #include "src/gpu/ganesh/GrGeometryProcessor.h"
 #include "src/gpu/ganesh/GrProcessor.h"
 #include "src/gpu/ganesh/GrProcessorUnitTest.h"
 
+#include <utility>
+
 class GrGLBitmapTextGeoProc;
 class GrInvariantOutput;
 class GrSurfaceProxyView;
@@ -31,6 +35,7 @@ public:
                                      const GrShaderCaps& caps,
                                      const SkPMColor4f& color,
                                      bool wideColor,
+                                     sk_sp<GrColorSpaceXform> colorSpaceXform,
                                      const GrSurfaceProxyView* views,
                                      int numActiveViews,
                                      GrSamplerState p,
@@ -38,7 +43,8 @@ public:
                                      const SkMatrix& localMatrix,
                                      bool usesW) {
         return arena->make([&](void* ptr) {
-            return new (ptr) GrBitmapTextGeoProc(caps, color, wideColor, views, numActiveViews,
+            return new (ptr) GrBitmapTextGeoProc(caps, color, wideColor, std::move(colorSpaceXform),
+                                                 views, numActiveViews,
                                                  p, format, localMatrix, usesW);
         });
     }
@@ -57,6 +63,7 @@ private:
     class Impl;
 
     GrBitmapTextGeoProc(const GrShaderCaps&, const SkPMColor4f&, bool wideColor,
+                        sk_sp<GrColorSpaceXform> colorSpaceXform,
                         const GrSurfaceProxyView* views, int numViews, GrSamplerState params,
                         skgpu::MaskFormat format, const SkMatrix& localMatrix, bool usesW);
 
@@ -64,15 +71,16 @@ private:
 
     const TextureSampler& onTextureSampler(int i) const override { return fTextureSamplers[i]; }
 
-    SkPMColor4f      fColor;
-    SkMatrix         fLocalMatrix;
-    bool             fUsesW;
-    SkISize          fAtlasDimensions;  // dimensions for all textures used with fTextureSamplers[].
-    TextureSampler   fTextureSamplers[kMaxTextures];
-    Attribute        fInPosition;
-    Attribute        fInColor;
-    Attribute        fInTextureCoords;
-    skgpu::MaskFormat     fMaskFormat;
+    SkPMColor4f              fColor;
+    sk_sp<GrColorSpaceXform> fColorSpaceXform;
+    SkMatrix                 fLocalMatrix;
+    bool                     fUsesW;
+    SkISize                  fAtlasDimensions;  // dims for all textures used with fTextureSamplers
+    TextureSampler           fTextureSamplers[kMaxTextures];
+    Attribute                fInPosition;
+    Attribute                fInColor;
+    Attribute                fInTextureCoords;
+    skgpu::MaskFormat        fMaskFormat;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST
 
diff --git a/src/gpu/ganesh/ops/AtlasTextOp.cpp b/src/gpu/ganesh/ops/AtlasTextOp.cpp
index ae222adb51..3e6a7c29d2 100644
--- a/src/gpu/ganesh/ops/AtlasTextOp.cpp
+++ b/src/gpu/ganesh/ops/AtlasTextOp.cpp
@@ -15,6 +15,7 @@
 #include "src/core/SkMatrixProvider.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/gpu/ganesh/GrCaps.h"
+#include "src/gpu/ganesh/GrColorSpaceXform.h"
 #include "src/gpu/ganesh/GrMemoryPool.h"
 #include "src/gpu/ganesh/GrOpFlushState.h"
 #include "src/gpu/ganesh/GrRecordingContextPriv.h"
@@ -70,6 +71,7 @@ AtlasTextOp::AtlasTextOp(MaskType maskType,
                          int glyphCount,
                          SkRect deviceRect,
                          Geometry* geo,
+                         const GrColorInfo& dstColorInfo,
                          GrPaint&& paint)
         : INHERITED{ClassID()}
         , fProcessors(std::move(paint))
@@ -85,6 +87,10 @@ AtlasTextOp::AtlasTextOp(MaskType maskType,
     // We don't have tight bounds on the glyph paths in device space. For the purposes of bounds
     // we treat this as a set of non-AA rects rendered with a texture.
     this->setBounds(deviceRect, HasAABloat::kNo, IsHairline::kNo);
+    if (maskType == MaskType::kColorBitmap) {
+        // We assume that color emoji use the sRGB colorspace
+        fColorSpaceXform = dstColorInfo.refColorSpaceXformFromSRGB();
+    }
 }
 
 AtlasTextOp::AtlasTextOp(MaskType maskType,
@@ -259,7 +265,8 @@ void AtlasTextOp::onPrepareDraws(GrMeshDrawTarget* target) {
         // color, so we can use the first's without worry.
         flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
                 target->allocator(), *target->caps().shaderCaps(), fHead->fColor,
-                false, views, numActiveViews, filter, maskFormat, localMatrix, fHasPerspective);
+                /*wideColor=*/false, fColorSpaceXform, views, numActiveViews, filter,
+                maskFormat, localMatrix, fHasPerspective);
     }
 
     const int vertexStride = (int)flushInfo.fGeometryProcessor->vertexStride();
diff --git a/src/gpu/ganesh/ops/AtlasTextOp.h b/src/gpu/ganesh/ops/AtlasTextOp.h
index 1f73e70b44..964afa58e4 100644
--- a/src/gpu/ganesh/ops/AtlasTextOp.h
+++ b/src/gpu/ganesh/ops/AtlasTextOp.h
@@ -9,6 +9,7 @@
 #define skgpu_ganesh_AtlasTextOp_DEFINED
 
 #include "src/gpu/AtlasTypes.h"
+#include "src/gpu/ganesh/GrColorSpaceXform.h"
 #include "src/gpu/ganesh/effects/GrDistanceFieldGeoProc.h"
 #include "src/gpu/ganesh/ops/GrMeshDrawOp.h"
 #include "src/text/gpu/TextBlob.h"
@@ -132,6 +133,7 @@ private:
                 int glyphCount,
                 SkRect deviceRect,
                 Geometry* geo,
+                const GrColorInfo& dstColorInfo,
                 GrPaint&& paint);
 
     AtlasTextOp(MaskType maskType,
@@ -254,6 +256,9 @@ private:
     static_assert(kInvalid_DistanceFieldEffectFlag <= (1 << 9), "DFGP Flags do not fit in 10 bits");
 #endif
 
+    // Only needed for color emoji
+    sk_sp<GrColorSpaceXform> fColorSpaceXform;
+
     // Only used for distance fields; per-channel luminance for LCD, or gamma-corrected luminance
     // for single-channel distance fields.
     const SkColor fLuminanceColor{0};
diff --git a/src/gpu/ganesh/ops/SmallPathRenderer.cpp b/src/gpu/ganesh/ops/SmallPathRenderer.cpp
index 4245160363..faf09b3ce6 100644
--- a/src/gpu/ganesh/ops/SmallPathRenderer.cpp
+++ b/src/gpu/ganesh/ops/SmallPathRenderer.cpp
@@ -193,8 +193,8 @@ private:
         } else {
             flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
                     target->allocator(), *target->caps().shaderCaps(), this->color(), fWideColor,
-                    views, numActiveProxies, GrSamplerState::Filter::kNearest,
-                    MaskFormat::kA8, invert, false);
+                    /*colorSpaceXform=*/nullptr, views, numActiveProxies,
+                    GrSamplerState::Filter::kNearest, MaskFormat::kA8, invert, false);
         }
 
         // allocate vertices
diff --git a/src/gpu/ganesh/vk/GrVkBuffer.cpp b/src/gpu/ganesh/vk/GrVkBuffer.cpp
index 37c37fb4f2..7157ed9fd6 100644
--- a/src/gpu/ganesh/vk/GrVkBuffer.cpp
+++ b/src/gpu/ganesh/vk/GrVkBuffer.cpp
@@ -8,6 +8,7 @@
 #include "src/gpu/ganesh/vk/GrVkBuffer.h"
 
 #include "include/gpu/GrDirectContext.h"
+#include "include/private/base/SkDebug.h"
 #include "src/gpu/ganesh/GrDirectContextPriv.h"
 #include "src/gpu/ganesh/GrResourceProvider.h"
 #include "src/gpu/ganesh/vk/GrVkDescriptorSet.h"
@@ -135,11 +136,14 @@ sk_sp<GrVkBuffer> GrVkBuffer::Make(GrVkGpu* gpu,
         return nullptr;
     }
 
-    auto checkResult = [gpu](VkResult result) {
+    bool shouldPersistentlyMapCpuToGpu = gpu->vkCaps().shouldPersistentlyMapCpuToGpuBuffers();
+    auto checkResult = [gpu, allocUsage, shouldPersistentlyMapCpuToGpu](VkResult result) {
+        GR_VK_LOG_IF_NOT_SUCCESS(gpu, result, "skgpu::VulkanMemory::AllocBufferMemory "
+                                 "(allocUsage:%d, shouldPersistentlyMapCpuToGpu:%d)",
+                                 (int)allocUsage, (int)shouldPersistentlyMapCpuToGpu);
         return gpu->checkVkResult(result);
     };
     auto allocator = gpu->memoryAllocator();
-    bool shouldPersistentlyMapCpuToGpu = gpu->vkCaps().shouldPersistentlyMapCpuToGpuBuffers();
     if (!skgpu::VulkanMemory::AllocBufferMemory(allocator,
                                                 buffer,
                                                 allocUsage,
@@ -189,19 +193,26 @@ void GrVkBuffer::vkMap(size_t readOffset, size_t readSize) {
         SkASSERT(fAlloc.fSize >= readOffset + readSize);
 
         GrVkGpu* gpu = this->getVkGpu();
-        auto checkResult = [gpu](VkResult result) {
+        auto checkResult_mapAlloc = [gpu](VkResult result) {
+            GR_VK_LOG_IF_NOT_SUCCESS(gpu, result, "skgpu::VulkanMemory::MapAlloc");
             return gpu->checkVkResult(result);
         };
         auto allocator = gpu->memoryAllocator();
-        fMapPtr = skgpu::VulkanMemory::MapAlloc(allocator, fAlloc, checkResult);
+        fMapPtr = skgpu::VulkanMemory::MapAlloc(allocator, fAlloc, checkResult_mapAlloc);
         if (fMapPtr && readSize != 0) {
+            auto checkResult_invalidateMapAlloc = [gpu, readOffset, readSize](VkResult result) {
+                GR_VK_LOG_IF_NOT_SUCCESS(gpu, result, "skgpu::VulkanMemory::InvalidateMappedAlloc "
+                                         "(readOffset:%zu, readSize:%zu)",
+                                         readOffset, readSize);
+                return gpu->checkVkResult(result);
+            };
             // "Invalidate" here means make device writes visible to the host. That is, it makes
             // sure any GPU writes are finished in the range we might read from.
             skgpu::VulkanMemory::InvalidateMappedAlloc(allocator,
                                                        fAlloc,
                                                        readOffset,
                                                        readSize,
-                                                       checkResult);
+                                                       checkResult_invalidateMapAlloc);
         }
     }
 }
@@ -213,7 +224,10 @@ void GrVkBuffer::vkUnmap(size_t flushOffset, size_t flushSize) {
     SkASSERT(fAlloc.fSize >= flushOffset + flushSize);
 
     GrVkGpu* gpu = this->getVkGpu();
-    auto checkResult = [gpu](VkResult result) {
+    auto checkResult = [gpu, flushOffset, flushSize](VkResult result) {
+        GR_VK_LOG_IF_NOT_SUCCESS(gpu, result, "skgpu::VulkanMemory::FlushMappedAlloc "
+                                 "(flushOffset:%zu, flushSize:%zu)",
+                                 flushOffset, flushSize);
         return gpu->checkVkResult(result);
     };
     auto allocator = this->getVkGpu()->memoryAllocator();
diff --git a/src/gpu/ganesh/vk/GrVkImage.cpp b/src/gpu/ganesh/vk/GrVkImage.cpp
index 2f76f03a71..a07cecf89b 100644
--- a/src/gpu/ganesh/vk/GrVkImage.cpp
+++ b/src/gpu/ganesh/vk/GrVkImage.cpp
@@ -522,7 +522,12 @@ bool GrVkImage::InitImageInfo(GrVkGpu* gpu, const ImageDesc& imageDesc, GrVkImag
     bool useLazyAllocation =
             SkToBool(imageDesc.fUsageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT);
 
-    auto checkResult = [gpu](VkResult result) {
+    auto checkResult = [gpu, isProtected, forceDedicatedMemory, useLazyAllocation](
+                               VkResult result) {
+        GR_VK_LOG_IF_NOT_SUCCESS(gpu, result, "skgpu::VulkanMemory::AllocImageMemory"
+                                 " (isProtected:%d, forceDedicatedMemory:%d, useLazyAllocation:%d)",
+                                 (int)isProtected, (int)forceDedicatedMemory,
+                                 (int)useLazyAllocation);
         return gpu->checkVkResult(result);
     };
     auto allocator = gpu->memoryAllocator();
diff --git a/src/gpu/ganesh/vk/GrVkUtil.h b/src/gpu/ganesh/vk/GrVkUtil.h
index a64a93b14a..c2e565e3be 100644
--- a/src/gpu/ganesh/vk/GrVkUtil.h
+++ b/src/gpu/ganesh/vk/GrVkUtil.h
@@ -22,13 +22,20 @@ class GrVkGpu;
 // makes a Vk call on the interface
 #define GR_VK_CALL(IFACE, X) (IFACE)->fFunctions.f##X
 
+// Note: must be called before checkVkResult, since this does not log if the GPU is already
+// considering the device to be lost.
+#define GR_VK_LOG_IF_NOT_SUCCESS(GPU, RESULT, X, ...)                                   \
+    do {                                                                                \
+        if (RESULT != VK_SUCCESS && !GPU->isDeviceLost()) {                             \
+            SkDebugf("Failed vulkan call. Error: %d, " X "\n", RESULT, ##__VA_ARGS__);  \
+        }                                                                               \
+    } while (false)
+
 #define GR_VK_CALL_RESULT(GPU, RESULT, X)                                 \
     do {                                                                  \
         (RESULT) = GR_VK_CALL(GPU->vkInterface(), X);                     \
         SkASSERT(VK_SUCCESS == RESULT || VK_ERROR_DEVICE_LOST == RESULT); \
-        if (RESULT != VK_SUCCESS && !GPU->isDeviceLost()) {               \
-            SkDebugf("Failed vulkan call. Error: %d," #X "\n", RESULT);   \
-        }                                                                 \
+        GR_VK_LOG_IF_NOT_SUCCESS(GPU, RESULT, #X);                        \
         GPU->checkVkResult(RESULT);                                       \
     } while (false)
 
diff --git a/src/text/gpu/SubRunContainer.cpp b/src/text/gpu/SubRunContainer.cpp
index d99bf17745..981ddd89e0 100644
--- a/src/text/gpu/SubRunContainer.cpp
+++ b/src/text/gpu/SubRunContainer.cpp
@@ -1461,6 +1461,7 @@ std::tuple<const GrClip*, GrOp::Owner> DirectMaskSubRun::makeAtlasTextOp(
                                              this->glyphCount(),
                                              subRunDeviceBounds,
                                              geometry,
+                                             sdc->colorInfo(),
                                              std::move(grPaint));
     return {clip, std::move(op)};
 }
@@ -1803,6 +1804,7 @@ public:
                                                  this->glyphCount(),
                                                  this->deviceRect(positionMatrix),
                                                  geometry,
+                                                 sdc->colorInfo(),
                                                  std::move(grPaint));
         return {clip, std::move(op)};
     }
diff --git a/src/xml/SkXMLParser.cpp b/src/xml/SkXMLParser.cpp
index eab28cb9f6..5d3526a7c9 100644
--- a/src/xml/SkXMLParser.cpp
+++ b/src/xml/SkXMLParser.cpp
@@ -154,29 +154,41 @@ bool SkXMLParser::parse(SkStream& docStream)
     // Disable entity processing, to inhibit internal entity expansion. See expat CVE-2013-0340.
     XML_SetEntityDeclHandler(ctx.fXMLParser, entity_decl_handler);
 
-    static constexpr int kBufferSize = 4096;
-    bool done = false;
-    do {
-        void* buffer = XML_GetBuffer(ctx.fXMLParser, kBufferSize);
-        if (!buffer) {
-            SkDEBUGF("could not buffer enough to continue\n");
-            return false;
-        }
-
-        size_t len = docStream.read(buffer, kBufferSize);
-        done = docStream.isAtEnd();
-        XML_Status status = XML_ParseBuffer(ctx.fXMLParser, SkToS32(len), done);
-        if (XML_STATUS_ERROR == status) {
-        #if defined(SK_DEBUG)
-            XML_Error error = XML_GetErrorCode(ctx.fXMLParser);
-            int line = XML_GetCurrentLineNumber(ctx.fXMLParser);
-            int column = XML_GetCurrentColumnNumber(ctx.fXMLParser);
-            const XML_LChar* errorString = XML_ErrorString(error);
-            SkDEBUGF("parse error @%d:%d: %d (%s).\n", line, column, error, errorString);
-        #endif
-            return false;
-        }
-    } while (!done);
+    XML_Status status = XML_STATUS_OK;
+    if (docStream.getMemoryBase() && docStream.hasLength()) {
+        const char* base = reinterpret_cast<const char*>(docStream.getMemoryBase());
+        status = XML_Parse(ctx.fXMLParser,
+                           base + docStream.getPosition(),
+                           docStream.getLength() - docStream.getPosition(),
+                           true);
+    } else {
+        static constexpr int kBufferSize = 4096;
+        bool done = false;
+        do {
+            void* buffer = XML_GetBuffer(ctx.fXMLParser, kBufferSize);
+            if (!buffer) {
+                SkDEBUGF("could not buffer enough to continue\n");
+                return false;
+            }
+
+            size_t len = docStream.read(buffer, kBufferSize);
+            done = docStream.isAtEnd();
+            status = XML_ParseBuffer(ctx.fXMLParser, SkToS32(len), done);
+            if (XML_STATUS_ERROR == status) {
+                break;
+            }
+        } while (!done);
+    }
+    if (XML_STATUS_ERROR == status) {
+#if defined(SK_DEBUG)
+        XML_Error error = XML_GetErrorCode(ctx.fXMLParser);
+        int line = XML_GetCurrentLineNumber(ctx.fXMLParser);
+        int column = XML_GetCurrentColumnNumber(ctx.fXMLParser);
+        const XML_LChar* errorString = XML_ErrorString(error);
+        SkDEBUGF("parse error @%d:%d: %d (%s).\n", line, column, error, errorString);
+#endif
+        return false;
+    }
 
     return true;
 }
diff --git a/tests/ColorFilterTest.cpp b/tests/ColorFilterTest.cpp
index 671c2fbe2b..da7a2b6713 100644
--- a/tests/ColorFilterTest.cpp
+++ b/tests/ColorFilterTest.cpp
@@ -167,7 +167,7 @@ struct FailureColorFilter final : public SkColorFilterBase {
 DEF_GANESH_TEST_FOR_ALL_CONTEXTS(ComposeFailureWithInputElision,
                                  r,
                                  ctxInfo,
-                                 CtsEnforcement::kApiLevel_T) {
+                                 CtsEnforcement::kNextRelease) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(8, 8);
     auto surface = SkSurface::MakeRenderTarget(ctxInfo.directContext(), skgpu::Budgeted::kNo, info);
     SkPaint paint;
diff --git a/tests/GrFinishedFlushTest.cpp b/tests/GrFinishedFlushTest.cpp
index 03bc545fd0..43a6853341 100644
--- a/tests/GrFinishedFlushTest.cpp
+++ b/tests/GrFinishedFlushTest.cpp
@@ -177,7 +177,7 @@ static void async_callback(void* c, std::unique_ptr<const SkImage::AsyncReadResu
 DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(FinishedAsyncProcWhenAbandonedTest,
                                        reporter,
                                        ctxInfo,
-                                       CtsEnforcement::kApiLevel_T) {
+                                       CtsEnforcement::kNextRelease) {
     auto dContext = ctxInfo.directContext();
 
     SkImageInfo info =
diff --git a/tests/GrGpuBufferTest.cpp b/tests/GrGpuBufferTest.cpp
index bb50c570e8..8bd1ac5fa6 100644
--- a/tests/GrGpuBufferTest.cpp
+++ b/tests/GrGpuBufferTest.cpp
@@ -219,7 +219,7 @@ private:
 DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(GrGpuBufferTransferTest,
                                        reporter,
                                        ctxInfo,
-                                       CtsEnforcement::kApiLevel_T) {
+                                       CtsEnforcement::kNextRelease) {
     if (!ctxInfo.directContext()->priv().caps()->transferFromBufferToBufferSupport()) {
         return;
     }
@@ -372,7 +372,7 @@ DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(GrGpuBufferTransferTest,
 DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(GrGpuBufferUpdateDataTest,
                                        reporter,
                                        ctxInfo,
-                                       CtsEnforcement::kApiLevel_T) {
+                                       CtsEnforcement::kNextRelease) {
     GrDirectContext* dc = ctxInfo.directContext();
 
     GrGpu* gpu = ctxInfo.directContext()->priv().getGpu();
diff --git a/tests/ReadWritePixelsGpuTest.cpp b/tests/ReadWritePixelsGpuTest.cpp
index 0fcff04dea..4ee5034593 100644
--- a/tests/ReadWritePixelsGpuTest.cpp
+++ b/tests/ReadWritePixelsGpuTest.cpp
@@ -693,10 +693,11 @@ DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceAsyncReadPixels,
     }
 }
 
-DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ImageAsyncReadPixels,
-                                       reporter,
-                                       ctxInfo,
-                                       CtsEnforcement::kApiLevel_T) {
+// Manually parameterized by GrRenderable and GrSurfaceOrigin to reduce per-test run time.
+static void image_async_read_pixels(GrRenderable renderable,
+                                    GrSurfaceOrigin origin,
+                                    skiatest::Reporter* reporter,
+                                    const sk_gpu_test::ContextInfo& ctxInfo) {
     using Image = sk_sp<SkImage>;
     auto context = ctxInfo.directContext();
     auto reader = std::function<GpuReadSrcFn<Image>>([context](const Image& image,
@@ -734,16 +735,44 @@ DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ImageAsyncReadPixels,
     rules.fAllowUnpremulSrc = true;
     rules.fUncontainedRectSucceeds = false;
 
-    for (auto origin : {kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) {
-        for (auto renderable : {GrRenderable::kNo, GrRenderable::kYes}) {
-            auto factory = std::function<GpuSrcFactory<Image>>([&](const SkPixmap& src) {
-                return sk_gpu_test::MakeBackendTextureImage(ctxInfo.directContext(), src,
-                                                            renderable, origin);
-            });
-            auto label = SkStringPrintf("Renderable: %d, Origin: %d", (int)renderable, origin);
-            gpu_read_pixels_test_driver(reporter, rules, factory, reader, label);
-        }
-    }
+    auto factory = std::function<GpuSrcFactory<Image>>([&](const SkPixmap& src) {
+        return sk_gpu_test::MakeBackendTextureImage(ctxInfo.directContext(), src,
+                                                    renderable, origin);
+    });
+    auto label = SkStringPrintf("Renderable: %d, Origin: %d", (int)renderable, origin);
+    gpu_read_pixels_test_driver(reporter, rules, factory, reader, label);
+}
+
+DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ImageAsyncReadPixels_NonRenderable_TopLeft,
+                                       reporter,
+                                       ctxInfo,
+                                       CtsEnforcement::kApiLevel_T) {
+    image_async_read_pixels(GrRenderable::kNo, GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin,
+                            reporter, ctxInfo);
+}
+
+DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ImageAsyncReadPixels_NonRenderable_BottomLeft,
+                                       reporter,
+                                       ctxInfo,
+                                       CtsEnforcement::kApiLevel_T) {
+    image_async_read_pixels(GrRenderable::kNo, GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin,
+                            reporter, ctxInfo);
+}
+
+DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ImageAsyncReadPixels_Renderable_TopLeft,
+                                       reporter,
+                                       ctxInfo,
+                                       CtsEnforcement::kApiLevel_T) {
+    image_async_read_pixels(GrRenderable::kYes, GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin,
+                            reporter, ctxInfo);
+}
+
+DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ImageAsyncReadPixels_Renderable_BottomLeft,
+                                       reporter,
+                                       ctxInfo,
+                                       CtsEnforcement::kApiLevel_T) {
+    image_async_read_pixels(GrRenderable::kYes, GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin,
+                            reporter, ctxInfo);
 }
 
 DEF_GANESH_TEST(AsyncReadPixelsContextShutdown, reporter, options, CtsEnforcement::kApiLevel_T) {
@@ -1117,10 +1146,11 @@ static void gpu_write_pixels_test_driver(skiatest::Reporter* reporter,
     }
 }
 
-DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceContextWritePixels,
-                                       reporter,
-                                       ctxInfo,
-                                       CtsEnforcement::kApiLevel_T) {
+// Manually parameterized by GrRenderable and GrSurfaceOrigin to reduce per-test run time.
+static void surface_context_write_pixels(GrRenderable renderable,
+                                         GrSurfaceOrigin origin,
+                                         skiatest::Reporter* reporter,
+                                         const sk_gpu_test::ContextInfo& ctxInfo) {
     using Surface = std::unique_ptr<skgpu::v1::SurfaceContext>;
     GrDirectContext* direct = ctxInfo.directContext();
     auto writer = std::function<GpuWriteDstFn<Surface>>(
@@ -1146,20 +1176,48 @@ DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceContextWritePixels,
         return result;
     });
 
-    for (auto renderable : {GrRenderable::kNo, GrRenderable::kYes}) {
-        for (GrSurfaceOrigin origin : {kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) {
-            auto factory = std::function<GpuDstFactory<Surface>>(
-                    [direct, origin, renderable](const SkImageInfo& info) {
-                        return CreateSurfaceContext(direct,
-                                                    info,
-                                                    SkBackingFit::kExact,
-                                                    origin,
-                                                    renderable);
-                    });
+    auto factory = std::function<GpuDstFactory<Surface>>(
+            [direct, origin, renderable](const SkImageInfo& info) {
+                return CreateSurfaceContext(direct,
+                                            info,
+                                            SkBackingFit::kExact,
+                                            origin,
+                                            renderable);
+            });
 
-            gpu_write_pixels_test_driver(reporter, factory, writer, reader);
-        }
-    }
+    gpu_write_pixels_test_driver(reporter, factory, writer, reader);
+}
+
+DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceContextWritePixels_NonRenderable_TopLeft,
+                                       reporter,
+                                       ctxInfo,
+                                       CtsEnforcement::kApiLevel_T) {
+    surface_context_write_pixels(GrRenderable::kNo, GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin,
+                                 reporter, ctxInfo);
+}
+
+DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceContextWritePixels_NonRenderable_BottomLeft,
+                                       reporter,
+                                       ctxInfo,
+                                       CtsEnforcement::kApiLevel_T) {
+    surface_context_write_pixels(GrRenderable::kNo, GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin,
+                                 reporter, ctxInfo);
+}
+
+DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceContextWritePixels_Renderable_TopLeft,
+                                       reporter,
+                                       ctxInfo,
+                                       CtsEnforcement::kApiLevel_T) {
+    surface_context_write_pixels(GrRenderable::kYes, GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin,
+                                 reporter, ctxInfo);
+}
+
+DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceContextWritePixels_Renderable_BottomLeft,
+                                       reporter,
+                                       ctxInfo,
+                                       CtsEnforcement::kApiLevel_T) {
+    surface_context_write_pixels(GrRenderable::kYes, GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin,
+                                 reporter, ctxInfo);
 }
 
 DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceContextWritePixelsMipped,
diff --git a/tests/SkRuntimeEffectTest.cpp b/tests/SkRuntimeEffectTest.cpp
index 8554b0029a..0bc1da96e2 100644
--- a/tests/SkRuntimeEffectTest.cpp
+++ b/tests/SkRuntimeEffectTest.cpp
@@ -836,7 +836,7 @@ DEF_TEST(SkRuntimeEffectObeysCapabilities_CPU, r) {
 DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRuntimeEffectObeysCapabilities_GPU,
                                        r,
                                        ctxInfo,
-                                       CtsEnforcement::kApiLevel_T) {
+                                       CtsEnforcement::kNextRelease) {
     SkImageInfo info = SkImageInfo::Make(2, 2, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
     sk_sp<SkSurface> surface =
             SkSurface::MakeRenderTarget(ctxInfo.directContext(), skgpu::Budgeted::kNo, info);
diff --git a/tests/SkSLTest.cpp b/tests/SkSLTest.cpp
index e9a89dafb8..b0e5f08fbd 100644
--- a/tests/SkSLTest.cpp
+++ b/tests/SkSLTest.cpp
@@ -492,20 +492,20 @@ SKSL_TEST(RP + GPU_ES3,  kNever,      IntFoldingES3,                   "folding/
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, FloatFolding,                    "folding/FloatFolding.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, MatrixFoldingES2,                "folding/MatrixFoldingES2.rts")
 SKSL_TEST(RP + GPU_ES3,  kNever,      MatrixFoldingES3,                "folding/MatrixFoldingES3.sksl")
-SKSL_TEST(RP + VM + GPU, kApiLevel_T, MatrixNoOpFolding,               "folding/MatrixNoOpFolding.rts")
-SKSL_TEST(RP + VM + GPU, kApiLevel_T, MatrixScalarNoOpFolding,         "folding/MatrixScalarNoOpFolding.rts")
-SKSL_TEST(RP + VM + GPU, kApiLevel_T, MatrixVectorNoOpFolding,         "folding/MatrixVectorNoOpFolding.rts")
+SKSL_TEST(RP + VM + GPU, kNextRelease, MatrixNoOpFolding,               "folding/MatrixNoOpFolding.rts")
+SKSL_TEST(RP + VM + GPU, kNextRelease, MatrixScalarNoOpFolding,         "folding/MatrixScalarNoOpFolding.rts")
+SKSL_TEST(RP + VM + GPU, kNextRelease, MatrixVectorNoOpFolding,         "folding/MatrixVectorNoOpFolding.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, Negation,                        "folding/Negation.rts")
 // TODO(skia:13035): This test fails on Nvidia GPUs on OpenGL but passes Vulkan. Re-enable the test
 // on Vulkan when granular GPU backend selection is supported.
 SKSL_TEST(RP + VM,       kApiLevel_T, PreserveSideEffects,             "folding/PreserveSideEffects.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, SelfAssignment,                  "folding/SelfAssignment.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, ShortCircuitBoolFolding,         "folding/ShortCircuitBoolFolding.rts")
-SKSL_TEST(RP + VM + GPU, kApiLevel_T, StructFieldFolding,              "folding/StructFieldFolding.rts")
-SKSL_TEST(RP + VM + GPU, kApiLevel_T, StructFieldNoFolding,            "folding/StructFieldNoFolding.rts")
+SKSL_TEST(RP + VM + GPU, kNextRelease, StructFieldFolding,              "folding/StructFieldFolding.rts")
+SKSL_TEST(RP + VM + GPU, kNextRelease, StructFieldNoFolding,            "folding/StructFieldNoFolding.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, SwitchCaseFolding,               "folding/SwitchCaseFolding.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, SwizzleFolding,                  "folding/SwizzleFolding.rts")
-SKSL_TEST(RP + VM + GPU, kApiLevel_T, TernaryFolding,                  "folding/TernaryFolding.rts")
+SKSL_TEST(RP + VM + GPU, kNextRelease, TernaryFolding,                  "folding/TernaryFolding.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, VectorScalarFolding,             "folding/VectorScalarFolding.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, VectorVectorFolding,             "folding/VectorVectorFolding.rts")
 
@@ -526,7 +526,7 @@ SKSL_TEST(RP + VM + GPU, kApiLevel_T, InlinerElidesTempVarForReturnsInsideBlock,
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, InlinerUsesTempVarForMultipleReturns,             "inliner/InlinerUsesTempVarForMultipleReturns.sksl")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, InlinerUsesTempVarForReturnsInsideBlockWithVar,   "inliner/InlinerUsesTempVarForReturnsInsideBlockWithVar.sksl")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, InlineThreshold,                                  "inliner/InlineThreshold.sksl")
-SKSL_TEST(RP + GPU_ES3,  kApiLevel_T, InlineUnscopedVariable,                           "inliner/InlineUnscopedVariable.sksl")
+SKSL_TEST(RP + GPU_ES3,  kNextRelease, InlineUnscopedVariable,                           "inliner/InlineUnscopedVariable.sksl")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, InlineWithModifiedArgument,                       "inliner/InlineWithModifiedArgument.sksl")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, InlineWithNestedBigCalls,                         "inliner/InlineWithNestedBigCalls.sksl")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, InlineWithUnmodifiedArgument,                     "inliner/InlineWithUnmodifiedArgument.sksl")
@@ -596,7 +596,7 @@ SKSL_TEST(GPU_ES3,       kNever,      ArrayNarrowingConversions,       "runtime/
 SKSL_TEST(RP + GPU_ES3,  kNever,      Commutative,                     "runtime/Commutative.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, LoopFloat,                       "runtime/LoopFloat.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, LoopInt,                         "runtime/LoopInt.rts")
-SKSL_TEST(RP + VM + GPU, kApiLevel_T, Ossfuzz52603,                    "runtime/Ossfuzz52603.rts")
+SKSL_TEST(RP + VM + GPU, kNextRelease, Ossfuzz52603,                    "runtime/Ossfuzz52603.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, QualifierOrder,                  "runtime/QualifierOrder.rts")
 SKSL_TEST(RP + VM + GPU, kApiLevel_T, PrecisionQualifiers,             "runtime/PrecisionQualifiers.rts")
 
@@ -614,7 +614,7 @@ SKSL_TEST(RP + VM + GPU,     kApiLevel_T, Assignment,                      "shar
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, CastsRoundTowardZero,            "shared/CastsRoundTowardZero.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, CommaMixedTypes,                 "shared/CommaMixedTypes.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, CommaSideEffects,                "shared/CommaSideEffects.sksl")
-SKSL_TEST(RP + VM + GPU,     kApiLevel_T, CompileTimeConstantVariables,    "shared/CompileTimeConstantVariables.sksl")
+SKSL_TEST(RP + VM + GPU,     kNextRelease, CompileTimeConstantVariables,    "shared/CompileTimeConstantVariables.sksl")
 SKSL_TEST(GPU_ES3,           kNever,      ConstantCompositeAccessViaConstantIndex, "shared/ConstantCompositeAccessViaConstantIndex.sksl")
 SKSL_TEST(GPU_ES3,           kNever,      ConstantCompositeAccessViaDynamicIndex,  "shared/ConstantCompositeAccessViaDynamicIndex.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, ConstantIf,                      "shared/ConstantIf.sksl")
@@ -628,7 +628,7 @@ SKSL_TEST(RP + VM + GPU,     kApiLevel_T, DeadReturn,                      "shar
 SKSL_TEST(RP /* +GPU_ES3 */, kNever,      SkSLDeadReturnES3,               "shared/DeadReturnES3.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, DeadStripFunctions,              "shared/DeadStripFunctions.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, DependentInitializers,           "shared/DependentInitializers.sksl")
-SKSL_TEST(RP + VM + GPU,     kApiLevel_T, DoubleNegation,                  "shared/DoubleNegation.sksl")
+SKSL_TEST(RP + VM + GPU,     kNextRelease, DoubleNegation,                  "shared/DoubleNegation.sksl")
 SKSL_TEST(RP + GPU_ES3,      kNever,      DoWhileControlFlow,              "shared/DoWhileControlFlow.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, EmptyBlocksES2,                  "shared/EmptyBlocksES2.sksl")
 SKSL_TEST(RP + GPU_ES3,      kNever,      EmptyBlocksES3,                  "shared/EmptyBlocksES3.sksl")
@@ -643,8 +643,8 @@ SKSL_TEST(RP + VM + GPU,     kApiLevel_T, HelloWorld,                      "shar
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, Hex,                             "shared/Hex.sksl")
 SKSL_TEST(RP + GPU_ES3,      kNever,      HexUnsigned,                     "shared/HexUnsigned.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, InoutParameters,                 "shared/InoutParameters.sksl")
-SKSL_TEST(RP + VM + GPU,     kApiLevel_T, InoutParamsAreDistinct,          "shared/InoutParamsAreDistinct.sksl")
-SKSL_TEST(RP + GPU_ES3,      kApiLevel_T, IntegerDivisionES3,              "shared/IntegerDivisionES3.sksl")
+SKSL_TEST(RP + VM + GPU,     kNextRelease, InoutParamsAreDistinct,          "shared/InoutParamsAreDistinct.sksl")
+SKSL_TEST(RP + GPU_ES3,      kNextRelease, IntegerDivisionES3,              "shared/IntegerDivisionES3.sksl")
 SKSL_TEST(RP + VM + GPU,     kNextRelease,LogicalAndShortCircuit,          "shared/LogicalAndShortCircuit.sksl")
 SKSL_TEST(RP + VM + GPU,     kNextRelease,LogicalOrShortCircuit,           "shared/LogicalOrShortCircuit.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, Matrices,                        "shared/Matrices.sksl")
@@ -665,7 +665,7 @@ SKSL_TEST(GPU_ES3,           kNever,      OperatorsES3,                    "shar
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, Ossfuzz36852,                    "shared/Ossfuzz36852.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, OutParams,                       "shared/OutParams.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, OutParamsAreDistinct,            "shared/OutParamsAreDistinct.sksl")
-SKSL_TEST(RP + VM + GPU,     kApiLevel_T, OutParamsAreDistinctFromGlobal,  "shared/OutParamsAreDistinctFromGlobal.sksl")
+SKSL_TEST(RP + VM + GPU,     kNextRelease, OutParamsAreDistinctFromGlobal,  "shared/OutParamsAreDistinctFromGlobal.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, OutParamsTricky,                 "shared/OutParamsTricky.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, ResizeMatrix,                    "shared/ResizeMatrix.sksl")
 SKSL_TEST(RP + GPU_ES3,      kNever,      ResizeMatrixNonsquare,           "shared/ResizeMatrixNonsquare.sksl")
@@ -701,7 +701,7 @@ SKSL_TEST(RP + VM + GPU,     kApiLevel_T, TernaryExpression,               "shar
 SKSL_TEST(RP + VM + GPU,     kNextRelease,TernarySideEffects,              "shared/TernarySideEffects.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, UnaryPositiveNegative,           "shared/UnaryPositiveNegative.sksl")
 SKSL_TEST(VM + GPU,          kApiLevel_T, UniformArray,                    "shared/UniformArray.sksl")
-SKSL_TEST(RP + VM + GPU,     kApiLevel_T, UniformMatrixResize,             "shared/UniformMatrixResize.sksl")
+SKSL_TEST(RP + VM + GPU,     kNextRelease, UniformMatrixResize,             "shared/UniformMatrixResize.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, UnusedVariables,                 "shared/UnusedVariables.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, VectorConstructors,              "shared/VectorConstructors.sksl")
 SKSL_TEST(RP + VM + GPU,     kApiLevel_T, VectorToMatrixCast,              "shared/VectorToMatrixCast.sksl")