Start using RenderTargetProxy (omnibus)

src/effects/SkBlurMaskFilter.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
 #include "SkGpuBlurUtils.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMaskFilter.h"
 #include "SkRRect.h"
 #include "SkStringUtils.h"
 #include "SkStrokeRec.h"
 
 #if SK_SUPPORT_GPU
 #include "GrCircleBlurFragmentProcessor.h"
 #include "GrContext.h"
 #include "GrRenderTargetContext.h"
 #include "GrTexture.h"
+#include "GrTextureProxy.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrStyle.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLSampler.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #endif
@@ skipping 24 matching lines @@
                              const SkStrokeRec& strokeRec,
                              const SkPath& path) const override;
     bool directFilterRRectMaskGPU(GrContext*,
                                   GrRenderTargetContext* renderTargetContext,
                                   GrPaint* grp,
                                   const GrClip&,
                                   const SkMatrix& viewMatrix,
                                   const SkStrokeRec& strokeRec,
                                   const SkRRect& rrect,
                                   const SkRRect& devRRect) const override;
-    bool filterMaskGPU(GrTexture* src,
+    bool filterMaskGPU(GrTextureProxy* src,
                        const SkMatrix& ctm,
                        const SkIRect& maskRect,
-                       GrTexture** result) const override;
+                       GrTextureProxy** result) const override;
 #endif
 
     void computeFastBounds(const SkRect&, SkRect*) const override;
     bool asABlur(BlurRec*) const override;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurMaskFilterImpl)
 
 protected:
     FilterReturn filterRectsToNine(const SkRect[], int count, const SkMatrix&,
@@ skipping 996 matching lines @@
     const char* name() const override { return "GrRRectBlur"; }
 
     const SkRRect& getRRect() const { return fRRect; }
     float getSigma() const { return fSigma; }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
     GrRRectBlurEffect(float sigma, const SkRRect&, GrTexture* profileTexture);
 
+    GrRRectBlurEffect(float sigma, const SkRRect&, GrTextureProxy* profileTexture);
+
     virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                        GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor& other) const override;
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
     SkRRect             fRRect;
     float               fSigma;
     GrTextureAccess     fNinePatchAccess;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
-static sk_sp<GrTexture> find_or_create_rrect_blur_mask(GrContext* context,
-                                                       const SkRRect& rrectToDraw,
-                                                       const SkISize& size,
-                                                       float xformedSigma,
-                                                       bool doAA) {
+static sk_sp<GrTextureProxy> find_or_create_rrect_blur_mask(GrContext* context,
+                                                            const SkRRect& rrectToDraw,
+                                                            const SkISize& size,
+                                                            float xformedSigma,
+                                                            bool doAA) {
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey key;
     GrUniqueKey::Builder builder(&key, kDomain, 9);
     builder[0] = SkScalarCeilToInt(xformedSigma-1/6.0f);
 
     int index = 1;
     for (auto c : { SkRRect::kUpperLeft_Corner,  SkRRect::kUpperRight_Corner,
                     SkRRect::kLowerRight_Corner, SkRRect::kLowerLeft_Corner }) {
         SkASSERT(SkScalarIsInt(rrectToDraw.radii(c).fX) && SkScalarIsInt(rrectToDraw.radii(c).fY));
         builder[index++] = SkScalarCeilToInt(rrectToDraw.radii(c).fX);
         builder[index++] = SkScalarCeilToInt(rrectToDraw.radii(c).fY);
     }
     builder.finish();
 
-    sk_sp<GrTexture> mask(context->textureProvider()->findAndRefTextureByUniqueKey(key));
+    sk_sp<GrTextureProxy> mask(context->textureProvider()->findAndRefTextureProxyByUniqueKey(key));
     if (!mask) {
         // TODO: this could be approx but the texture coords will need to be updated
         sk_sp<GrRenderTargetContext> rtc(context->makeRenderTargetContextWithFallback(
             SkBackingFit::kExact, size.fWidth, size.fHeight, kAlpha_8_GrPixelConfig, nullptr));
         if (!rtc) {
             return nullptr;
         }
 
         GrPaint grPaint;
         grPaint.setAntiAlias(doAA);
 
         rtc->clear(nullptr, 0x0, true);
         rtc->drawRRect(GrNoClip(), grPaint, SkMatrix::I(), rrectToDraw, GrStyle::SimpleFill());
 
-        sk_sp<GrTexture> srcTexture(rtc->asTexture());
+        sk_sp<GrTextureProxy> srcTexture(rtc->asDeferredTexture());
         sk_sp<GrRenderTargetContext> rtc2(SkGpuBlurUtils::GaussianBlur(context,
                                                                        srcTexture.get(),
                                                                        nullptr,
                                                                        SkIRect::MakeWH(
                                                                            size.fWidth,
                                                                            size.fHeight),
                                                                        nullptr,
                                                                        xformedSigma, xformedSigma,
                                                                        SkBackingFit::kExact));
         if (!rtc2) {
             return nullptr;
         }
 
-        mask = rtc2->asTexture();
+        mask = rtc2->asDeferredTexture();
         SkASSERT(mask);
-        context->textureProvider()->assignUniqueKeyToTexture(key, mask.get());
+        context->textureProvider()->assignUniqueKeyToDeferredTexture(key, mask.get());
     }
 
     return mask;
 }
 
 sk_sp<GrFragmentProcessor> GrRRectBlurEffect::Make(GrContext* context,
                                                    float sigma, float xformedSigma,
                                                    const SkRRect& srcRRect, const SkRRect& devRRect) {
     SkASSERT(!devRRect.isCircle() && !devRRect.isRect()); // Should've been caught up-stream
 
@@ skipping 16 matching lines @@
                                                                      sigma, xformedSigma,
                                                                      &rrectToDraw, &size,
                                                                      ignored, ignored,
                                                                      ignored, ignored,
                                                                      &ignoredSize, &ignoredSize,
                                                                      &ignored32);
     if (!ninePatchable) {
         return nullptr;
     }
 
-    sk_sp<GrTexture> mask(find_or_create_rrect_blur_mask(context, rrectToDraw, size,
-                                                         xformedSigma, true));
+    sk_sp<GrTextureProxy> mask(find_or_create_rrect_blur_mask(context, rrectToDraw, size,
+                                                             xformedSigma, true));
     if (!mask) {
         return nullptr;
     }
 
     return sk_sp<GrFragmentProcessor>(new GrRRectBlurEffect(xformedSigma,
                                                             devRRect,
                                                             mask.get()));
 }
 
 void GrRRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
@@ skipping 279 matching lines @@
     // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area.
     srcRect.outset(sigma3, sigma3);
     clipRect.outset(sigma3, sigma3);
     if (!srcRect.intersect(clipRect)) {
         srcRect.setEmpty();
     }
     *maskRect = srcRect;
     return true;
 }
 
-bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src,
+bool SkBlurMaskFilterImpl::filterMaskGPU(GrTextureProxy* src,
                                          const SkMatrix& ctm,
                                          const SkIRect& maskRect,
-                                         GrTexture** result) const {
+                                         GrTextureProxy** result) const {
     // 'maskRect' isn't snapped to the UL corner but the mask in 'src' is.
     const SkIRect clipRect = SkIRect::MakeWH(maskRect.width(), maskRect.height());
 
     GrContext* context = src->getContext();
 
     SkScalar xformedSigma = this->computeXformedSigma(ctm);
     SkASSERT(xformedSigma > 0);
 
     // If we're doing a normal blur, we can clobber the pathTexture in the
     // gaussianBlur.  Otherwise, we need to save it for later compositing.
@@ skipping 24 matching lines @@
             // outer:  dst = dst * (1 - src)
             //             = 0 * src + (1 - src) * dst
             paint.setCoverageSetOpXPFactory(SkRegion::kDifference_Op);
         } else {
             paint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
         }
 
         renderTargetContext->drawRect(GrNoClip(), paint, SkMatrix::I(), SkRect::Make(clipRect));
     }
 
-    *result = renderTargetContext->asTexture().release();
+    *result = renderTargetContext->asDeferredTexture().release();
     return true;
 }
 
 #endif // SK_SUPPORT_GPU
 
 
 #ifndef SK_IGNORE_TO_STRING
 void SkBlurMaskFilterImpl::toString(SkString* str) const {
     str->append("SkBlurMaskFilterImpl: (");
 
@@ skipping 16 matching lines @@
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END