Remove call to copy in GrcontextPriv read/write pixel calls.

Instead we just directly do all those copies as draws.

Change-Id: I0cd9dfc6f96e35fbbc9c153a28a08eebf1d7b77f
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/216356
Commit-Queue: Greg Daniel <[email protected]>
Reviewed-by: Brian Salomon <[email protected]>
Reviewed-by: Robert Phillips <[email protected]>

Author: egdaniel

src/gpu/GrContextPriv.cpp

@@ -327,63 +327,50 @@ bool GrContextPriv::readSurfacePixels(GrSurfaceContext* src, int left, int top,
 
     if (!fContext->priv().caps()->surfaceSupportsReadPixels(srcSurface) ||
         canvas2DFastPath) {
-        GrSurfaceDesc desc;
-        desc.fWidth = width;
-        desc.fHeight = height;
-        desc.fSampleCnt = 1;
-
         GrBackendFormat format;
+        GrPixelConfig config;
         if (canvas2DFastPath) {
-            desc.fFlags = kRenderTarget_GrSurfaceFlag;
-            desc.fConfig = kRGBA_8888_GrPixelConfig;
+            config = kRGBA_8888_GrPixelConfig;
             format = this->caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);
         } else {
-            desc.fFlags = kNone_GrSurfaceFlags;
-            desc.fConfig = srcProxy->config();
+            config = srcProxy->config();
             format = srcProxy->backendFormat().makeTexture2D();
             if (!format.isValid()) {
                 return false;
             }
         }
+        sk_sp<SkColorSpace> cs = canvas2DFastPath ? nullptr : src->colorSpaceInfo().refColorSpace();
 
-        auto tempProxy = this->proxyProvider()->createProxy(
-                format, desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kApprox, SkBudgeted::kYes);
-        if (!tempProxy) {
-            return false;
-        }
-        sk_sp<GrSurfaceContext> tempCtx;
-        if (canvas2DFastPath) {
-            tempCtx = this->drawingManager()->makeRenderTargetContext(std::move(tempProxy), nullptr,
-                                                                      nullptr);
-            SkASSERT(tempCtx->asRenderTargetContext());
-            tempCtx->asRenderTargetContext()->discard();
-        } else {
-            tempCtx = this->drawingManager()->makeTextureContext(
-                    std::move(tempProxy), src->colorSpaceInfo().refColorSpace());
-        }
+        sk_sp<GrRenderTargetContext> tempCtx = this->makeDeferredRenderTargetContext(
+                format, SkBackingFit::kApprox, width, height, config, std::move(cs), 1,
+                GrMipMapped::kNo, kTopLeft_GrSurfaceOrigin, nullptr, SkBudgeted::kYes);
         if (!tempCtx) {
             return false;
         }
+
+        std::unique_ptr<GrFragmentProcessor> fp;
         if (canvas2DFastPath) {
-            GrPaint paint;
-            paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
-            auto fp = fContext->createPMToUPMEffect(
+            fp = fContext->createPMToUPMEffect(
                     GrSimpleTextureEffect::Make(sk_ref_sp(srcProxy->asTextureProxy()),
                                                 SkMatrix::I()));
             if (dstColorType == GrColorType::kBGRA_8888) {
                 fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), GrSwizzle::BGRA());
                 dstColorType = GrColorType::kRGBA_8888;
             }
-            if (!fp) {
-                return false;
-            }
-            paint.addColorFragmentProcessor(std::move(fp));
-            tempCtx->asRenderTargetContext()->fillRectToRect(
-                    GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(),
-                    SkRect::MakeWH(width, height), SkRect::MakeXYWH(left, top, width, height));
-        } else if (!tempCtx->copy(srcProxy, SkIRect::MakeXYWH(left, top, width, height), {0, 0})) {
+        } else {
+            fp = GrSimpleTextureEffect::Make(sk_ref_sp(srcProxy->asTextureProxy()), SkMatrix::I());
+        }
+        if (!fp) {
             return false;
         }
+        GrPaint paint;
+        paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
+        paint.addColorFragmentProcessor(std::move(fp));
+
+        tempCtx->asRenderTargetContext()->fillRectToRect(
+                GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(),
+                SkRect::MakeWH(width, height), SkRect::MakeXYWH(left, top, width, height));
+
         uint32_t flags = canvas2DFastPath ? 0 : pixelOpsFlags;
         return this->readSurfacePixels(tempCtx.get(), 0, 0, width, height, dstColorType,
                                        dstColorSpace, buffer, rowBytes, flags);
@@ -545,26 +532,26 @@ bool GrContextPriv::writeSurfacePixels(GrSurfaceContext* dst, int left, int top,
                                       srcColorSpace, buffer, rowBytes, flags)) {
             return false;
         }
+
+        std::unique_ptr<GrFragmentProcessor> fp;
         if (canvas2DFastPath) {
-            GrPaint paint;
-            paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
-            auto fp = fContext->createUPMToPMEffect(
+            fp = fContext->createUPMToPMEffect(
                     GrSimpleTextureEffect::Make(std::move(tempProxy), SkMatrix::I()));
             if (srcColorType == GrColorType::kBGRA_8888) {
                 fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), GrSwizzle::BGRA());
             }
-            if (!fp) {
-                return false;
-            }
-            paint.addColorFragmentProcessor(std::move(fp));
-            dst->asRenderTargetContext()->fillRectToRect(
-                    GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(),
-                    SkRect::MakeXYWH(left, top, width, height), SkRect::MakeWH(width, height));
         } else {
-            if (!dst->copy(tempProxy.get(), SkIRect::MakeWH(width, height), {left, top})) {
-                return false;
-            }
+            fp = GrSimpleTextureEffect::Make(std::move(tempProxy), SkMatrix::I());
+        }
+        if (!fp) {
+            return false;
         }
+        GrPaint paint;
+        paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
+        paint.addColorFragmentProcessor(std::move(fp));
+        dst->asRenderTargetContext()->fillRectToRect(
+                GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(),
+                SkRect::MakeXYWH(left, top, width, height), SkRect::MakeWH(width, height));
 
         return true;
     }

src/gpu/GrSurfaceContext.cpp

@@ -94,6 +94,10 @@ bool GrSurfaceContext::writePixels(const SkImageInfo& srcInfo, const void* srcBu
         return false;
     }
 
+    if (this->asSurfaceProxy()->readOnly()) {
+        return false;
+    }
+
     return direct->priv().writeSurfacePixels(this, x, y, srcInfo.width(), srcInfo.height(),
                                              colorType, srcInfo.colorSpace(), srcBuffer,
                                              srcRowBytes, flags);

tests/GrSurfaceTest.cpp

@@ -329,6 +329,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadOnlyTexture, reporter, context_info) {
 
         // Mip regen should not work with a read only texture.
         if (context->priv().caps()->mipMapSupport()) {
+            delete_backend_texture(context, backendTex);
             backendTex = context->createBackendTexture(
                     kSize, kSize, kRGBA_8888_SkColorType, GrMipMapped::kYes, GrRenderable::kYes);
             proxy = proxyProvider->wrapBackendTexture(backendTex, kTopLeft_GrSurfaceOrigin,
@@ -340,6 +341,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadOnlyTexture, reporter, context_info) {
                     context->priv().getGpu()->regenerateMipMapLevels(proxy->peekTexture());
             REPORTER_ASSERT(reporter, regenResult == (ioType == kRW_GrIOType));
         }
+        delete_backend_texture(context, backendTex);
     }
 }
 

tests/TestUtils.cpp

@@ -156,6 +156,9 @@ bool create_backend_texture(GrContext* context, GrBackendTexture* backendTex,
 }
 
 void delete_backend_texture(GrContext* context, const GrBackendTexture& backendTex) {
+    GrFlushInfo flushInfo;
+    flushInfo.fFlags = kSyncCpu_GrFlushFlag;
+    context->flush(flushInfo);
     context->deleteBackendTexture(backendTex);
 }