commit cc25d534204fd48fc4da649f0cf3289fe6a47804
author Adlai Holler <adlai@google.com> Wed Feb 10 13:58:34 2021 +0000
committer Skia Commit-Bot <skia-commit-bot@chromium.org> Wed Feb 10 14:52:53 2021 +0000
tree 60640c2d24240e3c39b984d7b37d3a1ad46d3971
parent 4908a24d4b24ad34a3dce693d931654b872bff08

Revert "Migrate uses of deferred proxies to lazy proxies"

This reverts commit 990a0d8b6563941d69aa24ecae847be150ab1128.

Reason for revert: Keeping it. Deferred proxies are uploaded later than lazy and we want that for this use case.

Original change's description:
> Migrate uses of deferred proxies to lazy proxies
>
> A follow-up CL removes the deferred proxies system entirely.
>
> Bug: skia:11288
> Change-Id: Ic5b3ce820ea946f6ae27bd763c0f389caf8863d1
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/366716
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Commit-Queue: Adlai Holler <adlai@google.com>

TBR=bsalomon@google.com,robertphillips@google.com,adlai@google.com

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: skia:11288
Change-Id: I9ced532d013805afae3b20baa53cab31cae2b953
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/368797
Reviewed-by: Adlai Holler <adlai@google.com>
Commit-Queue: Adlai Holler <adlai@google.com>

src/gpu/GrSoftwarePathRenderer.cpp

diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index 0f43d27..e4dc789 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -173,10 +173,27 @@
                   dstRect, invert);
 }
 
+static GrSurfaceProxyView make_deferred_mask_texture_view(GrRecordingContext* context,
+                                                          SkBackingFit fit,
+                                                          SkISize dimensions) {
+    GrProxyProvider* proxyProvider = context->priv().proxyProvider();
+    const GrCaps* caps = context->priv().caps();
+
+    const GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kAlpha_8,
+                                                                 GrRenderable::kNo);
+
+    GrSwizzle swizzle = caps->getReadSwizzle(format, GrColorType::kAlpha_8);
+
+    auto proxy =
+            proxyProvider->createProxy(format, dimensions, GrRenderable::kNo, 1, GrMipmapped::kNo,
+                                       fit, SkBudgeted::kYes, GrProtected::kNo);
+    return {std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle};
+}
+
 namespace {
 
 /**
- * Payload class for use with GrSWMaskHelper. The software path renderer only draws
+ * Payload class for use with GrTDeferredProxyUploader. The software path renderer only draws
  * a single path into the mask texture. This stores all of the information needed by the worker
  * thread's call to drawShape (see below, in onDrawPath).
  */
@@ -190,7 +207,7 @@
             , fAA(aa) {}
 
     const SkIRect& getMaskBounds() const { return fMaskBounds; }
-    const SkMatrix& getViewMatrix() const { return fViewMatrix; }
+    const SkMatrix* getViewMatrix() const { return &fViewMatrix; }
     const GrStyledShape& getShape() const { return fShape; }
     GrAA getAA() const { return fAA; }
 
@@ -309,15 +326,44 @@
     if (!view) {
         SkBackingFit fit = useCache ? SkBackingFit::kExact : SkBackingFit::kApprox;
         GrAA aa = GrAA(GrAAType::kCoverage == args.fAAType);
-        SoftwarePathData data(*boundsForMask, *args.fViewMatrix, *args.fShape, aa);
-        view = GrSWMaskHelper::MakeTexture(data.getMaskBounds(),
-                                           args.fContext,
-                                           fit,
-                                           [data{std::move(data)}](GrSWMaskHelper* helper) {
-            TRACE_EVENT0("skia.gpu", "SW Mask Render");
-            helper->drawShape(data.getShape(), data.getViewMatrix(), SkRegion::kReplace_Op,
-                              data.getAA(), 0xFF);
-        });
+
+        SkTaskGroup* taskGroup = nullptr;
+        if (auto direct = args.fContext->asDirectContext()) {
+            taskGroup = direct->priv().getTaskGroup();
+        }
+
+        if (taskGroup) {
+            view = make_deferred_mask_texture_view(args.fContext, fit, boundsForMask->size());
+            if (!view) {
+                return false;
+            }
+
+            auto uploader = std::make_unique<GrTDeferredProxyUploader<SoftwarePathData>>(
+                    *boundsForMask, *args.fViewMatrix, *args.fShape, aa);
+            GrTDeferredProxyUploader<SoftwarePathData>* uploaderRaw = uploader.get();
+
+            auto drawAndUploadMask = [uploaderRaw] {
+                TRACE_EVENT0("skia.gpu", "Threaded SW Mask Render");
+                GrSWMaskHelper helper(uploaderRaw->getPixels());
+                if (helper.init(uploaderRaw->data().getMaskBounds())) {
+                    helper.drawShape(uploaderRaw->data().getShape(),
+                                     *uploaderRaw->data().getViewMatrix(),
+                                     SkRegion::kReplace_Op, uploaderRaw->data().getAA(), 0xFF);
+                } else {
+                    SkDEBUGFAIL("Unable to allocate SW mask.");
+                }
+                uploaderRaw->signalAndFreeData();
+            };
+            taskGroup->add(std::move(drawAndUploadMask));
+            view.asTextureProxy()->texPriv().setDeferredUploader(std::move(uploader));
+        } else {
+            GrSWMaskHelper helper;
+            if (!helper.init(*boundsForMask)) {
+                return false;
+            }
+            helper.drawShape(*args.fShape, *args.fViewMatrix, SkRegion::kReplace_Op, aa, 0xFF);
+            view = helper.toTextureView(args.fContext, fit);
+        }
 
         if (!view) {
             return false;