Revert "Migrate GrSurfaceContext readPixels to take direct context"

This reverts commit d169e19.

Reason for revert: broke chrome via code generator

Original change's description:
> Migrate GrSurfaceContext readPixels to take direct context
> 
> After this lands we'll proceed up the stack and add the direct
> context requirement to the public API and SkImage.
> 
> Bug: skia:104662
> Change-Id: I4b2d779a7fcd65eec68e631757821ac8e136ddba
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/309044
> Commit-Queue: Adlai Holler <[email protected]>
> Reviewed-by: Robert Phillips <[email protected]>

[email protected],[email protected]

Change-Id: I6126f2dca4bc902c903512ac486e22841cc472e5
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:104662
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/309281
Reviewed-by: Adlai Holler <[email protected]>
Commit-Queue: Adlai Holler <[email protected]>

Author: Adlai-Holler

src/gpu/GrSurfaceContext.cpp

@@ -75,35 +75,30 @@ class GrSurfaceContext {
 
     /**
      * Reads a rectangle of pixels from the render target context.
-     * @param dContext      The direct context to use
      * @param dstInfo       image info for the destination
      * @param dst           destination pixels for the read
      * @param rowBytes      bytes in a row of 'dst'
      * @param srcPt         offset w/in the surface context from which to read
+     * @param direct        The direct context to use. If null will use our GrRecordingContext if it
      *                      is a GrDirectContext and fail otherwise.
      */
-    bool readPixels(GrDirectContext* dContext,
-                    const GrImageInfo& dstInfo,
-                    void* dst,
-                    size_t rowBytes,
-                    SkIPoint srcPt);
+    bool readPixels(const GrImageInfo& dstInfo, void* dst, size_t rowBytes, SkIPoint srcPt,
+                    GrDirectContext* direct = nullptr);
 
     using ReadPixelsCallback = SkImage::ReadPixelsCallback;
     using ReadPixelsContext  = SkImage::ReadPixelsContext;
     using RescaleGamma       = SkImage::RescaleGamma;
 
     // GPU implementation for SkImage:: and SkSurface::asyncRescaleAndReadPixels.
-    void asyncRescaleAndReadPixels(GrDirectContext*,
-                                   const SkImageInfo& info,
+    void asyncRescaleAndReadPixels(const SkImageInfo& info,
                                    const SkIRect& srcRect,
                                    RescaleGamma rescaleGamma,
                                    SkFilterQuality rescaleQuality,
                                    ReadPixelsCallback callback,
-                                   ReadPixelsContext callbackContext);
+                                   ReadPixelsContext context);
 
     // GPU implementation for SkImage:: and SkSurface::asyncRescaleAndReadPixelsYUV420.
-    void asyncRescaleAndReadPixelsYUV420(GrDirectContext*,
-                                         SkYUVColorSpace yuvColorSpace,
+    void asyncRescaleAndReadPixelsYUV420(SkYUVColorSpace yuvColorSpace,
                                          sk_sp<SkColorSpace> dstColorSpace,
                                          const SkIRect& srcRect,
                                          SkISize dstSize,
@@ -115,17 +110,15 @@ class GrSurfaceContext {
     /**
      * Writes a rectangle of pixels [srcInfo, srcBuffer, srcRowbytes] into the
      * renderTargetContext at the specified position.
-     * @param dContext      The direct context to use
      * @param srcInfo       image info for the source pixels
      * @param src           source for the write
      * @param rowBytes      bytes in a row of 'src'
      * @param dstPt         offset w/in the surface context at which to write
+     * @param direct        The direct context to use. If null will use our GrRecordingContext if it
+     *                      is a GrDirectContext and fail otherwise.
      */
-    bool writePixels(GrDirectContext* dContext,
-                     const GrImageInfo& srcInfo,
-                     const void* src,
-                     size_t rowBytes,
-                     SkIPoint dstPt);
+    bool writePixels(const GrImageInfo& srcInfo, const void* src, size_t rowBytes, SkIPoint dstPt,
+                     GrDirectContext* direct = nullptr);
 
     GrSurfaceProxy* asSurfaceProxy() { return fReadView.proxy(); }
     const GrSurfaceProxy* asSurfaceProxy() const { return fReadView.proxy(); }
@@ -211,11 +204,10 @@ class GrSurfaceContext {
     PixelTransferResult transferPixels(GrColorType colorType, const SkIRect& rect);
 
     // The async read step of asyncRescaleAndReadPixels()
-    void asyncReadPixels(GrDirectContext*,
-                         const SkIRect& srcRect,
-                         SkColorType,
-                         ReadPixelsCallback,
-                         ReadPixelsContext);
+    void asyncReadPixels(const SkIRect& rect,
+                         SkColorType colorType,
+                         ReadPixelsCallback callback,
+                         ReadPixelsContext context);
 
 private:
     friend class GrSurfaceProxy; // for copy

src/gpu/GrSurfaceContext.h

@@ -183,26 +183,21 @@ sk_sp<SkSpecialImage> SkGpuDevice::filterTexture(SkSpecialImage* srcImg,
 bool SkGpuDevice::onReadPixels(const SkPixmap& pm, int x, int y) {
     ASSERT_SINGLE_OWNER
 
-    // Context TODO: Elevate direct context requirement to public API
-    auto dContext = fContext->asDirectContext();
-    if (!dContext || !SkImageInfoValidConversion(pm.info(), this->imageInfo())) {
+    if (!SkImageInfoValidConversion(pm.info(), this->imageInfo())) {
         return false;
     }
 
-    return fRenderTargetContext->readPixels(dContext, pm.info(), pm.writable_addr(), pm.rowBytes(),
-                                            {x, y});
+    return fRenderTargetContext->readPixels(pm.info(), pm.writable_addr(), pm.rowBytes(), {x, y});
 }
 
 bool SkGpuDevice::onWritePixels(const SkPixmap& pm, int x, int y) {
     ASSERT_SINGLE_OWNER
 
-    // Context TODO: Elevate direct context requirement to public API
-    auto dContext = fContext->asDirectContext();
-    if (!dContext || !SkImageInfoValidConversion(this->imageInfo(), pm.info())) {
+    if (!SkImageInfoValidConversion(this->imageInfo(), pm.info())) {
         return false;
     }
 
-    return fRenderTargetContext->writePixels(dContext, pm.info(), pm.addr(), pm.rowBytes(), {x, y});
+    return fRenderTargetContext->writePixels(pm.info(), pm.addr(), pm.rowBytes(), {x, y});
 }
 
 bool SkGpuDevice::onAccessPixels(SkPixmap* pmap) {

src/gpu/SkGpuDevice.cpp

@@ -81,7 +81,7 @@ std::unique_ptr<GrFragmentProcessor> GrConfigConversionEffect::TestCreate(
 }
 #endif
 
-bool GrConfigConversionEffect::TestForPreservingPMConversions(GrDirectContext* dContext) {
+bool GrConfigConversionEffect::TestForPreservingPMConversions(GrDirectContext* context) {
     static constexpr int kSize = 256;
     static constexpr GrColorType kColorType = GrColorType::kRGBA_8888;
     SkAutoTMalloc<uint32_t> data(kSize * kSize * 3);
@@ -107,9 +107,9 @@ bool GrConfigConversionEffect::TestForPreservingPMConversions(GrDirectContext* d
     const SkImageInfo ii =
             SkImageInfo::Make(kSize, kSize, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
 
-    auto readRTC = GrRenderTargetContext::Make(dContext, kColorType, nullptr, SkBackingFit::kExact,
+    auto readRTC = GrRenderTargetContext::Make(context, kColorType, nullptr, SkBackingFit::kExact,
                                                {kSize, kSize});
-    auto tempRTC = GrRenderTargetContext::Make(dContext, kColorType, nullptr, SkBackingFit::kExact,
+    auto tempRTC = GrRenderTargetContext::Make(context, kColorType, nullptr, SkBackingFit::kExact,
                                                {kSize, kSize});
     if (!readRTC || !readRTC->asTextureProxy() || !tempRTC) {
         return false;
@@ -125,7 +125,7 @@ bool GrConfigConversionEffect::TestForPreservingPMConversions(GrDirectContext* d
     bitmap.installPixels(ii, srcData, 4 * kSize);
     bitmap.setImmutable();
 
-    GrBitmapTextureMaker maker(dContext, bitmap, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
+    GrBitmapTextureMaker maker(context, bitmap, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
     auto dataView = maker.view(GrMipmapped::kNo);
     if (!dataView) {
         return false;
@@ -144,7 +144,7 @@ bool GrConfigConversionEffect::TestForPreservingPMConversions(GrDirectContext* d
     paint1.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
     readRTC->fillRectToRect(nullptr, std::move(paint1), GrAA::kNo, SkMatrix::I(), kRect, kRect);
-    if (!readRTC->readPixels(dContext, ii, firstRead, 0, {0, 0})) {
+    if (!readRTC->readPixels(ii, firstRead, 0, {0, 0})) {
         return false;
     }
 
@@ -168,7 +168,7 @@ bool GrConfigConversionEffect::TestForPreservingPMConversions(GrDirectContext* d
 
     readRTC->fillRectToRect(nullptr, std::move(paint3), GrAA::kNo, SkMatrix::I(), kRect, kRect);
 
-    if (!readRTC->readPixels(dContext, ii, secondRead, 0, {0, 0})) {
+    if (!readRTC->readPixels(ii, secondRead, 0, {0, 0})) {
         return false;
     }
 

src/gpu/effects/generated/GrConfigConversionEffect.cpp

@@ -219,26 +219,27 @@ void GrAtlasManager::addGlyphToBulkAndSetUseToken(GrDrawOpAtlas::BulkUseTokenUpd
   * Write the contents of the surface proxy to a PNG. Returns true if successful.
   * @param filename      Full path to desired file
   */
-static bool save_pixels(GrDirectContext* dContext, GrSurfaceProxyView view, GrColorType colorType,
+static bool save_pixels(GrDirectContext* context, GrSurfaceProxyView view, GrColorType colorType,
                         const char* filename) {
     if (!view.proxy()) {
         return false;
     }
 
-    auto ii = SkImageInfo::Make(view.proxy()->dimensions(), kRGBA_8888_SkColorType,
-                                kPremul_SkAlphaType);
+    SkImageInfo ii =
+            SkImageInfo::Make(view.proxy()->dimensions(), kRGBA_8888_SkColorType,
+                              kPremul_SkAlphaType);
     SkBitmap bm;
     if (!bm.tryAllocPixels(ii)) {
         return false;
     }
 
-    auto sContext = GrSurfaceContext::Make(dContext, std::move(view), colorType,
+    auto sContext = GrSurfaceContext::Make(context, std::move(view), colorType,
                                            kUnknown_SkAlphaType, nullptr);
     if (!sContext || !sContext->asTextureProxy()) {
         return false;
     }
 
-    bool result = sContext->readPixels(dContext, ii, bm.getPixels(), bm.rowBytes(), {0, 0});
+    bool result = sContext->readPixels(ii, bm.getPixels(), bm.rowBytes(), {0, 0});
     if (!result) {
         SkDebugf("------ failed to read pixels for %s\n", filename);
         return false;

src/gpu/text/GrAtlasManager.cpp

@@ -126,21 +126,14 @@ void SkImage_Gpu::onAsyncRescaleAndReadPixels(const SkImageInfo& info,
                                               SkFilterQuality rescaleQuality,
                                               ReadPixelsCallback callback,
                                               ReadPixelsContext context) {
-    auto dContext = fContext->asDirectContext();
-    if (!dContext) {
-        // DDL TODO: buffer up the readback so it occurs when the DDL is drawn?
-        callback(context, nullptr);
-        return;
-    }
     GrColorType ct = SkColorTypeToGrColorType(this->colorType());
-    auto ctx = GrSurfaceContext::Make(dContext, fView, ct, this->alphaType(),
+    auto ctx = GrSurfaceContext::Make(fContext.get(), fView, ct, this->alphaType(),
                                       this->refColorSpace());
     if (!ctx) {
         callback(context, nullptr);
         return;
     }
-    ctx->asyncRescaleAndReadPixels(dContext, info, srcRect, rescaleGamma, rescaleQuality,
-                                   callback, context);
+    ctx->asyncRescaleAndReadPixels(info, srcRect, rescaleGamma, rescaleQuality, callback, context);
 }
 
 void SkImage_Gpu::onAsyncRescaleAndReadPixelsYUV420(SkYUVColorSpace yuvColorSpace,
@@ -151,21 +144,14 @@ void SkImage_Gpu::onAsyncRescaleAndReadPixelsYUV420(SkYUVColorSpace yuvColorSpac
                                                     SkFilterQuality rescaleQuality,
                                                     ReadPixelsCallback callback,
                                                     ReadPixelsContext context) {
-    auto dContext = fContext->asDirectContext();
-    if (!dContext) {
-        // DDL TODO: buffer up the readback so it occurs when the DDL is drawn?
-        callback(context, nullptr);
-        return;
-    }
     GrColorType ct = SkColorTypeToGrColorType(this->colorType());
-    auto ctx = GrSurfaceContext::Make(dContext, fView, ct, this->alphaType(),
+    auto ctx = GrSurfaceContext::Make(fContext.get(), fView, ct, this->alphaType(),
                                       this->refColorSpace());
     if (!ctx) {
         callback(context, nullptr);
         return;
     }
-    ctx->asyncRescaleAndReadPixelsYUV420(dContext,
-                                         yuvColorSpace,
+    ctx->asyncRescaleAndReadPixelsYUV420(yuvColorSpace,
                                          std::move(dstColorSpace),
                                          srcRect,
                                          dstSize,
@@ -679,13 +665,13 @@ sk_sp<SkImage> SkImage::MakeFromAHardwareBufferWithData(GrContext* context,
         return nullptr;
     }
 
-    auto dContext = GrAsDirectContext(context);
-    if (!dContext) {
+    auto direct = GrAsDirectContext(context);
+    if (!direct) {
         SkDebugf("Direct context required\n");
         return nullptr;
     }
 
-    GrBackendFormat backendFormat = GrAHardwareBufferUtils::GetBackendFormat(dContext,
+    GrBackendFormat backendFormat = GrAHardwareBufferUtils::GetBackendFormat(direct,
                                                                              hardwareBuffer,
                                                                              bufferDesc.format,
                                                                              true);
@@ -699,7 +685,7 @@ sk_sp<SkImage> SkImage::MakeFromAHardwareBufferWithData(GrContext* context,
     GrAHardwareBufferUtils::TexImageCtx deleteImageCtx = nullptr;
 
     GrBackendTexture backendTexture =
-            GrAHardwareBufferUtils::MakeBackendTexture(dContext, hardwareBuffer,
+            GrAHardwareBufferUtils::MakeBackendTexture(direct, hardwareBuffer,
                                                        bufferDesc.width, bufferDesc.height,
                                                        &deleteImageProc, &updateImageProc,
                                                        &deleteImageCtx, false, backendFormat, true);
@@ -716,7 +702,7 @@ sk_sp<SkImage> SkImage::MakeFromAHardwareBufferWithData(GrContext* context,
 
     GrColorType grColorType = SkColorTypeToGrColorType(colorType);
 
-    GrProxyProvider* proxyProvider = dContext->priv().proxyProvider();
+    GrProxyProvider* proxyProvider = direct->priv().proxyProvider();
     if (!proxyProvider) {
         return nullptr;
     }
@@ -731,26 +717,26 @@ sk_sp<SkImage> SkImage::MakeFromAHardwareBufferWithData(GrContext* context,
     sk_sp<SkColorSpace> cs = pixmap.refColorSpace();
     SkAlphaType at =  pixmap.alphaType();
 
-    GrSwizzle swizzle = dContext->priv().caps()->getReadSwizzle(backendFormat, grColorType);
+    GrSwizzle swizzle = direct->priv().caps()->getReadSwizzle(backendFormat, grColorType);
     GrSurfaceProxyView view(std::move(proxy), surfaceOrigin, swizzle);
-    sk_sp<SkImage> image = sk_make_sp<SkImage_Gpu>(sk_ref_sp(dContext), kNeedNewImageUniqueID, view,
+    sk_sp<SkImage> image = sk_make_sp<SkImage_Gpu>(sk_ref_sp(direct), kNeedNewImageUniqueID, view,
                                                    colorType, at, cs);
     if (!image) {
         return nullptr;
     }
 
-    GrDrawingManager* drawingManager = dContext->priv().drawingManager();
+    GrDrawingManager* drawingManager = direct->priv().drawingManager();
     if (!drawingManager) {
         return nullptr;
     }
 
-    GrSurfaceContext surfaceContext(dContext, std::move(view),
+    GrSurfaceContext surfaceContext(direct, std::move(view),
                                     SkColorTypeToGrColorType(pixmap.colorType()),
                                     pixmap.alphaType(), cs);
 
     SkImageInfo srcInfo = SkImageInfo::Make(bufferDesc.width, bufferDesc.height, colorType, at,
                                             std::move(cs));
-    surfaceContext.writePixels(dContext, srcInfo, pixmap.addr(0, 0), pixmap.rowBytes(), {0, 0});
+    surfaceContext.writePixels(srcInfo, pixmap.addr(0, 0), pixmap.rowBytes(), {0, 0});
 
     GrSurfaceProxy* p[1] = {surfaceContext.asSurfaceProxy()};
     drawingManager->flush(p, 1, SkSurface::BackendSurfaceAccess::kNoAccess, {}, nullptr);

src/image/SkImage_Gpu.cpp

@@ -86,8 +86,8 @@ bool SkImage_GpuBase::ValidateCompressedBackendTexture(const GrCaps* caps,
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 bool SkImage_GpuBase::getROPixels(SkBitmap* dst, CachingHint chint) const {
-    auto dContext = fContext->asDirectContext();
-    if (!dContext) {
+    auto direct = fContext->asDirectContext();
+    if (!direct) {
         // DDL TODO: buffer up the readback so it occurs when the DDL is drawn?
         return false;
     }
@@ -112,19 +112,18 @@ bool SkImage_GpuBase::getROPixels(SkBitmap* dst, CachingHint chint) const {
         }
     }
 
-    const GrSurfaceProxyView* view = this->view(dContext);
+    const GrSurfaceProxyView* view = this->view(direct);
     SkASSERT(view);
     GrColorType grColorType = SkColorTypeAndFormatToGrColorType(
             fContext->priv().caps(), this->colorType(), view->proxy()->backendFormat());
 
-    auto sContext = GrSurfaceContext::Make(dContext, *view, grColorType, this->alphaType(),
+    auto sContext = GrSurfaceContext::Make(direct, *view, grColorType, this->alphaType(),
                                            this->refColorSpace());
     if (!sContext) {
         return false;
     }
 
-    if (!sContext->readPixels(dContext, pmap.info(), pmap.writable_addr(), pmap.rowBytes(),
-                              {0, 0})) {
+    if (!sContext->readPixels(pmap.info(), pmap.writable_addr(), pmap.rowBytes(), {0, 0})) {
         return false;
     }
 
@@ -158,8 +157,8 @@ sk_sp<SkImage> SkImage_GpuBase::onMakeSubset(const SkIRect& subset,
 
 bool SkImage_GpuBase::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
                                    int srcX, int srcY, CachingHint) const {
-    auto dContext = fContext->asDirectContext();
-    if (!dContext) {
+    auto direct = fContext->asDirectContext();
+    if (!direct) {
         // DDL TODO: buffer up the readback so it occurs when the DDL is drawn?
         return false;
     }
@@ -168,18 +167,18 @@ bool SkImage_GpuBase::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels,
         return false;
     }
 
-    const GrSurfaceProxyView* view = this->view(dContext);
+    const GrSurfaceProxyView* view = this->view(direct);
     SkASSERT(view);
     GrColorType grColorType = SkColorTypeAndFormatToGrColorType(
-            dContext->priv().caps(), this->colorType(), view->proxy()->backendFormat());
+            fContext->priv().caps(), this->colorType(), view->proxy()->backendFormat());
 
-    auto sContext = GrSurfaceContext::Make(dContext, *view, grColorType, this->alphaType(),
+    auto sContext = GrSurfaceContext::Make(direct, *view, grColorType, this->alphaType(),
                                            this->refColorSpace());
     if (!sContext) {
         return false;
     }
 
-    return sContext->readPixels(dContext, dstInfo, dstPixels, dstRB, {srcX, srcY});
+    return sContext->readPixels(dstInfo, dstPixels, dstRB, {srcX, srcY});
 }
 
 GrSurfaceProxyView SkImage_GpuBase::refView(GrRecordingContext* context,