Migrate MakeTextureImage to take GrDirectContext

This is part of a larger effort to force SkImage users to specify
the direct context they want to use when manipulating GPU images.

Chrome CL 2299194 (landed) enables the staging flag.

bug: skia:10466
Change-Id: I959db57dd8dca5c2622eb5ffaa7de161c4d6d8f0
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/302643
Commit-Queue: Brian Salomon <bsalomon@google.com>
Auto-Submit: Adlai Holler <adlai@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>

Author: Adlai-Holler

bench/BulkRectBench.cpp

@@ -215,15 +215,14 @@ class BulkRectBench : public Benchmark {
         // Push the skimages to the GPU when using the GPU backend so that the texture creation is
         // not part of the bench measurements. Always remake the images since they are so simple,
         // and since they are context-specific, this works when the bench runs multiple GPU backends
-        auto context = canvas->recordingContext() ? canvas->recordingContext()->asDirectContext()
-                                                  : nullptr;
+        auto direct = GrAsDirectContext(canvas->recordingContext());
         for (int i = 0; i < kImageCount; ++i) {
             SkBitmap bm;
             bm.allocN32Pixels(256, 256);
             bm.eraseColor(fColors[i].toSkColor());
             auto image = SkImage::MakeFromBitmap(bm);
 
-            fImages[i] = context ? image->makeTextureImage(context) : std::move(image);
+            fImages[i] = direct ? image->makeTextureImage(direct) : std::move(image);
         }
     }
 

bench/ImageFilterDAGBench.cpp

@@ -73,10 +73,9 @@ class ImageMakeWithFilterDAGBench : public Benchmark {
         SkIPoint offset = SkIPoint::Make(0, 0);
         SkIRect discardSubset;
 
-        auto context = canvas->recordingContext() ? canvas->recordingContext()->asDirectContext()
-                                                  : nullptr;
+        auto direct = GrAsDirectContext(canvas->recordingContext());
         // makeWithFilter will only use the GPU backend if the image is already a texture
-        sk_sp<SkImage> image = fImage->makeTextureImage(context);
+        sk_sp<SkImage> image = fImage->makeTextureImage(direct);
         if (!image) {
             image = fImage;
         }

gm/bc1_transparency.cpp

@@ -8,7 +8,7 @@
 #include "gm/gm.h"
 #include "include/core/SkCanvas.h"
 #include "include/core/SkImage.h"
-#include "include/gpu/GrContext.h"
+#include "include/gpu/GrDirectContext.h"
 #include "include/gpu/GrRecordingContext.h"
 #include "src/core/SkCompressedDataUtils.h"
 #include "src/gpu/GrCaps.h"
@@ -99,10 +99,10 @@ static sk_sp<SkData> make_compressed_data() {
     return tmp;
 }
 
-static sk_sp<SkImage> data_to_img(GrContext *context, sk_sp<SkData> data,
+static sk_sp<SkImage> data_to_img(GrDirectContext *direct, sk_sp<SkData> data,
                                   SkImage::CompressionType compression) {
-    if (context) {
-        return SkImage::MakeTextureFromCompressed(context, std::move(data),
+    if (direct) {
+        return SkImage::MakeTextureFromCompressed(direct, std::move(data),
                                                   kImgWidth,
                                                   kImgHeight,
                                                   compression,
@@ -180,16 +180,16 @@ class BC1TransparencyGM : public GM {
     }
 
     void onDraw(SkCanvas* canvas) override {
-        auto context = canvas->getGrContext();
+        auto direct = GrAsDirectContext(canvas->recordingContext());
 
-        sk_sp<SkImage> rgbImg = data_to_img(context, fBC1Data,
+        sk_sp<SkImage> rgbImg = data_to_img(direct, fBC1Data,
                                             SkImage::CompressionType::kBC1_RGB8_UNORM);
 
-        sk_sp<SkImage> rgbaImg = data_to_img(context, fBC1Data,
+        sk_sp<SkImage> rgbaImg = data_to_img(direct, fBC1Data,
                                              SkImage::CompressionType::kBC1_RGBA8_UNORM);
 
-        draw_image(context, canvas, rgbImg, kPad, kPad);
-        draw_image(context, canvas, rgbaImg, kPad, 2 * kPad + kImgHeight);
+        draw_image(direct, canvas, rgbImg, kPad, kPad);
+        draw_image(direct, canvas, rgbaImg, kPad, 2 * kPad + kImgHeight);
     }
 
 private:

gm/compressed_textures.cpp

@@ -21,7 +21,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
 #include "include/core/SkString.h"
-#include "include/gpu/GrContext.h"
+#include "include/gpu/GrDirectContext.h"
 #include "include/gpu/GrRecordingContext.h"
 #include "src/core/SkCompressedDataUtils.h"
 #include "src/core/SkMipmap.h"
@@ -31,7 +31,6 @@
 #include "src/image/SkImage_Base.h"
 #include "third_party/etc1/etc1.h"
 
-class GrContext;
 class GrRenderTargetContext;
 
 static SkPoint gen_pt(float angle, const SkVector& scale) {
@@ -213,26 +212,26 @@ class CompressedTexturesGM : public skiagm::GM {
     }
 
     void onDraw(SkCanvas* canvas) override {
-        GrContext* context = canvas->getGrContext();
+        auto direct = GrAsDirectContext(canvas->recordingContext());
 
-        this->drawCell(context, canvas, fOpaqueETC2Data,
+        this->drawCell(direct, canvas, fOpaqueETC2Data,
                        SkImage::CompressionType::kETC2_RGB8_UNORM, { kPad, kPad });
 
-        this->drawCell(context, canvas, fOpaqueBC1Data,
+        this->drawCell(direct, canvas, fOpaqueBC1Data,
                        SkImage::CompressionType::kBC1_RGB8_UNORM, { 2*kPad + kCellWidth, kPad });
 
-        this->drawCell(context, canvas, fTransparentBC1Data,
+        this->drawCell(direct, canvas, fTransparentBC1Data,
                        SkImage::CompressionType::kBC1_RGBA8_UNORM,
                        { 2*kPad + kCellWidth, 2*kPad + kBaseTexHeight });
     }
 
 private:
-    void drawCell(GrContext* context, SkCanvas* canvas, sk_sp<SkData> data,
+    void drawCell(GrDirectContext* direct, SkCanvas* canvas, sk_sp<SkData> data,
                   SkImage::CompressionType compression, SkIVector offset) {
 
         sk_sp<SkImage> image;
-        if (context) {
-            image = SkImage::MakeTextureFromCompressed(context, std::move(data),
+        if (direct) {
+            image = SkImage::MakeTextureFromCompressed(direct, std::move(data),
                                                        fImgDimensions.width(),
                                                        fImgDimensions.height(),
                                                        compression, GrMipMapped::kYes);
@@ -255,7 +254,7 @@ class CompressedTexturesGM : public skiagm::GM {
 
         bool isCompressed = false;
         if (image->isTextureBacked()) {
-            const GrCaps* caps = context->priv().caps();
+            const GrCaps* caps = direct->priv().caps();
 
             GrTextureProxy* proxy = as_IB(image)->peekProxy();
             isCompressed = caps->isFormatCompressed(proxy->backendFormat());

gm/exoticformats.cpp

@@ -9,7 +9,7 @@
 #include "include/core/SkCanvas.h"
 #include "include/core/SkImage.h"
 #include "include/core/SkStream.h"
-#include "include/gpu/GrContext.h"
+#include "include/gpu/GrDirectContext.h"
 #include "include/gpu/GrRecordingContext.h"
 #include "src/core/SkCompressedDataUtils.h"
 #include "src/core/SkMipmap.h"
@@ -301,9 +301,10 @@ static sk_sp<SkData> load_dds(const char* filename, ImageInfo* imageInfo) {
 }
 
 //-------------------------------------------------------------------------------------------------
-static sk_sp<SkImage> data_to_img(GrContext *context, sk_sp<SkData> data, const ImageInfo& info) {
-    if (context) {
-        return SkImage::MakeTextureFromCompressed(context, std::move(data),
+static sk_sp<SkImage> data_to_img(GrDirectContext *direct, sk_sp<SkData> data,
+                                  const ImageInfo& info) {
+    if (direct) {
+        return SkImage::MakeTextureFromCompressed(direct, std::move(data),
                                                   info.fDim.fWidth,
                                                   info.fDim.fHeight,
                                                   info.fCompressionType,
@@ -335,7 +336,7 @@ class ExoticFormatsGM : public GM {
         return SkISize::Make(2*kImgWidthHeight + 3 * kPad, kImgWidthHeight + 2 * kPad);
     }
 
-    void loadImages(GrContext *context) {
+    void loadImages(GrDirectContext *direct) {
 
         if (!fETC1Image) {
             ImageInfo info;
@@ -345,7 +346,7 @@ class ExoticFormatsGM : public GM {
                 SkASSERT(info.fMipMapped == GrMipMapped::kNo);
                 SkASSERT(info.fCompressionType == SkImage::CompressionType::kETC2_RGB8_UNORM);
 
-                fETC1Image = data_to_img(context, std::move(data), info);
+                fETC1Image = data_to_img(direct, std::move(data), info);
             } else {
                 SkDebugf("failed to load flower-etc1.ktx\n");
             }
@@ -359,7 +360,7 @@ class ExoticFormatsGM : public GM {
                 SkASSERT(info.fMipMapped == GrMipMapped::kNo);
                 SkASSERT(info.fCompressionType == SkImage::CompressionType::kBC1_RGB8_UNORM);
 
-                fBC1Image = data_to_img(context, std::move(data), info);
+                fBC1Image = data_to_img(direct, std::move(data), info);
             } else {
                 SkDebugf("failed to load flower-bc1.dds\n");
             }
@@ -394,12 +395,18 @@ class ExoticFormatsGM : public GM {
     }
 
     void onDraw(SkCanvas* canvas) override {
-        GrContext* context = canvas->getGrContext();
+        auto recording = canvas->recordingContext();
+        auto direct = GrAsDirectContext(recording);
 
-        this->loadImages(context);
+        // In DDL mode, these draws will be dropped.
+        if (recording && !direct) {
+            return;
+        }
+
+        this->loadImages(direct);
 
-        this->drawImage(context, canvas, fETC1Image.get(), kPad, kPad);
-        this->drawImage(context, canvas, fBC1Image.get(), kImgWidthHeight + 2 * kPad, kPad);
+        this->drawImage(direct, canvas, fETC1Image.get(), kPad, kPad);
+        this->drawImage(direct, canvas, fBC1Image.get(), kImgWidthHeight + 2 * kPad, kPad);
     }
 
 private:

gm/flippity.cpp

@@ -81,7 +81,7 @@ static const SkMatrix kUVMatrices[kNumMatrices] = {
 
 
 // Create a fixed size text label like "LL" or "LR".
-static sk_sp<SkImage> make_text_image(GrContext* context, const char* text, SkColor color) {
+static sk_sp<SkImage> make_text_image(GrDirectContext* direct, const char* text, SkColor color) {
     SkPaint paint;
     paint.setAntiAlias(true);
     paint.setColor(color);
@@ -107,7 +107,7 @@ static sk_sp<SkImage> make_text_image(GrContext* context, const char* text, SkCo
 
     sk_sp<SkImage> image = surf->makeImageSnapshot();
 
-    return image->makeTextureImage(context);
+    return image->makeTextureImage(direct);
 }
 
 // Create an image with each corner marked w/ "LL", "LR", etc., with the origin either bottom-left
@@ -231,7 +231,7 @@ class FlippityGM : public skiagm::GpuGM {
         canvas->restore();
     }
 
-    void makeLabels(GrDirectContext* context) {
+    void makeLabels(GrDirectContext* direct) {
         if (fLabels.count()) {
             return;
         }
@@ -246,7 +246,7 @@ class FlippityGM : public skiagm::GpuGM {
         };
 
         for (int i = 0; i < kNumLabels; ++i) {
-            fLabels.push_back(make_text_image(context, kLabelText[i], kLabelColors[i]));
+            fLabels.push_back(make_text_image(direct, kLabelText[i], kLabelColors[i]));
         }
         SkASSERT(kNumLabels == fLabels.count());
     }

gm/imagefilters.cpp

@@ -28,6 +28,7 @@
 #include "include/effects/SkHighContrastFilter.h"
 #include "include/effects/SkImageFilters.h"
 #include "include/effects/SkShaderMaskFilter.h"
+#include "include/gpu/GrDirectContext.h"
 #include "tools/Resources.h"
 #include "tools/ToolUtils.h"
 
@@ -200,9 +201,9 @@ DEF_GM(return new SaveLayerWithBackdropGM();)
 // normally be a sprite draw that could avoid an auto-saveLayer.
 DEF_SIMPLE_GM(imagefilters_effect_order, canvas, 512, 512) {
     sk_sp<SkImage> image(GetResourceAsImage("images/mandrill_256.png"));
-    if (canvas->getGrContext()) {
-        sk_sp<SkImage> gpuImage = image->makeTextureImage(canvas->getGrContext());
-        if (gpuImage) {
+    auto direct = GrAsDirectContext(canvas->recordingContext());
+    if (direct) {
+        if (sk_sp<SkImage> gpuImage = image->makeTextureImage(direct)) {
             image = std::move(gpuImage);
         }
     }

gm/imagemakewithfilter.cpp

@@ -28,7 +28,7 @@
 
 #include "include/effects/SkImageFilters.h"
 
-#include "include/gpu/GrContext.h"
+#include "include/gpu/GrDirectContext.h"
 
 #include "tools/Resources.h"
 #include "tools/ToolUtils.h"
@@ -270,12 +270,12 @@ class ImageMakeWithFilterGM : public skiagm::GM {
         // These need to be GPU-backed when on the GPU to ensure that the image filters use the GPU
         // code paths (otherwise they may choose to do CPU filtering then upload)
         sk_sp<SkImage> mainImage, auxImage;
-        if (canvas->recordingContext()) {
-            if (canvas->recordingContext()->abandoned()) {
+        if (auto direct = GrAsDirectContext(canvas->recordingContext())) {
+            if (direct->abandoned()) {
                 return;
             }
-            mainImage = fMainImage->makeTextureImage(canvas->getGrContext());
-            auxImage = fAuxImage->makeTextureImage(canvas->getGrContext());
+            mainImage = fMainImage->makeTextureImage(direct);
+            auxImage = fAuxImage->makeTextureImage(direct);
         } else {
             mainImage = fMainImage;
             auxImage = fAuxImage;

gm/readpixels.cpp

@@ -22,6 +22,7 @@
 #include "include/core/SkStream.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
+#include "include/gpu/GrDirectContext.h"
 #include "include/third_party/skcms/skcms.h"
 #include "tools/Resources.h"
 
@@ -164,8 +165,8 @@ class ReadPixelsGM : public skiagm::GM {
                 if (!image) {
                     continue;
                 }
-                if (GrContext* context = canvas->getGrContext()) {
-                    image = image->makeTextureImage(context);
+                if (auto direct = GrAsDirectContext(canvas->recordingContext())) {
+                    image = image->makeTextureImage(direct);
                 }
                 if (image) {
                     for (SkColorType dstColorType : colorTypes) {

include/core/SkImage.h

@@ -252,16 +252,17 @@ class SK_API SkImage : public SkRefCnt {
      *  If the encoded format is not supported, or subset is outside of the bounds of the decoded
      *  image, nullptr is returned.
      *
+     *  @param direct   the GrDirectContext in play
      *  @param encoded  the encoded data
      *  @param length   the number of bytes of encoded data
      *  @param subset   the bounds of the pixels within the decoded image to return. may be null.
      *  @return         created SkImage, or nullptr
      */
-    static sk_sp<SkImage> DecodeToTexture(GrContext* ctx, const void* encoded, size_t length,
-                                          const SkIRect* subset = nullptr);
-    static sk_sp<SkImage> DecodeToTexture(GrContext* ctx, const sk_sp<SkData>& data,
+    static sk_sp<SkImage> DecodeToTexture(GrDirectContext* direct, const void* encoded,
+                                          size_t length, const SkIRect* subset = nullptr);
+    static sk_sp<SkImage> DecodeToTexture(GrDirectContext* direct, const sk_sp<SkData>& data,
                                           const SkIRect* subset = nullptr) {
-        return DecodeToTexture(ctx, data->data(), data->size(), subset);
+        return DecodeToTexture(direct, data->data(), data->size(), subset);
     }
 
     /*
@@ -306,7 +307,7 @@ class SK_API SkImage : public SkRefCnt {
         @param isProtected do the contents of 'data' require DRM protection (on Vulkan)?
         @return            created SkImage, or nullptr
     */
-    static sk_sp<SkImage> MakeTextureFromCompressed(GrContext* context,
+    static sk_sp<SkImage> MakeTextureFromCompressed(GrDirectContext* direct,
                                                     sk_sp<SkData> data,
                                                     int width, int height,
                                                     CompressionType type,
@@ -319,11 +320,7 @@ class SK_API SkImage : public SkRefCnt {
                                              int width, int height,
                                              CompressionType type,
                                              GrMipMapped mipMapped = GrMipMapped::kNo,
-                                             GrProtected isProtected = GrProtected::kNo) {
-        return MakeTextureFromCompressed(context, data, width, height, type,
-                                         mipMapped, isProtected);
-
-    }
+                                             GrProtected isProtected = GrProtected::kNo);
 
     /** Creates a CPU-backed SkImage from compressed data.
 
@@ -1224,17 +1221,23 @@ class SK_API SkImage : public SkRefCnt {
         mipMapped is compatible with the backing GPU texture. SkBudgeted is ignored in this case.
 
         Returns nullptr if context is nullptr, or if SkImage was created with another
-        GrContext.
+        GrDirectContext.
 
-        @param GrContext      GPU context
-        @param GrMipMapped    whether created SkImage texture must allocate mip map levels
-        @param SkBudgeted     whether to count a newly created texture for the returned image
-                              counts against the GrContext's budget.
-        @return               created SkImage, or nullptr
+        @param GrDirectContext the GrDirectContext in play, if it exists
+        @param GrMipMapped     whether created SkImage texture must allocate mip map levels
+        @param SkBudgeted      whether to count a newly created texture for the returned image
+                               counts against the GrContext's budget.
+        @return                created SkImage, or nullptr
     */
+#ifndef SK_IMAGE_MAKE_TEXTURE_IMAGE_ALLOW_GR_CONTEXT
+    sk_sp<SkImage> makeTextureImage(GrDirectContext*,
+                                    GrMipMapped = GrMipMapped::kNo,
+                                    SkBudgeted = SkBudgeted::kYes) const;
+#else
     sk_sp<SkImage> makeTextureImage(GrContext*,
                                     GrMipMapped = GrMipMapped::kNo,
                                     SkBudgeted = SkBudgeted::kYes) const;
+#endif
 
     /** Returns raster image or lazy image. Copies SkImage backed by GPU texture into
         CPU memory if needed. Returns original SkImage if decoded in raster bitmap,