Start using RenderTargetProxy (omnibus)

src/gpu/GrBlurUtils.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBlurUtils.h"
 #include "GrRenderTargetContext.h"
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrFixedClip.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "GrStyle.h"
 #include "GrTexture.h"
+#include "GrTextureProxy.h"
 #include "GrTextureProvider.h"
 #include "SkDraw.h"
 #include "SkGrPriv.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkTLazy.h"
 
 static bool clip_bounds_quick_reject(const SkIRect& clipBounds, const SkIRect& rect) {
     return clipBounds.isEmpty() || rect.isEmpty() || !SkIRect::Intersects(clipBounds, rect);
 }
 
 // Draw a mask using the supplied paint. Since the coverage/geometry
 // is already burnt into the mask this boils down to a rect draw.
 // Return true if the mask was successfully drawn.
 static bool draw_mask(GrRenderTargetContext* renderTargetContext,
                       const GrClip& clip,
                       const SkMatrix& viewMatrix,
                       const SkIRect& maskRect,
                       GrPaint* grp,
-                      GrTexture* mask) {
+                      GrTextureProxy* mask) {
     SkMatrix matrix;
     matrix.setTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop));
     matrix.postIDiv(mask->width(), mask->height());
     matrix.preConcat(viewMatrix);
     grp->addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(mask, nullptr, matrix));
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
@@ skipping 35 matching lines @@
     desc.fHeight = dstM.fBounds.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     sk_sp<GrTexture> texture(textureProvider->createApproxTexture(desc));
     if (!texture) {
         return false;
     }
     texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                                dstM.fImage, dstM.fRowBytes);
 
-    return draw_mask(renderTargetContext, clipData, viewMatrix, dstM.fBounds, grp, texture.get());
+    sk_sp<GrTextureProxy> proxy(GrTextureProxy::Make(texture));
+    return draw_mask(renderTargetContext, clipData, viewMatrix, dstM.fBounds, grp, proxy.get());
 }
 
 // Create a mask of 'devPath' and place the result in 'mask'.
-static sk_sp<GrTexture> create_mask_GPU(GrContext* context,
-                                        const SkIRect& maskRect,
-                                        const SkPath& devPath,
-                                        SkStrokeRec::InitStyle fillOrHairline,
-                                        bool doAA,
-                                        int sampleCnt) {
+static sk_sp<GrTextureProxy> create_mask_GPU(GrContext* context,
+                                             const SkIRect& maskRect,
+                                             const SkPath& devPath,
+                                             SkStrokeRec::InitStyle fillOrHairline,
+                                             bool doAA,
+                                             int sampleCnt) {
     if (!doAA) {
         // Don't need MSAA if mask isn't AA
         sampleCnt = 0;
     }
 
     sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContextWithFallback(
         SkBackingFit::kApprox, maskRect.width(), maskRect.height(), kAlpha_8_GrPixelConfig, nullptr,
         sampleCnt));
     if (!renderTargetContext) {
         return nullptr;
     }
 
     renderTargetContext->clear(nullptr, 0x0, true);
 
     GrPaint tempPaint;
     tempPaint.setAntiAlias(doAA);
     tempPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
 
     // setup new clip
     const SkIRect clipRect = SkIRect::MakeWH(maskRect.width(), maskRect.height());
     GrFixedClip clip(clipRect);
 
     // Draw the mask into maskTexture with the path's integerized top-left at
     // the origin using tempPaint.
     SkMatrix translate;
     translate.setTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop));
     renderTargetContext->drawPath(clip, tempPaint, translate, devPath, GrStyle(fillOrHairline));
-    return renderTargetContext->asTexture();;
+    return sk_ref_sp(renderTargetContext->asDeferredTexture());
 }
 
 static void draw_path_with_mask_filter(GrContext* context,
                                        GrRenderTargetContext* renderTargetContext,
                                        const GrClip& clip,
                                        GrPaint* paint,
                                        const SkMatrix& viewMatrix,
                                        const SkMaskFilter* maskFilter,
                                        const GrStyle& style,
                                        const SkPath* path,
@@ skipping 58 matching lines @@
                                             paint,
                                             clip,
                                             viewMatrix,
                                             SkStrokeRec(fillOrHairline),
                                             *path)) {
             // the mask filter was able to draw itself directly, so there's nothing
             // left to do.
             return;
         }
 
-        sk_sp<GrTexture> mask(create_mask_GPU(context,
-                                              finalIRect,
-                                              *path,
-                                              fillOrHairline,
-                                              paint->isAntiAlias(),
-                                              renderTargetContext->numColorSamples()));
+        sk_sp<GrTextureProxy> mask(create_mask_GPU(context,
+                                                   finalIRect,
+                                                   *path,
+                                                   fillOrHairline,
+                                                   paint->isAntiAlias(),
+                                                   renderTargetContext->numColorSamples()));
         if (mask) {
-            GrTexture* filtered;
+            GrTextureProxy* filtered;
 
             if (maskFilter->filterMaskGPU(mask.get(), viewMatrix, finalIRect, &filtered)) {
                 // filterMaskGPU gives us ownership of a ref to the result
-                sk_sp<GrTexture> atu(filtered);
+                sk_sp<GrTextureProxy> atu(filtered);
                 if (draw_mask(renderTargetContext, clip, viewMatrix, finalIRect, paint, filtered)) {
                     // This path is completely drawn
                     return;
                 }
             }
         }
     }
 
     sw_draw_with_mask_filter(renderTargetContext, context->textureProvider(),
                              clip, viewMatrix, *path,
@@ skipping 57 matching lines @@
     SkMaskFilter* mf = paint.getMaskFilter();
     if (mf && !mf->asFragmentProcessor(nullptr, nullptr, viewMatrix)) {
         // The MaskFilter wasn't already handled in SkPaintToGrPaint
         draw_path_with_mask_filter(context, renderTargetContext, clip, &grPaint, viewMatrix,
                                    mf, style,
                                    path, pathIsMutable);
     } else {
         renderTargetContext->drawPath(clip, grPaint, viewMatrix, *path, style);
     }
 }