Remove GrRenderTarget from GrPipelineBuilder

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"
@@ skipping 112 matching lines @@
 #if 0
             SkString str = fBatches[i]->dumpInfo();
             SkDebugf("%s\n", str.c_str());
 #endif
         }
     }
 }
 #endif
 
 bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder,
+                                           GrRenderTarget* rt,
                                            const GrClip& clip,
                                            const GrPipelineOptimizations& optimizations,
                                            GrXferProcessor::DstTexture* dstTexture,
                                            const SkRect& batchBounds) {
     SkRect bounds = batchBounds;
     bounds.outset(0.5f, 0.5f);
 
     if (!pipelineBuilder.willXPNeedDstTexture(*this->caps(), optimizations)) {
         return true;
     }
 
-    GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
-
     if (this->caps()->textureBarrierSupport()) {
         if (GrTexture* rtTex = rt->asTexture()) {
             // The render target is a texture, so we can read from it directly in the shader. The XP
             // will be responsible to detect this situation and request a texture barrier.
             dstTexture->setTexture(rtTex);
             dstTexture->setOffset(0, 0);
             return true;
         }
     }
 
@@ skipping 81 matching lines @@
 void GrDrawTarget::drawBatch(const GrPipelineBuilder& pipelineBuilder,
                              GrDrawContext* drawContext,
                              const GrClip& clip,
                              GrDrawBatch* batch) {
     // Setup clip
     GrAppliedClip appliedClip;
     if (!clip.apply(fContext, pipelineBuilder, drawContext, &batch->bounds(), &appliedClip)) {
         return;
     }
 
+    // TODO: this is the only remaining usage of the AutoRestoreFragmentProcessorState - remove it
     GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
     if (appliedClip.clipCoverageFragmentProcessor()) {
         arfps.set(&pipelineBuilder);
         arfps.addCoverageFragmentProcessor(appliedClip.clipCoverageFragmentProcessor());
     }
 
     GrPipeline::CreateArgs args;
     args.fPipelineBuilder = &pipelineBuilder;
+    args.fDrawContext = drawContext;
     args.fCaps = this->caps();
     args.fScissor = &appliedClip.scissorState();
     args.fHasStencilClip = appliedClip.hasStencilClip();
     if (pipelineBuilder.hasUserStencilSettings() || appliedClip.hasStencilClip()) {
-        if (!fResourceProvider->attachStencilAttachment(pipelineBuilder.getRenderTarget())) {
+        if (!fResourceProvider->attachStencilAttachment(drawContext->accessRenderTarget())) {
             SkDebugf("ERROR creating stencil attachment. Draw skipped.\n");
             return;
         }
     }
     batch->getPipelineOptimizations(&args.fOpts);
     GrScissorState finalScissor;
     if (args.fOpts.fOverrides.fUsePLSDstRead || fClipBatchToBounds) {
-        GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
         GrGLIRect viewport;
         viewport.fLeft = 0;
         viewport.fBottom = 0;
-        viewport.fWidth = rt->width();
-        viewport.fHeight = rt->height();
+        viewport.fWidth = drawContext->width();
+        viewport.fHeight = drawContext->height();
         SkIRect ibounds;
         ibounds.fLeft = SkTPin(SkScalarFloorToInt(batch->bounds().fLeft), viewport.fLeft,
                               viewport.fWidth);
         ibounds.fTop = SkTPin(SkScalarFloorToInt(batch->bounds().fTop), viewport.fBottom,
                              viewport.fHeight);
         ibounds.fRight = SkTPin(SkScalarCeilToInt(batch->bounds().fRight), viewport.fLeft,
                                viewport.fWidth);
         ibounds.fBottom = SkTPin(SkScalarCeilToInt(batch->bounds().fBottom), viewport.fBottom,
                                 viewport.fHeight);
         if (appliedClip.scissorState().enabled()) {
             const SkIRect& scissorRect = appliedClip.scissorState().rect();
             if (!ibounds.intersect(scissorRect)) {
                 return;
             }
         }
         finalScissor.set(ibounds);
         args.fScissor = &finalScissor;
     }
     args.fOpts.fColorPOI.completeCalculations(pipelineBuilder.fColorFragmentProcessors.begin(),
                                               pipelineBuilder.numColorFragmentProcessors());
     args.fOpts.fCoveragePOI.completeCalculations(
                                                pipelineBuilder.fCoverageFragmentProcessors.begin(),
                                                pipelineBuilder.numCoverageFragmentProcessors());
-    if (!this->setupDstReadIfNecessary(pipelineBuilder, clip, args.fOpts, &args.fDstTexture,
-                                       batch->bounds())) {
+    if (!this->setupDstReadIfNecessary(pipelineBuilder, drawContext->accessRenderTarget(),
+                                       clip, args.fOpts,
+                                       &args.fDstTexture, batch->bounds())) {
         return;
     }
 
     if (!batch->installPipeline(args)) {
         return;
     }
 
 #ifdef ENABLE_MDB
     SkASSERT(fRenderTarget);
     batch->pipeline()->addDependenciesTo(fRenderTarget);
@@ skipping 16 matching lines @@
     GrAppliedClip 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);
+    GrStencilAttachment* stencilAttachment = fResourceProvider->attachStencilAttachment(
+                                                drawContext->accessRenderTarget());
     if (!stencilAttachment) {
         SkDebugf("ERROR creating stencil attachment. Draw skipped.\n");
         return;
     }
 
     GrBatch* batch = GrStencilPathBatch::Create(viewMatrix,
                                                 pipelineBuilder.isHWAntialias(),
                                                 fill,
                                                 appliedClip.hasStencilClip(),
                                                 stencilAttachment->bits(),
                                                 appliedClip.scissorState(),
-                                                pipelineBuilder.getRenderTarget(),
+                                                drawContext->accessRenderTarget(),
                                                 path);
     this->recordBatch(batch);
     batch->unref();
 }
 
 void GrDrawTarget::clear(const SkIRect* rect,
                          GrColor color,
                          bool canIgnoreRect,
                          GrDrawContext* drawContext) {
     SkIRect rtRect = SkIRect::MakeWH(drawContext->width(), drawContext->height());
@@ skipping 11 matching lines @@
     }
 
     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) {
             drawContext->discard();
         }
 
+        // TODO: flip this into real draw!
         GrPipelineBuilder pipelineBuilder;
         pipelineBuilder.setXPFactory(
             GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
-        pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
 
         SkRect scalarRect = SkRect::Make(*rect);
         SkAutoTUnref<GrDrawBatch> batch(
                 GrRectBatchFactory::CreateNonAAFill(color, SkMatrix::I(), scalarRect,
                                                     nullptr, nullptr));
         this->drawBatch(pipelineBuilder, drawContext, GrNoClip(), batch);
     } else {
         GrBatch* batch = new GrClearBatch(*rect, color, drawContext->accessRenderTarget());
         this->recordBatch(batch);
         batch->unref();
@@ skipping 130 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawTarget::clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) {
     GrBatch* batch = new GrClearStencilClipBatch(rect, insideClip, rt);
     this->recordBatch(batch);
     batch->unref();
 }