Update error handling in DDL-averse GMs

This will allow local debug DDL dm runs to complete.

Change-Id: I47aa978c5e52fd1dcdba45c59318844bae871115
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/326796
Reviewed-by: Adlai Holler <adlai@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
diff --git a/gm/asyncrescaleandread.cpp b/gm/asyncrescaleandread.cpp
index c75f81c..f880adc 100644
--- a/gm/asyncrescaleandread.cpp
+++ b/gm/asyncrescaleandread.cpp
@@ -192,7 +192,11 @@
         *errorMsg = "Not supported on recording/vector backends.";
         return skiagm::DrawResult::kSkip;
     }
-    auto direct = GrAsDirectContext(canvas->recordingContext());
+    auto dContext = GrAsDirectContext(canvas->recordingContext());
+    if (!dContext) {
+        *errorMsg = "Not supported in DDL mode";
+        return skiagm::DrawResult::kSkip;
+    }
 
     if (doSurface) {
         // Turn the image into a surface in order to call the read and rescale API
@@ -213,10 +217,10 @@
         SkPaint paint;
         paint.setBlendMode(SkBlendMode::kSrc);
         surface->getCanvas()->drawImage(image, 0, 0, &paint);
-        return do_rescale_grid(canvas, surface.get(), direct, srcRect, newSize,
+        return do_rescale_grid(canvas, surface.get(), dContext, srcRect, newSize,
                                doYUV420, errorMsg);
-    } else if (direct) {
-        image = image->makeTextureImage(direct);
+    } else if (dContext) {
+        image = image->makeTextureImage(dContext);
         if (!image) {
             *errorMsg = "Could not create image.";
             // When testing abandoned GrContext we expect surface creation to fail.
@@ -226,7 +230,7 @@
             return skiagm::DrawResult::kFail;
         }
     }
-    return do_rescale_grid(canvas, image.get(), direct, srcRect, newSize, doYUV420,
+    return do_rescale_grid(canvas, image.get(), dContext, srcRect, newSize, doYUV420,
                            errorMsg);
 }
 
@@ -287,6 +291,12 @@
         return skiagm::DrawResult::kSkip;
     }
 
+    auto dContext = GrAsDirectContext(surface->recordingContext());
+    if (!dContext) {
+        *errorMsg = "Not supported in DDL mode";
+        return skiagm::DrawResult::kSkip;
+    }
+
     auto image = GetResourceAsImage("images/yellow_rose.webp");
     if (!image) {
         return skiagm::DrawResult::kFail;
@@ -294,11 +304,9 @@
     SkPaint paint;
     canvas->drawImage(image.get(), 0, 0);
 
-    auto direct = GrAsDirectContext(surface->recordingContext());
-
     SkScopeExit scopeExit;
     auto yuvImage = do_read_and_scale_yuv(
-            surface, direct, kRec601_SkYUVColorSpace, SkIRect::MakeWH(400, 300),
+            surface, dContext, kRec601_SkYUVColorSpace, SkIRect::MakeWH(400, 300),
             {400, 300}, SkImage::RescaleGamma::kSrc, kNone_SkFilterQuality, &scopeExit);
 
     canvas->clear(SK_ColorWHITE);
@@ -313,6 +321,12 @@
         return skiagm::DrawResult::kSkip;
     }
 
+    auto dContext = GrAsDirectContext(canvas->recordingContext());
+    if (!dContext) {
+        *errorMsg = "Not supported in DDL mode";
+        return skiagm::DrawResult::kSkip;
+    }
+
     static constexpr int kBorder = 5;
     static constexpr int kInner = 5;
     const auto srcRect = SkIRect::MakeXYWH(kBorder, kBorder, kInner, kInner);
@@ -337,8 +351,7 @@
     canvas->translate(kPad, kPad);
     skiagm::DrawResult result;
     SkISize downSize = {static_cast<int>(kInner/2),  static_cast<int>(kInner / 2)};
-    auto direct = GrAsDirectContext(canvas->recordingContext());
-    result = do_rescale_grid(canvas, surface.get(), direct, srcRect, downSize, false, errorMsg,
+    result = do_rescale_grid(canvas, surface.get(), dContext, srcRect, downSize, false, errorMsg,
                              kPad);
 
     if (result != skiagm::DrawResult::kOk) {
@@ -346,7 +359,8 @@
     }
     canvas->translate(0, 4 * downSize.height());
     SkISize upSize = {static_cast<int>(kInner * 3.5), static_cast<int>(kInner * 4.6)};
-    result = do_rescale_grid(canvas, surface.get(), direct, srcRect, upSize, false, errorMsg, kPad);
+    result = do_rescale_grid(canvas, surface.get(), dContext, srcRect, upSize, false, errorMsg,
+                             kPad);
     if (result != skiagm::DrawResult::kOk) {
         return result;
     }
diff --git a/gm/image.cpp b/gm/image.cpp
index e2f2922..261541e 100644
--- a/gm/image.cpp
+++ b/gm/image.cpp
@@ -437,6 +437,14 @@
 }
 
 DEF_SIMPLE_GM_CAN_FAIL(image_subset, canvas, errorMsg, 440, 220) {
+    auto rContext = canvas->recordingContext();
+    auto dContext = GrAsDirectContext(rContext);
+
+    if (!dContext && rContext) {
+        *errorMsg = "Not supported in DDL mode";
+        return skiagm::DrawResult::kSkip;
+    }
+
     SkImageInfo info = SkImageInfo::MakeN32Premul(200, 200, nullptr);
     auto        surf = ToolUtils::makeSurface(canvas, info, nullptr);
     auto img = make_lazy_image(surf.get());
diff --git a/gm/path_stroke_with_zero_length.cpp b/gm/path_stroke_with_zero_length.cpp
index dbd4741..7550ef5 100644
--- a/gm/path_stroke_with_zero_length.cpp
+++ b/gm/path_stroke_with_zero_length.cpp
@@ -129,10 +129,16 @@
 static const SkColor kFailureRed = 0x7FE7298A;
 static const SkColor kSuccessGreen = 0x7F1B9E77;
 
-static void draw_zero_length_capped_paths(SkCanvas* canvas, bool aa) {
+static skiagm::DrawResult draw_zero_length_capped_paths(SkCanvas* canvas, bool aa,
+                                                        SkString* errorMsg) {
     auto rContext = canvas->recordingContext();
     auto dContext = GrAsDirectContext(rContext);
-    SkASSERT(dContext || !rContext); // not supported in DDL.
+
+    if (!dContext && rContext) {
+        *errorMsg = "Not supported in DDL mode";
+        return skiagm::DrawResult::kSkip;
+    }
+
     canvas->translate(kCellPad, kCellPad);
 
     SkImageInfo info = canvas->imageInfo().makeWH(kCellWidth, kCellHeight);
@@ -182,20 +188,28 @@
     }
 
     canvas->drawColor(numFailedTests > 0 ? kFailureRed : kSuccessGreen);
+    return skiagm::DrawResult::kOk;
 }
 
-DEF_SIMPLE_GM_BG(zero_length_paths_aa, canvas, kTotalWidth, kTotalHeight, SK_ColorBLACK) {
-    draw_zero_length_capped_paths(canvas, true);
+DEF_SIMPLE_GM_BG_CAN_FAIL(zero_length_paths_aa, canvas, errorMsg,
+                          kTotalWidth, kTotalHeight, SK_ColorBLACK) {
+    return draw_zero_length_capped_paths(canvas, true, errorMsg);
 }
 
-DEF_SIMPLE_GM_BG(zero_length_paths_bw, canvas, kTotalWidth, kTotalHeight, SK_ColorBLACK) {
-    draw_zero_length_capped_paths(canvas, false);
+DEF_SIMPLE_GM_BG_CAN_FAIL(zero_length_paths_bw, canvas, errorMsg,
+                          kTotalWidth, kTotalHeight, SK_ColorBLACK) {
+    return draw_zero_length_capped_paths(canvas, false, errorMsg);
 }
 
-static void draw_zero_length_capped_paths_dbl_contour(SkCanvas* canvas, bool aa) {
+static skiagm::DrawResult draw_zero_length_capped_paths_dbl_contour(SkCanvas* canvas, bool aa,
+                                                                    SkString* errorMsg) {
     auto rContext = canvas->recordingContext();
     auto dContext = GrAsDirectContext(rContext);
-    SkASSERT(dContext || !rContext); // not supported in DDL.
+
+    if (!dContext && rContext) {
+        *errorMsg = "Not supported in DDL mode";
+        return skiagm::DrawResult::kSkip;
+    }
     canvas->translate(kCellPad, kCellPad);
 
     SkImageInfo info = canvas->imageInfo().makeWH(kCellWidth, kCellHeight);
@@ -255,14 +269,15 @@
     }
 
     canvas->drawColor(numFailedTests > 0 ? kFailureRed : kSuccessGreen);
+    return skiagm::DrawResult::kOk;
 }
 
-DEF_SIMPLE_GM_BG(zero_length_paths_dbl_aa, canvas, kDblContourTotalWidth, kTotalHeight,
-                 SK_ColorBLACK) {
-    draw_zero_length_capped_paths_dbl_contour(canvas, true);
+DEF_SIMPLE_GM_BG_CAN_FAIL(zero_length_paths_dbl_aa, canvas, errorMsg,
+                          kDblContourTotalWidth, kTotalHeight, SK_ColorBLACK) {
+    return draw_zero_length_capped_paths_dbl_contour(canvas, true, errorMsg);
 }
 
-DEF_SIMPLE_GM_BG(zero_length_paths_dbl_bw, canvas, kDblContourTotalWidth, kTotalHeight,
-                 SK_ColorBLACK) {
-    draw_zero_length_capped_paths_dbl_contour(canvas, false);
+DEF_SIMPLE_GM_BG_CAN_FAIL(zero_length_paths_dbl_bw, canvas, errorMsg,
+                          kDblContourTotalWidth, kTotalHeight, SK_ColorBLACK) {
+    return draw_zero_length_capped_paths_dbl_contour(canvas, false, errorMsg);
 }
diff --git a/gm/preservefillrule.cpp b/gm/preservefillrule.cpp
index fdb5eb3..26e43bb 100644
--- a/gm/preservefillrule.cpp
+++ b/gm/preservefillrule.cpp
@@ -59,7 +59,7 @@
         ctxOptions->fAllowPathMaskCaching = true;
     }
 
-    DrawResult onDraw(GrRecordingContext* ctx, GrRenderTargetContext* rtc, SkCanvas* canvas,
+    DrawResult onDraw(GrRecordingContext* rContext, GrRenderTargetContext* rtc, SkCanvas* canvas,
                       SkString* errorMsg) override {
         using CoverageType = GrCCAtlas::CoverageType;
 
@@ -68,7 +68,7 @@
             return DrawResult::kSkip;
         }
 
-        auto* ccpr = ctx->priv().drawingManager()->getCoverageCountingPathRenderer();
+        auto* ccpr = rContext->priv().drawingManager()->getCoverageCountingPathRenderer();
         if (!ccpr) {
             errorMsg->set("ccpr only");
             return DrawResult::kSkip;
@@ -81,6 +81,8 @@
             return DrawResult::kFail;
         }
 
+        auto dContext = GrAsDirectContext(rContext);
+
         auto starRect = SkRect::MakeWH(fStarSize, fStarSize);
         SkPath star7_winding = ToolUtils::make_star(starRect, 7);
         star7_winding.setFillType(SkPathFillType::kWinding);
@@ -136,8 +138,11 @@
                 }
                 ++numCachedPaths;
             }
-            // Verify all 4 paths are tracked by the path cache.
-            ERR_MSG_ASSERT(4 == numCachedPaths);
+
+            if (dContext) {
+                // Verify all 4 paths are tracked by the path cache.
+                ERR_MSG_ASSERT(4 == numCachedPaths);
+            }
         }
 
         return DrawResult::kOk;