Make GrClipMaskManager stateless and push GrPipelineBuilder construction downstack

src/gpu/GrClipMaskManager.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipMaskManager.h"
 #include "GrCaps.h"
 #include "GrDrawingManager.h"
 #include "GrDrawContextPriv.h"
-#include "GrDrawTarget.h"
 #include "GrGpuResourcePriv.h"
 #include "GrPaint.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceProvider.h"
 #include "GrStencilAttachment.h"
 #include "GrSWMaskHelper.h"
 #include "SkRasterClip.h"
 #include "SkTLazy.h"
 #include "batches/GrRectBatchFactory.h"
 #include "effects/GrConvexPolyEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrRRectEffect.h"
 #include "effects/GrTextureDomain.h"
 
 typedef SkClipStack::Element Element;
 
+static const int kMaxAnalyticElements = 4;
+
 ////////////////////////////////////////////////////////////////////////////////
 // set up the draw state to enable the aa clipping mask. Besides setting up the
 // stage matrix this also alters the vertex layout
 static sk_sp<const GrFragmentProcessor> create_fp_for_mask(GrTexture* result,
                                                            const SkIRect &devBound) {
     SkMatrix mat;
     // We use device coords to compute the texture coordinates. We set our matrix to be a
     // translation to the devBound, and then a scaling matrix to normalized coords.
     mat.setIDiv(result->width(), result->height());
     mat.preTranslate(SkIntToScalar(-devBound.fLeft),
                      SkIntToScalar(-devBound.fTop));
 
     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
     return sk_sp<const GrFragmentProcessor>(GrTextureDomainEffect::Create(
                                          result,
                                          mat,
                                          GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                          GrTextureDomain::kDecal_Mode,
                                          GrTextureParams::kNone_FilterMode,
                                          kDevice_GrCoordSet));
 }
 
-static void draw_non_aa_rect(GrDrawTarget* drawTarget,
-                             const GrPipelineBuilder& pipelineBuilder,
-                             const GrClip& clip,
-                             GrColor color,
-                             const SkMatrix& viewMatrix,
-                             const SkRect& rect) {
-    SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAFill(color, viewMatrix, rect,
-                                                                        nullptr, nullptr));
-    drawTarget->drawBatch(pipelineBuilder, clip, batch);
+void GrClipMaskManager::DrawNonAARect(GrDrawContext* drawContext,
+                                      const GrFixedClip& clip,
+                                      const SkMatrix& viewMatrix,
+                                      const SkRect& rect,
+                                      bool doAA,
+                                      const GrUserStencilSettings* stencilSettings) {
+    drawContext->drawContextPriv().stencilRect(clip, stencilSettings, doAA, viewMatrix, rect);
 }
 
 // Does the path in 'element' require SW rendering? If so, return true (and,
 // optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
 // 'prOut' to the non-SW path renderer that will do the job).
 bool GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
                                             bool hasUserStencilSettings,
-                                            const GrRenderTarget* rt,
+                                            const GrDrawContext* drawContext,
                                             const SkMatrix& viewMatrix,
                                             const Element* element,
                                             GrPathRenderer** prOut,
                                             bool needsStencil) {
     if (Element::kRect_Type == element->getType()) {
         // rects can always be drawn directly w/o using the software path
         // TODO: skip rrects once we're drawing them directly.
         if (prOut) {
             *prOut = nullptr;
         }
@@ skipping 21 matching lines @@
                             : GrPathRendererChain::kColor_DrawType;
         }
 
         GrPathRenderer::CanDrawPathArgs canDrawArgs;
         canDrawArgs.fShaderCaps = context->caps()->shaderCaps();
         canDrawArgs.fViewMatrix = &viewMatrix;
         canDrawArgs.fPath = &path;
         canDrawArgs.fStyle = &GrStyle::SimpleFill();
         canDrawArgs.fAntiAlias = element->isAA();
         canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
-        canDrawArgs.fIsStencilBufferMSAA = rt->isStencilBufferMultisampled();
+        canDrawArgs.fIsStencilBufferMSAA = drawContext->isStencilBufferMultisampled();
 
         // the 'false' parameter disallows use of the SW path renderer
         GrPathRenderer* pr = context->drawingManager()->getPathRenderer(canDrawArgs, false, type);
         if (prOut) {
             *prOut = pr;
         }
         return SkToBool(!pr);
     }
 }
 
-// Determines whether it is possible to draw the element to both the stencil buffer and the
-// alpha mask simultaneously. If so and the element is a path a compatible path renderer is
-// also returned.
-GrPathRenderer* GrClipMaskManager::GetPathRenderer(GrContext* context,
-                                                   GrTexture* texture,
-                                                   const SkMatrix& viewMatrix,
-                                                   const SkClipStack::Element* element) {
-    GrPathRenderer* pr;
-    constexpr bool kNeedsStencil = true;
-    constexpr bool kHasUserStencilSettings = false;
-    PathNeedsSWRenderer(context,
-                        kHasUserStencilSettings,
-                        texture->asRenderTarget(),
-                        viewMatrix,
-                        element,
-                        &pr,
-                        kNeedsStencil);
-    return pr;
-}
-
-GrContext* GrClipMaskManager::getContext() {
-    return fDrawTarget->cmmAccess().context();
-}
-
-const GrCaps* GrClipMaskManager::caps() const {
-    return fDrawTarget->caps();
-}
-
-GrResourceProvider* GrClipMaskManager::resourceProvider() {
-    return fDrawTarget->cmmAccess().resourceProvider();
-}
 /*
  * This method traverses the clip stack to see if the GrSoftwarePathRenderer
  * will be used on any element. If so, it returns true to indicate that the
  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
  */
 bool GrClipMaskManager::UseSWOnlyPath(GrContext* context,
                                       const GrPipelineBuilder& pipelineBuilder,
-                                      const GrRenderTarget* rt,
+                                      const GrDrawContext* drawContext,
                                       const SkVector& clipToMaskOffset,
                                       const GrReducedClip::ElementList& elements) {
     // TODO: generalize this function so that when
     // a clip gets complex enough it can just be done in SW regardless
     // of whether it would invoke the GrSoftwarePathRenderer.
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
     const SkMatrix translate = SkMatrix::MakeTrans(clipToMaskOffset.fX, clipToMaskOffset.fY);
 
     for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
         const Element* element = iter.get();
 
         SkRegion::Op op = element->getOp();
         bool invert = element->isInverseFilled();
         bool needsStencil = invert ||
                             SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op;
 
         if (PathNeedsSWRenderer(context, pipelineBuilder.hasUserStencilSettings(),
-                                rt, translate, element, nullptr, needsStencil)) {
+                                drawContext, translate, element, nullptr, needsStencil)) {
             return true;
         }
     }
     return false;
 }
 
-bool GrClipMaskManager::getAnalyticClipProcessor(const GrReducedClip::ElementList& elements,
-                                                 bool abortIfAA,
-                                                 SkVector& clipToRTOffset,
-                                                 const SkRect* drawBounds,
-                                                 sk_sp<const GrFragmentProcessor>* resultFP) {
+static bool get_analytic_clip_processor(const GrReducedClip::ElementList& elements,
+                                        bool abortIfAA,
+                                        SkVector& clipToRTOffset,
+                                        const SkRect* drawBounds,
+                                        sk_sp<const GrFragmentProcessor>* resultFP) {
     SkRect boundsInClipSpace;
     if (drawBounds) {
         boundsInClipSpace = *drawBounds;
         boundsInClipSpace.offset(-clipToRTOffset.fX, -clipToRTOffset.fY);
     }
     SkASSERT(elements.count() <= kMaxAnalyticElements);
     const GrFragmentProcessor* fps[kMaxAnalyticElements];
     for (int i = 0; i < kMaxAnalyticElements; ++i) {
         fps[i] = nullptr;
     }
@@ skipping 75 matching lines @@
     }
     for (int i = 0; i < fpCnt; ++i) {
         fps[i]->unref();
     }
     return !failed;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
-bool GrClipMaskManager::setupClipping(const GrPipelineBuilder& pipelineBuilder,
+bool GrClipMaskManager::SetupClipping(GrContext* context,
+                                      const GrPipelineBuilder& pipelineBuilder,
+                                      GrDrawContext* drawContext,
                                       const GrClipStackClip& clip,
                                       const SkRect* devBounds,
                                       GrAppliedClip* out) {
     if (!clip.clipStack() || clip.clipStack()->isWideOpen()) {
         return true;
     }
 
     GrReducedClip::ElementList elements;
     int32_t genID = 0;
     GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
     SkIRect clipSpaceIBounds;
     bool requiresAA = false;
-    GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
 
-    // GrDrawTarget should have filtered this for us
-    SkASSERT(rt);
-
-    SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(rt->width(), rt->height());
+    SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(drawContext->width(), drawContext->height());
     clipSpaceRTIBounds.offset(clip.origin());
 
     SkIRect clipSpaceReduceQueryBounds;
 #define DISABLE_DEV_BOUNDS_FOR_CLIP_REDUCTION 0
     if (devBounds && !DISABLE_DEV_BOUNDS_FOR_CLIP_REDUCTION) {
         SkIRect devIBounds = devBounds->roundOut();
         devIBounds.offset(clip.origin());
         if (!clipSpaceReduceQueryBounds.intersect(clipSpaceRTIBounds, devIBounds)) {
             return false;
         }
@@ skipping 23 matching lines @@
     //   isect convex_poly
     //   isect convex_poly
     // when drawing rounded div borders. This could probably be tuned based on a
     // configuration's relative costs of switching RTs to generate a mask vs
     // longer shaders.
     if (elements.count() <= kMaxAnalyticElements) {
         SkVector clipToRTOffset = { SkIntToScalar(-clip.origin().fX),
                                     SkIntToScalar(-clip.origin().fY) };
         // When there are multiple samples we want to do per-sample clipping, not compute a
         // fractional pixel coverage.
-        bool disallowAnalyticAA = rt->isStencilBufferMultisampled();
-        if (disallowAnalyticAA && !rt->numColorSamples()) {
+        bool disallowAnalyticAA = drawContext->isStencilBufferMultisampled();
+        if (disallowAnalyticAA && !drawContext->numColorSamples()) {
             // With a single color sample, any coverage info is lost from color once it hits the
             // color buffer anyway, so we may as well use coverage AA if nothing else in the pipe
             // is multisampled.
             disallowAnalyticAA = pipelineBuilder.isHWAntialias() ||
                                  pipelineBuilder.hasUserStencilSettings();
         }
         sk_sp<const GrFragmentProcessor> clipFP;
         if (elements.isEmpty() ||
             (requiresAA &&
-             this->getAnalyticClipProcessor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
-                                            &clipFP))) {
+             get_analytic_clip_processor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
+                                         &clipFP))) {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
             scissorSpaceIBounds.offset(-clip.origin());
-            if (nullptr == devBounds ||
-                !SkRect::Make(scissorSpaceIBounds).contains(*devBounds)) {
+            if (!devBounds || !SkRect::Make(scissorSpaceIBounds).contains(*devBounds)) {
                 out->makeScissoredFPBased(clipFP, scissorSpaceIBounds);
                 return true;
             }
             out->makeFPBased(clipFP);
             return true;
         }
     }
 
     // If the stencil buffer is multisampled we can use it to do everything.
-    if (!rt->isStencilBufferMultisampled() && requiresAA) {
+    if (!drawContext->isStencilBufferMultisampled() && requiresAA) {
         sk_sp<GrTexture> result;
 
         // The top-left of the mask corresponds to the top-left corner of the bounds.
         SkVector clipToMaskOffset = {
             SkIntToScalar(-clipSpaceIBounds.fLeft),
             SkIntToScalar(-clipSpaceIBounds.fTop)
         };
 
-        if (UseSWOnlyPath(this->getContext(), pipelineBuilder, rt, clipToMaskOffset, elements)) {
+        if (UseSWOnlyPath(context, pipelineBuilder, drawContext,
+                          clipToMaskOffset, elements)) {
             // The clip geometry is complex enough that it will be more efficient to create it
             // entirely in software
-            result = CreateSoftwareClipMask(this->getContext()->textureProvider(),
+            result = CreateSoftwareClipMask(context->textureProvider(),
                                             genID,
                                             initialState,
                                             elements,
                                             clipToMaskOffset,
                                             clipSpaceIBounds);
         } else {
-            result = CreateAlphaClipMask(this->getContext(),
+            result = CreateAlphaClipMask(context,
                                          genID,
                                          initialState,
                                          elements,
                                          clipToMaskOffset,
                                          clipSpaceIBounds);
             // If createAlphaClipMask fails it means UseSWOnlyPath has a bug
             SkASSERT(result);
         }
 
         if (result) {
             // The mask's top left coord should be pinned to the rounded-out top left corner of
             // clipSpace bounds. We determine the mask's position WRT to the render target here.
             SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
             rtSpaceMaskBounds.offset(-clip.origin());
             out->makeFPBased(create_fp_for_mask(result.get(), rtSpaceMaskBounds));
             return true;
         }
         // if alpha clip mask creation fails fall through to the non-AA code paths
     }
 
     // use the stencil clip if we can't represent the clip as a rectangle.
     SkIPoint clipSpaceToStencilSpaceOffset = -clip.origin();
-    this->createStencilClipMask(rt,
-                                genID,
-                                initialState,
-                                elements,
-                                clipSpaceIBounds,
-                                clipSpaceToStencilSpaceOffset);
+    CreateStencilClipMask(context,
+                          drawContext,
+                          genID,
+                          initialState,
+                          elements,
+                          clipSpaceIBounds,
+                          clipSpaceToStencilSpaceOffset);
 
     // This must occur after createStencilClipMask. That function may change the scissor. Also, it
     // only guarantees that the stencil mask is correct within the bounds it was passed, so we must
     // use both stencil and scissor test to the bounds for the final draw.
     SkIRect scissorSpaceIBounds(clipSpaceIBounds);
     scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
     out->makeScissoredStencil(true, scissorSpaceIBounds);
     return true;
 }
 
@@ skipping 169 matching lines @@
 
     sk_sp<GrTexture> texture(dc->asTexture());
     SkASSERT(texture);
     texture->resourcePriv().setUniqueKey(key);
     return texture;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 // (as opposed to canvas) coordinates
-bool GrClipMaskManager::createStencilClipMask(GrRenderTarget* rt,
+bool GrClipMaskManager::CreateStencilClipMask(GrContext* context,
+                                              GrDrawContext* drawContext,
                                               int32_t elementsGenID,
                                               GrReducedClip::InitialState initialState,
                                               const GrReducedClip::ElementList& elements,
                                               const SkIRect& clipSpaceIBounds,
                                               const SkIPoint& clipSpaceToStencilOffset) {
-    SkASSERT(rt);
+    SkASSERT(drawContext);
 
-    GrStencilAttachment* stencilAttachment = this->resourceProvider()->attachStencilAttachment(rt);
+    GrStencilAttachment* stencilAttachment = context->resourceProvider()->attachStencilAttachment(
+                                                    drawContext->accessRenderTarget());
     if (nullptr == stencilAttachment) {
         return false;
     }
 
+    // TODO: these need to be swapped over to using a StencilAttachmentProxy
     if (stencilAttachment->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
         stencilAttachment->setLastClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset);
         // Set the matrix so that rendered clip elements are transformed from clip to stencil space.
         SkVector translate = {
             SkIntToScalar(clipSpaceToStencilOffset.fX),
             SkIntToScalar(clipSpaceToStencilOffset.fY)
         };
         SkMatrix viewMatrix;
         viewMatrix.setTranslate(translate);
 
         // We set the current clip to the bounds so that our recursive draws are scissored to them.
         SkIRect stencilSpaceIBounds(clipSpaceIBounds);
         stencilSpaceIBounds.offset(clipSpaceToStencilOffset);
         GrFixedClip clip(stencilSpaceIBounds);
 
-        fDrawTarget->cmmAccess().clearStencilClip(stencilSpaceIBounds,
-            GrReducedClip::kAllIn_InitialState == initialState, rt);
+        drawContext->drawContextPriv().clearStencilClip(
+                                            stencilSpaceIBounds,
+                                            GrReducedClip::kAllIn_InitialState == initialState);
 
         // walk through each clip element and perform its set op
         // with the existing clip.
         for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
             const Element* element = iter.get();
 
-            GrPipelineBuilder pipelineBuilder;
-            pipelineBuilder.setRenderTarget(rt);
-
-            pipelineBuilder.setDisableColorXPFactory();
-
-            // if the target is MSAA then we want MSAA enabled when the clip is soft
-            if (rt->isStencilBufferMultisampled()) {
-                pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, element->isAA());
-            }
-
             bool fillInverted = false;
             // enabled at bottom of loop
             clip.enableStencilClip(false);
 
             // This will be used to determine whether the clip shape can be rendered into the
             // stencil with arbitrary stencil settings.
             GrPathRenderer::StencilSupport stencilSupport;
 
             SkRegion::Op op = element->getOp();
 
             GrPathRenderer* pr = nullptr;
             SkPath clipPath;
             if (Element::kRect_Type == element->getType()) {
                 stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
                 fillInverted = false;
             } else {
                 element->asPath(&clipPath);
                 fillInverted = clipPath.isInverseFillType();
                 if (fillInverted) {
                     clipPath.toggleInverseFillType();
                 }
 
-                SkASSERT(!pipelineBuilder.hasUserStencilSettings());
-
                 GrPathRenderer::CanDrawPathArgs canDrawArgs;
-                canDrawArgs.fShaderCaps = this->getContext()->caps()->shaderCaps();
+                canDrawArgs.fShaderCaps = context->caps()->shaderCaps();
                 canDrawArgs.fViewMatrix = &viewMatrix;
                 canDrawArgs.fPath = &clipPath;
                 canDrawArgs.fStyle = &GrStyle::SimpleFill();
                 canDrawArgs.fAntiAlias = false;
-                canDrawArgs.fHasUserStencilSettings = pipelineBuilder.hasUserStencilSettings();
-                canDrawArgs.fIsStencilBufferMSAA = rt->isStencilBufferMultisampled();
+                canDrawArgs.fHasUserStencilSettings = false;
+                canDrawArgs.fIsStencilBufferMSAA = drawContext->isStencilBufferMultisampled();
 
-                pr = this->getContext()->drawingManager()->getPathRenderer(canDrawArgs, false,
-                                                                           GrPathRendererChain::kStencilOnly_DrawType,
-                                                                           &stencilSupport);
-                if (nullptr == pr) {
+                pr = context->drawingManager()->getPathRenderer(canDrawArgs, false,
+                                                                GrPathRendererChain::kStencilOnly_DrawType,
+                                                                &stencilSupport);
+                if (!pr) {
                     return false;
                 }
             }
 
             bool canRenderDirectToStencil =
                 GrPathRenderer::kNoRestriction_StencilSupport == stencilSupport;
             bool drawDirectToClip; // Given the renderer, the element,
                                    // fill rule, and set operation should
                                    // we render the element directly to
                                    // stencil bit used for clipping.
             GrUserStencilSettings const* const* stencilPasses =
                 GrStencilSettings::GetClipPasses(op, canRenderDirectToStencil, fillInverted,
                                                  &drawDirectToClip);
 
             // draw the element to the client stencil bits if necessary
             if (!drawDirectToClip) {
                 static constexpr GrUserStencilSettings kDrawToStencil(
                      GrUserStencilSettings::StaticInit<
                          0x0000,
                          GrUserStencilTest::kAlways,
                          0xffff,
                          GrUserStencilOp::kIncMaybeClamp,
                          GrUserStencilOp::kIncMaybeClamp,
                          0xffff>()
                 );
                 if (Element::kRect_Type == element->getType()) {
-                    pipelineBuilder.setUserStencil(&kDrawToStencil);
-
-                    draw_non_aa_rect(fDrawTarget, pipelineBuilder, clip, GrColor_WHITE, viewMatrix,
-                                     element->getRect());
+                    DrawNonAARect(drawContext, clip, viewMatrix,
+                                  element->getRect(), element->isAA(), &kDrawToStencil);
                 } else {
                     if (!clipPath.isEmpty()) {
                         if (canRenderDirectToStencil) {
-                            pipelineBuilder.setUserStencil(&kDrawToStencil);
+                            GrPaint paint;
+                            paint.setXPFactory(GrDisableColorXPFactory::Create());

[bungeman-skia, 2016/06/03 23:57:03]

leak

+                            paint.setAntiAlias(element->isAA());
 
                             GrPathRenderer::DrawPathArgs args;
-                            args.fTarget = fDrawTarget;
-                            args.fResourceProvider = this->getContext()->resourceProvider();
-                            args.fPipelineBuilder = &pipelineBuilder;
+                            args.fResourceProvider = context->resourceProvider();
+                            args.fPaint = &paint;
+                            args.fUserStencilSettings = &kDrawToStencil;
+                            args.fDrawContext = drawContext;
                             args.fClip = &clip;
                             args.fColor = GrColor_WHITE;
                             args.fViewMatrix = &viewMatrix;
                             args.fPath = &clipPath;
                             args.fStyle = &GrStyle::SimpleFill();
                             args.fAntiAlias = false;
                             args.fGammaCorrect = false;
                             pr->drawPath(args);
                         } else {
                             GrPathRenderer::StencilPathArgs args;
-                            args.fTarget = fDrawTarget;
-                            args.fResourceProvider = this->getContext()->resourceProvider();
-                            args.fPipelineBuilder = &pipelineBuilder;
+                            args.fResourceProvider = context->resourceProvider();
+                            args.fDrawContext = drawContext;
                             args.fClip = &clip;
                             args.fViewMatrix = &viewMatrix;
                             args.fPath = &clipPath;
+                            args.fIsAA = element->isAA();
                             pr->stencilPath(args);
                         }
                     }
                 }
             }
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             clip.enableStencilClip(true);
             for (GrUserStencilSettings const* const* pass = stencilPasses; *pass; ++pass) {
-                pipelineBuilder.setUserStencil(*pass);
 
                 if (drawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
-                        draw_non_aa_rect(fDrawTarget, pipelineBuilder, clip, GrColor_WHITE,
-                                         viewMatrix, element->getRect());
+                        DrawNonAARect(drawContext, clip,
+                                      viewMatrix, element->getRect(), element->isAA(), *pass);
                     } else {
+                        GrPaint paint;
+                        paint.setXPFactory(GrDisableColorXPFactory::Create());

[bungeman-skia, 2016/06/03 23:57:03]

leak

+                        paint.setAntiAlias(element->isAA());
+
                         GrPathRenderer::DrawPathArgs args;
-                        args.fTarget = fDrawTarget;
-                        args.fResourceProvider = this->getContext()->resourceProvider();
-                        args.fPipelineBuilder = &pipelineBuilder;
+                        args.fResourceProvider = context->resourceProvider();
+                        args.fPaint = &paint;
+                        args.fUserStencilSettings = *pass;
+                        args.fDrawContext = drawContext;
                         args.fClip = &clip;
                         args.fColor = GrColor_WHITE;
                         args.fViewMatrix = &viewMatrix;
                         args.fPath = &clipPath;
                         args.fStyle = &GrStyle::SimpleFill();
                         args.fAntiAlias = false;
                         args.fGammaCorrect = false;
                         pr->drawPath(args);
                     }
                 } else {
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
-                    draw_non_aa_rect(fDrawTarget, pipelineBuilder, clip, GrColor_WHITE, viewMatrix,
-                                     SkRect::Make(clipSpaceIBounds));
+                    DrawNonAARect(drawContext, clip, viewMatrix,
+                                  SkRect::Make(clipSpaceIBounds), false, *pass);
                 }
             }
         }
     }
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 sk_sp<GrTexture> GrClipMaskManager::CreateSoftwareClipMask(
                                                     GrTextureProvider* texProvider,
@@ skipping 64 matching lines @@
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }