Revert "Support large kernels on GPU in matrix convolution effect"

This reverts commit 1ed4391.

Reason for revert: Looks like some bad images showed up at gold.skia.org and that the ProcessorCloneTest is crashing on Windows bots:
https://logs.chromium.org/logs/skia/4bfabe0bad476911/+/steps/dm/0/stdout

Original change's description:
> Support large kernels on GPU in matrix convolution effect
> 
> Currently matrix convolution falls back to CPU execution for large kernels, due to the argument limit for fragment shaders.
> 
> Now for large kernels, we store them in a texture and sample them in a shader to sidestep the limit.
> 
> Change-Id: Icc069a701ea8e9cd0adf75f4bfd149fd22e31afd
> Bug: skia:8449
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/263495
> Reviewed-by: Michael Ludwig <[email protected]>
> Commit-Queue: Adlai Holler <[email protected]>

[email protected],[email protected],[email protected]

Change-Id: Iaf4858131046a343481bcf0fd9cc3919d9fc2bda
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:8449
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/287736
Reviewed-by: Brian Salomon <[email protected]>
Commit-Queue: Brian Salomon <[email protected]>

Author: bsalomon

gm/matrixconvolution.cpp

@@ -79,7 +79,7 @@ class MatrixConvolutionGM : public GM {
                 return SkImageFilters::MatrixConvolution({3,3}, kernel.data(), /* gain */ 0.3f, /* bias */ SkIntToScalar(100), kernelOffset, tileMode, convolveAlpha, nullptr, cropRect);
             }
             case kLarge_KernelFixture: {
-                // Intentionally go over the uniform kernel size limit of 25.
+                // Intentionally go over the MAX_KERNEL_SIZE limit and trigger CPU fallback.
                 // All 1s except center value, which is -47 (sum of 1).
                 std::vector<SkScalar> kernel(49, SkIntToScalar(1));
                 kernel[24] = SkIntToScalar(-47);

src/core/SkGpuBlurUtils.cpp

@@ -128,9 +128,8 @@ static std::unique_ptr<GrRenderTargetContext> convolve_gaussian_2d(GrRecordingCo
     SkIPoint kernelOffset = SkIPoint::Make(radiusX, radiusY);
     GrPaint paint;
     auto wm = SkTileModeToWrapMode(mode);
-    auto conv = GrMatrixConvolutionEffect::MakeGaussian(context, std::move(srcView), srcBounds,
-                                                        size, 1.0, 0.0, kernelOffset, wm, true,
-                                                        sigmaX, sigmaY,
+    auto conv = GrMatrixConvolutionEffect::MakeGaussian(std::move(srcView), srcBounds, size, 1.0,
+                                                        0.0, kernelOffset, wm, true, sigmaX, sigmaY,
                                                         *renderTargetContext->caps());
     paint.addColorFragmentProcessor(std::move(conv));
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
@@ -448,8 +447,7 @@ std::unique_ptr<GrRenderTargetContext> GaussianBlur(GrRecordingContext* context,
     if (scaleFactorX == 1 && scaleFactorY == 1) {
         // For really small blurs (certainly no wider than 5x5 on desktop GPUs) it is faster to just
         // launch a single non separable kernel vs two launches.
-        const int kernelSize = (2 * radiusX + 1) * (2 * radiusY + 1);
-        if (sigmaX > 0 && sigmaY > 0 && kernelSize <= GrMatrixConvolutionEffect::kMaxUniformSize) {
+        if (sigmaX > 0 && sigmaY > 0 && (2 * radiusX + 1) * (2 * radiusY + 1) <= MAX_KERNEL_SIZE) {
             // Apply the proxy offset to src bounds and offset directly
             return convolve_gaussian_2d(context, std::move(srcView), srcColorType, srcBounds,
                                         dstBounds, radiusX, radiusY, sigmaX, sigmaY, mode,

src/effects/imagefilters/SkMatrixConvolutionImageFilter.cpp

@@ -391,7 +391,9 @@ sk_sp<SkSpecialImage> SkMatrixConvolutionImageFilterImpl::onFilterImage(const Co
     }
 
 #if SK_SUPPORT_GPU
-    if (ctx.gpuBacked()) {
+    // Note: if the kernel is too big, the GPU path falls back to SW
+    if (ctx.gpuBacked() &&
+        fKernelSize.width() * fKernelSize.height() <= MAX_KERNEL_SIZE) {
         auto context = ctx.getContext();
 
         // Ensure the input is in the destination color space. Typically applyCropRect will have
@@ -412,8 +414,7 @@ sk_sp<SkSpecialImage> SkMatrixConvolutionImageFilterImpl::onFilterImage(const Co
         // Map srcBounds from input's logical image domain to that of the proxy
         srcBounds.offset(input->subset().x(), input->subset().y());
 
-        auto fp = GrMatrixConvolutionEffect::Make(context,
-                                                  std::move(inputView),
+        auto fp = GrMatrixConvolutionEffect::Make(std::move(inputView),
                                                   srcBounds,
                                                   fKernelSize,
                                                   fKernel,

src/gpu/GrFragmentProcessor.h

@@ -490,8 +490,6 @@ class GrFragmentProcessor::TextureSampler {
 
     TextureSampler(GrSurfaceProxyView, GrSamplerState = {});
 
-    TextureSampler(TextureSampler&&) = default;
-    TextureSampler& operator=(TextureSampler&&) = default;
     TextureSampler& operator=(const TextureSampler&) = delete;
 
     bool operator==(const TextureSampler& that) const {