Make GrClipMaskManager stateless and push GrPipelineBuilder construction downstack

src/gpu/GrDrawTarget.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawTarget.h"
 
 #include "GrAuditTrail.h"
 #include "GrCaps.h"
+#include "GrDrawContext.h"
 #include "GrGpu.h"
 #include "GrPath.h"
 #include "GrPipeline.h"
 #include "GrMemoryPool.h"
 #include "GrRenderTarget.h"
 #include "GrResourceProvider.h"
 #include "GrRenderTargetPriv.h"
 #include "GrStencilAttachment.h"
 #include "GrSurfacePriv.h"
 #include "GrTexture.h"
@@ skipping 17 matching lines @@
 
 GrDrawTarget::GrDrawTarget(GrRenderTarget* rt, GrGpu* gpu, GrResourceProvider* resourceProvider,
                            GrAuditTrail* auditTrail, const Options& options)
     : fGpu(SkRef(gpu))
     , fResourceProvider(resourceProvider)
     , fAuditTrail(auditTrail)
     , fFlags(0)
     , fRenderTarget(rt) {
     // TODO: Stop extracting the context (currently needed by GrClipMaskManager)
     fContext = fGpu->getContext();
-    fClipMaskManager.reset(new GrClipMaskManager(this));
 
     fClipBatchToBounds = options.fClipBatchToBounds;
     fDrawBatchBounds = options.fDrawBatchBounds;
     fMaxBatchLookback = (options.fMaxBatchLookback < 0) ? kDefaultMaxBatchLookback :
                                                           options.fMaxBatchLookback;
     fMaxBatchLookahead = (options.fMaxBatchLookahead < 0) ? kDefaultMaxBatchLookahead :
                                                            options.fMaxBatchLookahead;
 
     rt->setLastDrawTarget(this);
 
@@ skipping 168 matching lines @@
     }
 
     fGpu->finishDrawTarget();
 }
 
 void GrDrawTarget::reset() {
     fBatches.reset();
 }
 
 void GrDrawTarget::drawBatch(const GrPipelineBuilder& pipelineBuilder,
+                             GrDrawContext* drawContext,
                              const GrClip& clip,
                              GrDrawBatch* batch) {
     // Setup clip
     GrAppliedClip appliedClip;
-    if (!clip.apply(fClipMaskManager, pipelineBuilder, &batch->bounds(), &appliedClip)) {
+    if (!clip.apply(fContext, pipelineBuilder, drawContext, &batch->bounds(), &appliedClip)) {
         return;
     }
 
     GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
     if (appliedClip.clipCoverageFragmentProcessor()) {
         arfps.set(&pipelineBuilder);
         arfps.addCoverageFragmentProcessor(appliedClip.clipCoverageFragmentProcessor());
     }
 
     GrPipeline::CreateArgs args;
@@ skipping 50 matching lines @@
 
 #ifdef ENABLE_MDB
     SkASSERT(fRenderTarget);
     batch->pipeline()->addDependenciesTo(fRenderTarget);
 #endif
 
     this->recordBatch(batch);
 }
 
 void GrDrawTarget::stencilPath(const GrPipelineBuilder& pipelineBuilder,
+                               GrDrawContext* drawContext,
                                const GrClip& clip,
                                const SkMatrix& viewMatrix,
                                const GrPath* path,
                                GrPathRendering::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path stenciling.
     SkASSERT(path);
     SkASSERT(this->caps()->shaderCaps()->pathRenderingSupport());
 
     // Setup clip
     GrAppliedClip appliedClip;
-    if (!clip.apply(fClipMaskManager, pipelineBuilder, nullptr, &appliedClip)) {
+    if (!clip.apply(fContext, pipelineBuilder, drawContext, nullptr, &appliedClip)) {
         return;
     }
     // TODO: respect fClipBatchToBounds if we ever start computing bounds here.
 
     // Coverage AA does not make sense when rendering to the stencil buffer. The caller should never
     // attempt this in a situation that would require coverage AA.
     SkASSERT(!appliedClip.clipCoverageFragmentProcessor());
 
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
     GrStencilAttachment* stencilAttachment = fResourceProvider->attachStencilAttachment(rt);
@@ skipping 10 matching lines @@
                                                 appliedClip.scissorState(),
                                                 pipelineBuilder.getRenderTarget(),
                                                 path);
     this->recordBatch(batch);
     batch->unref();
 }
 
 void GrDrawTarget::clear(const SkIRect* rect,
                          GrColor color,
                          bool canIgnoreRect,
-                         GrRenderTarget* renderTarget) {
-    SkIRect rtRect = SkIRect::MakeWH(renderTarget->width(), renderTarget->height());
+                         GrDrawContext* drawContext) {
+    SkIRect rtRect = SkIRect::MakeWH(drawContext->width(), drawContext->height());
     SkIRect clippedRect;
     if (!rect ||
         (canIgnoreRect && this->caps()->fullClearIsFree()) ||
         rect->contains(rtRect)) {
         rect = &rtRect;
     } else {
         clippedRect = *rect;
         if (!clippedRect.intersect(rtRect)) {
             return;
         }
         rect = &clippedRect;
     }
 
     if (this->caps()->useDrawInsteadOfClear()) {
         // This works around a driver bug with clear by drawing a rect instead.
         // The driver will ignore a clear if it is the only thing rendered to a
         // target before the target is read.
         if (rect == &rtRect) {
-            this->discard(renderTarget);
+            drawContext->discard();
         }
 
         GrPipelineBuilder pipelineBuilder;
         pipelineBuilder.setXPFactory(
             GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
-        pipelineBuilder.setRenderTarget(renderTarget);
+        pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
 
         SkRect scalarRect = SkRect::Make(*rect);
         SkAutoTUnref<GrDrawBatch> batch(
                 GrRectBatchFactory::CreateNonAAFill(color, SkMatrix::I(), scalarRect,
                                                     nullptr, nullptr));
-        this->drawBatch(pipelineBuilder, GrNoClip(), batch);
+        this->drawBatch(pipelineBuilder, drawContext, GrNoClip(), batch);
     } else {
-        GrBatch* batch = new GrClearBatch(*rect, color, renderTarget);
+        GrBatch* batch = new GrClearBatch(*rect, color, drawContext->accessRenderTarget());
         this->recordBatch(batch);
         batch->unref();
     }
 }
 
 void GrDrawTarget::discard(GrRenderTarget* renderTarget) {
     if (this->caps()->discardRenderTargetSupport()) {
         GrBatch* batch = new GrDiscardBatch(renderTarget);
         this->recordBatch(batch);
         batch->unref();
@@ skipping 122 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawTarget::clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) {
     GrBatch* batch = new GrClearStencilClipBatch(rect, insideClip, rt);
     this->recordBatch(batch);
     batch->unref();
 }