Merge "Merge Android 14 QPR1" into main

11 files changed, 183 insertions, 84 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/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/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")