Start removal of tool usage of SkSurface::MakeFromBackendTextureAsRenderTarget.

Adds a new helper that creates a GrBackendRenderTarget using
GrGpu and then wraps it in a SkSurface. Uses the SkSurface
release proc to delete the BERT using GrGpu.

Upgrades GrGpu::createTestingOnlyBackendRenderTarget to create MSAA
buffers.

Updates many tests/tool to call sites to use the helper instead of
SkSurface::MakeFromBackendTextureAsRenderTarget.

Adds syncToCpu bool to SkSurface:: and GrContext::flushAndSubmit.

Bug: skia:9832

Change-Id: I73a8f0ce09dc6523729af0814464c6b6657fda06
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/293683
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
Reviewed-by: Jim Van Verth <jvanverth@google.com>
Reviewed-by: Kevin Lubick <kjlubick@google.com>

Author: bsalomon

BUILD.gn

@@ -1605,6 +1605,8 @@ if (skia_enable_tools) {
     deps = []
     public_deps = []
     sources = [
+      "tools/gpu/BackendSurfaceFactory.cpp",
+      "tools/gpu/BackendSurfaceFactory.h",
       "tools/gpu/BackendTextureImageFactory.cpp",
       "tools/gpu/BackendTextureImageFactory.h",
       "tools/gpu/FlushFinishTracker.cpp",

RELEASE_NOTES.txt

@@ -9,6 +9,8 @@ Milestone 88
 
   * <insert new release notes here>
 
+  * CPU sync bool added to SkSurface::flushAndSubmit() and GrContext::flushAndSubmit()
+
   * Removed legacy variant of SkImage::MakeFromYUVAPixmaps. Use the version that
     takes SkYUVAPixmaps instead. It has a more structured description of the
     planar configuration.

dm/DMSrcSink.cpp

@@ -51,6 +51,7 @@
 #include "tools/DDLTileHelper.h"
 #include "tools/Resources.h"
 #include "tools/debugger/DebugCanvas.h"
+#include "tools/gpu/BackendSurfaceFactory.h"
 #include "tools/gpu/MemoryCache.h"
 #if defined(SK_BUILD_FOR_WIN)
     #include "include/docs/SkXPSDocument.h"
@@ -1467,9 +1468,9 @@ Result GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream* dstStream, SkStri
     return this->onDraw(src, dst, dstStream, log, fBaseContextOptions);
 }
 
-sk_sp<SkSurface> GPUSink::createDstSurface(GrDirectContext* context, SkISize size,
-                                           GrBackendTexture* backendTexture,
-                                           GrBackendRenderTarget* backendRT) const {
+sk_sp<SkSurface> GPUSink::createDstSurface(GrDirectContext* context,
+                                           SkISize size,
+                                           GrBackendTexture* backendTexture) const {
     sk_sp<SkSurface> surface;
 
     SkImageInfo info = SkImageInfo::Make(size, fColorType, fAlphaType, fColorSpace);
@@ -1490,14 +1491,13 @@ sk_sp<SkSurface> GPUSink::createDstSurface(GrDirectContext* context, SkISize siz
                                                         fColorType, info.refColorSpace(), &props);
             break;
         case SkCommandLineConfigGpu::SurfType::kBackendRenderTarget:
-            if (1 == fSampleCount) {
-                auto colorType = SkColorTypeToGrColorType(info.colorType());
-                *backendRT = context->priv().getGpu()->createTestingOnlyBackendRenderTarget(
-                    info.width(), info.height(), colorType);
-                surface = SkSurface::MakeFromBackendRenderTarget(
-                    context, *backendRT, kBottomLeft_GrSurfaceOrigin, info.colorType(),
-                    info.refColorSpace(), &props);
-            }
+            surface = MakeBackendRenderTargetSurface(context,
+                                                     info.dimensions(),
+                                                     fSampleCount,
+                                                     kBottomLeft_GrSurfaceOrigin,
+                                                     info.colorType(),
+                                                     info.refColorSpace(),
+                                                     &props);
             break;
     }
 
@@ -1537,9 +1537,7 @@ Result GPUSink::onDraw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log,
     }
 
     GrBackendTexture backendTexture;
-    GrBackendRenderTarget backendRT;
-    sk_sp<SkSurface> surface = this->createDstSurface(direct, src.size(),
-                                                      &backendTexture, &backendRT);
+    sk_sp<SkSurface> surface = this->createDstSurface(direct, src.size(), &backendTexture);
     if (!surface) {
         return Result::Fatal("Could not create a surface.");
     }
@@ -1570,9 +1568,6 @@ Result GPUSink::onDraw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log,
         if (backendTexture.isValid()) {
             direct->deleteBackendTexture(backendTexture);
         }
-        if (backendRT.isValid()) {
-            direct->priv().getGpu()->deleteTestingOnlyBackendRenderTarget(backendRT);
-        }
     }
     if (grOptions.fPersistentCache) {
         direct->storeVkPipelineCacheData();
@@ -1749,9 +1744,7 @@ Result GPUOOPRSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* lo
     SkASSERT(context->priv().getGpu());
 
     GrBackendTexture backendTexture;
-    GrBackendRenderTarget backendRT;
-    sk_sp<SkSurface> surface = this->createDstSurface(context, src.size(),
-                                                      &backendTexture, &backendRT);
+    sk_sp<SkSurface> surface = this->createDstSurface(context, src.size(), &backendTexture);
     if (!surface) {
         return Result::Fatal("Could not create a surface.");
     }
@@ -1775,9 +1768,6 @@ Result GPUOOPRSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* lo
     if (backendTexture.isValid()) {
         context->deleteBackendTexture(backendTexture);
     }
-    if (backendRT.isValid()) {
-        context->priv().getGpu()->deleteTestingOnlyBackendRenderTarget(backendRT);
-    }
 
     return Result::Ok();
 }
@@ -1929,9 +1919,7 @@ Result GPUDDLSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log
     mainTestCtx->makeCurrent();
 
     GrBackendTexture backendTexture;
-    GrBackendRenderTarget backendRT;
-    sk_sp<SkSurface> surface = this->createDstSurface(mainCtx, src.size(),
-                                                      &backendTexture, &backendRT);
+    sk_sp<SkSurface> surface = this->createDstSurface(mainCtx, src.size(), &backendTexture);
     if (!surface) {
         return Result::Fatal("Could not create a surface.");
     }
@@ -1965,9 +1953,6 @@ Result GPUDDLSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log
     if (backendTexture.isValid()) {
         mainCtx->deleteBackendTexture(backendTexture);
     }
-    if (backendRT.isValid()) {
-        mainCtx->priv().getGpu()->deleteTestingOnlyBackendRenderTarget(backendRT);
-    }
 
     return Result::Ok();
 }

dm/DMSrcSink.h

@@ -407,8 +407,7 @@ class GPUSink : public Sink {
     }
 
 protected:
-    sk_sp<SkSurface> createDstSurface(GrDirectContext*, SkISize size, GrBackendTexture*,
-                                      GrBackendRenderTarget*) const;
+    sk_sp<SkSurface> createDstSurface(GrDirectContext*, SkISize size, GrBackendTexture*) const;
     bool readBack(SkSurface*, SkBitmap* dst) const;
 
 private:

include/core/SkSurface.h

@@ -900,9 +900,9 @@ class SK_API SkSurface : public SkRefCnt {
         correct ordering when the surface backing store is accessed outside Skia (e.g. direct use of
         the 3D API or a windowing system). GrContext has additional flush and submit methods that
         apply to all surfaces and images created from a GrContext. This is equivalent to calling
-        SkSurface::flush with a default GrFlushInfo followed by GrContext::submit.
+        SkSurface::flush with a default GrFlushInfo followed by GrContext::submit(syncCpu).
     */
-    void flushAndSubmit();
+    void flushAndSubmit(bool syncCpu = false);
 
     enum class BackendSurfaceAccess {
         kNoAccess,  //!< back-end object will not be used by client

include/gpu/GrContext.h

@@ -332,11 +332,11 @@ class SK_API GrContext : public GrRecordingContext {
     /**
      * Call to ensure all drawing to the context has been flushed and submitted to the underlying 3D
      * API. This is equivalent to calling GrContext::flush with a default GrFlushInfo followed by
-     * GrContext::submit.
+     * GrContext::submit(syncCpu).
      */
-    void flushAndSubmit() {
+    void flushAndSubmit(bool syncCpu = false) {
         this->flush(GrFlushInfo());
-        this->submit();
+        this->submit(syncCpu);
     }
 
     /**

modules/canvaskit/canvaskit_bindings.cpp

@@ -1647,7 +1647,9 @@ EMSCRIPTEN_BINDINGS(Skia) {
 
     class_<SkSurface>("SkSurface")
         .smart_ptr<sk_sp<SkSurface>>("sk_sp<SkSurface>")
-        .function("_flush", select_overload<void()>(&SkSurface::flushAndSubmit))
+        .function("_flush",  optional_override([](SkSurface& self) {
+            self.flushAndSubmit(false);
+        }))
         .function("getCanvas", &SkSurface::getCanvas, allow_raw_pointers())
         .function("imageInfo", optional_override([](SkSurface& self)->SimpleImageInfo {
             const auto& ii = self.imageInfo();

src/gpu/GrGpu.h

@@ -666,9 +666,22 @@ class GrGpu : public SkRefCnt {
     /** Check a handle represents an actual texture in the backend API that has not been freed. */
     virtual bool isTestingOnlyBackendTexture(const GrBackendTexture&) const = 0;
 
-    virtual GrBackendRenderTarget createTestingOnlyBackendRenderTarget(int w, int h,
-                                                                       GrColorType) = 0;
+    /**
+     * Creates a GrBackendRenderTarget that can be wrapped using
+     * SkSurface::MakeFromBackendRenderTarget. Ideally this is a non-textureable allocation to
+     * differentiate from testing with SkSurface::MakeFromBackendTexture. When sampleCnt > 1 this
+     * is used to test client wrapped allocations with MSAA where Skia does not allocate a separate
+     * buffer for resolving. If the color is non-null the backing store should be cleared to the
+     * passed in color.
+     */
+    virtual GrBackendRenderTarget createTestingOnlyBackendRenderTarget(SkISize,
+                                                                       GrColorType,
+                                                                       int sampleCount = 1) = 0;
 
+    /**
+     * Deletes a GrBackendRenderTarget allocated with the above. Synchronization to make this safe
+     * is up to the caller.
+     */
     virtual void deleteTestingOnlyBackendRenderTarget(const GrBackendRenderTarget&) = 0;
 
     // This is only to be used in GL-specific tests.

src/gpu/GrSurfaceContext.cpp

@@ -207,45 +207,75 @@ bool GrSurfaceContext::readPixels(GrDirectContext* dContext, const GrImageInfo&
     }
 
     if (readFlag == GrCaps::SurfaceReadPixelsSupport::kCopyToTexture2D || canvas2DFastPath) {
-        GrColorType colorType = (canvas2DFastPath || srcIsCompressed)
-                                    ? GrColorType::kRGBA_8888 : this->colorInfo().colorType();
-        sk_sp<SkColorSpace> cs = canvas2DFastPath ? nullptr : this->colorInfo().refColorSpace();
-
-        auto tempCtx = GrRenderTargetContext::Make(
-                dContext, colorType, std::move(cs), SkBackingFit::kApprox, dstInfo.dimensions(),
-                1, GrMipmapped::kNo, GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
-        if (!tempCtx) {
-            return false;
-        }
+        std::unique_ptr<GrSurfaceContext> tempCtx;
+        if (this->asTextureProxy()) {
+            GrColorType colorType = (canvas2DFastPath || srcIsCompressed)
+                                            ? GrColorType::kRGBA_8888
+                                            : this->colorInfo().colorType();
+            sk_sp<SkColorSpace> cs = canvas2DFastPath ? nullptr : this->colorInfo().refColorSpace();
+
+            tempCtx = GrRenderTargetContext::Make(
+                    dContext, colorType, std::move(cs), SkBackingFit::kApprox, dstInfo.dimensions(),
+                    1, GrMipMapped::kNo, GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
+            if (!tempCtx) {
+                return false;
+            }
 
-        std::unique_ptr<GrFragmentProcessor> fp;
-        if (canvas2DFastPath) {
-            fp = dContext->priv().createPMToUPMEffect(
-                    GrTextureEffect::Make(this->readSurfaceView(), this->colorInfo().alphaType()));
-            if (dstInfo.colorType() == GrColorType::kBGRA_8888) {
-                fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), GrSwizzle::BGRA());
-                dstInfo = dstInfo.makeColorType(GrColorType::kRGBA_8888);
+            std::unique_ptr<GrFragmentProcessor> fp;
+            if (canvas2DFastPath) {
+                fp = dContext->priv().createPMToUPMEffect(GrTextureEffect::Make(
+                        this->readSurfaceView(), this->colorInfo().alphaType()));
+                if (dstInfo.colorType() == GrColorType::kBGRA_8888) {
+                    fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), GrSwizzle::BGRA());
+                    dstInfo = dstInfo.makeColorType(GrColorType::kRGBA_8888);
+                }
+                // The render target context is incorrectly tagged as kPremul even though we're
+                // writing unpremul data thanks to the PMToUPM effect. Fake out the dst alpha type
+                // so we don't double unpremul.
+                dstInfo = dstInfo.makeAlphaType(kPremul_SkAlphaType);
+            } else {
+                fp = GrTextureEffect::Make(this->readSurfaceView(), this->colorInfo().alphaType());
+            }
+            if (!fp) {
+                return false;
             }
-            // The render target context is incorrectly tagged as kPremul even though we're writing
-            // unpremul data thanks to the PMToUPM effect. Fake out the dst alpha type so we don't
-            // double unpremul.
-            dstInfo = dstInfo.makeAlphaType(kPremul_SkAlphaType);
+            GrPaint paint;
+            paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
+            paint.setColorFragmentProcessor(std::move(fp));
+
+            tempCtx->asRenderTargetContext()->fillRectToRect(
+                    nullptr, std::move(paint), GrAA::kNo, SkMatrix::I(),
+                    SkRect::MakeWH(dstInfo.width(), dstInfo.height()),
+                    SkRect::MakeXYWH(pt.fX, pt.fY, dstInfo.width(), dstInfo.height()));
+            pt = {0, 0};
         } else {
-            fp = GrTextureEffect::Make(this->readSurfaceView(), this->colorInfo().alphaType());
-        }
-        if (!fp) {
-            return false;
+            auto restrictions = this->caps()->getDstCopyRestrictions(this->asRenderTargetProxy(),
+                                                                     this->colorInfo().colorType());
+            sk_sp<GrSurfaceProxy> copy;
+            static constexpr auto kFit = SkBackingFit::kExact;
+            static constexpr auto kBudgeted = SkBudgeted::kYes;
+            static constexpr auto kMipMapped = GrMipMapped::kNo;
+            if (restrictions.fMustCopyWholeSrc) {
+                copy = GrSurfaceProxy::Copy(fContext, srcProxy, this->origin(), kMipMapped, kFit,
+                                            kBudgeted);
+            } else {
+                auto srcRect = SkIRect::MakeXYWH(pt.fX, pt.fY, dstInfo.width(), dstInfo.height());
+                copy = GrSurfaceProxy::Copy(fContext, srcProxy, this->origin(), kMipMapped, srcRect,
+                                            kFit, kBudgeted, restrictions.fRectsMustMatch);
+                pt = {0, 0};
+            }
+            if (!copy) {
+                return false;
+            }
+            GrSurfaceProxyView view{std::move(copy), this->origin(), this->readSwizzle()};
+            tempCtx = GrSurfaceContext::Make(dContext,
+                                             std::move(view),
+                                             this->colorInfo().colorType(),
+                                             this->colorInfo().alphaType(),
+                                             this->colorInfo().refColorSpace());
+            SkASSERT(tempCtx);
         }
-        GrPaint paint;
-        paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
-        paint.setColorFragmentProcessor(std::move(fp));
-
-        tempCtx->asRenderTargetContext()->fillRectToRect(
-                nullptr, std::move(paint), GrAA::kNo, SkMatrix::I(),
-                SkRect::MakeWH(dstInfo.width(), dstInfo.height()),
-                SkRect::MakeXYWH(pt.fX, pt.fY, dstInfo.width(), dstInfo.height()));
-
-        return tempCtx->readPixels(dContext, dstInfo, dst, rowBytes, {0, 0});
+        return tempCtx->readPixels(dContext, dstInfo, dst, rowBytes, pt);
     }
 
     bool flip = this->origin() == kBottomLeft_GrSurfaceOrigin;

src/gpu/d3d/GrD3DCaps.cpp

@@ -911,8 +911,14 @@ GrCaps::SurfaceReadPixelsSupport GrD3DCaps::surfaceSupportsReadPixels(
         if (GrDxgiFormatIsCompressed(tex->dxgiFormat())) {
             return SurfaceReadPixelsSupport::kCopyToTexture2D;
         }
+        return SurfaceReadPixelsSupport::kSupported;
+    } else if (auto rt = static_cast<const GrD3DRenderTarget*>(surface->asRenderTarget())) {
+        if (rt->numSamples() > 1) {
+            return SurfaceReadPixelsSupport::kCopyToTexture2D;
+        }
+        return SurfaceReadPixelsSupport::kSupported;
     }
-    return SurfaceReadPixelsSupport::kSupported;
+    return SurfaceReadPixelsSupport::kUnsupported;
 }
 
 bool GrD3DCaps::onSurfaceSupportsWritePixels(const GrSurface* surface) const {