Move DstCopy on gpu into the GrXferProcessor.

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 229 matching lines @@
             draw->fType = add_trace_bit(draw->fType);
         }
     }
 
     return instancesToConcat;
 }
 
 void GrInOrderDrawBuffer::onDraw(const GrPipelineBuilder& pipelineBuilder,
                                  const GrGeometryProcessor* gp,
                                  const DrawInfo& info,
-                                 const GrScissorState& scissorState,
-                                 const GrDeviceCoordTexture* dstCopy) {
+                                 const GrScissorState& scissorState) {
     SkASSERT(info.vertexBuffer() && (!info.isIndexed() || info.indexBuffer()));
 
     // This closeBatch call is required because we may introduce new draws when we setup clip
     this->closeBatch();
 
-    if (!this->recordStateAndShouldDraw(pipelineBuilder, gp, scissorState, dstCopy)) {
+    if (!this->recordStateAndShouldDraw(pipelineBuilder, gp, scissorState, info.getDevBounds())) {
         return;
     }
 
     Draw* draw;
     if (info.isInstanced()) {
         int instancesConcated = this->concatInstancedDraw(pipelineBuilder, info);
         if (info.instanceCount() > instancesConcated) {
             draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info));
             draw->fInfo.adjustInstanceCount(-instancesConcated);
         } else {
             return;
         }
     } else {
         draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info));
     }
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawBatch(GrBatch* batch,
                                       const GrPipelineBuilder& pipelineBuilder,
                                       const GrScissorState& scissorState,
-                                      const GrDeviceCoordTexture* dstCopy) {
-    if (!this->recordStateAndShouldDraw(batch, pipelineBuilder, scissorState, dstCopy)) {
+                                      const SkRect* devBounds) {
+    if (!this->recordStateAndShouldDraw(batch, pipelineBuilder, scissorState, devBounds)) {
         return;
     }
 
     // Check if there is a Batch Draw we can batch with
     if (kDrawBatch_Cmd != strip_trace_bit(fCmdBuffer.back().fType)) {
         fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch));
         return;
     }
 
     DrawBatch* draw = static_cast<DrawBatch*>(&fCmdBuffer.back());
@@ skipping 18 matching lines @@
     sp->fViewMatrix = pathProc->viewMatrix();
     sp->fStencil = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPath(const GrPipelineBuilder& pipelineBuilder,
                                      const GrPathProcessor* pathProc,
                                      const GrPath* path,
                                      const GrScissorState& scissorState,
                                      const GrStencilSettings& stencilSettings,
-                                     const GrDeviceCoordTexture* dstCopy) {
+                                     const SkRect* devBounds) {
     this->closeBatch();
 
     // TODO: Only compare the subset of GrPipelineBuilder relevant to path covering?
-    if (!this->recordStateAndShouldDraw(pipelineBuilder, pathProc, scissorState, dstCopy)) {
+    if (!this->recordStateAndShouldDraw(pipelineBuilder, pathProc, scissorState, devBounds)) {
         return;
     }
     DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path));
     dp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPaths(const GrPipelineBuilder& pipelineBuilder,
                                       const GrPathProcessor* pathProc,
                                       const GrPathRange* pathRange,
                                       const void* indices,
                                       PathIndexType indexType,
                                       const float transformValues[],
                                       PathTransformType transformType,
                                       int count,
                                       const GrScissorState& scissorState,
                                       const GrStencilSettings& stencilSettings,
-                                      const GrDeviceCoordTexture* dstCopy) {
+                                      const SkRect* devBounds) {
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transformValues);
 
     this->closeBatch();
 
-    if (!this->recordStateAndShouldDraw(pipelineBuilder, pathProc, scissorState, dstCopy)) {
+    if (!this->recordStateAndShouldDraw(pipelineBuilder, pathProc, scissorState, devBounds)) {
         return;
     }
 
     int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
     if (int misalign = fPathIndexBuffer.count() % indexBytes) {
         // Add padding to the index buffer so the indices are aligned properly.
         fPathIndexBuffer.append(indexBytes - misalign);
     }
 
     char* savedIndices = fPathIndexBuffer.append(count * indexBytes,
@@ skipping 123 matching lines @@
 
         bool isSetState = kSetState_Cmd == strip_trace_bit(iter->fType);
         if (isSetState) {
             SetState* ss = reinterpret_cast<SetState*>(iter.get());
 
             // TODO sometimes we have a prim proc, othertimes we have a GrBatch.  Eventually we will
             // only have GrBatch and we can delete this
             if (ss->fPrimitiveProcessor) {
                 this->getGpu()->buildProgramDesc(&ss->fDesc, *ss->fPrimitiveProcessor,
                                                  ss->fPipeline,
-                                                 ss->fPipeline.descInfo(),
                                                  ss->fBatchTracker);
             }
             currentState = ss;
         } else {
             iter->execute(this, currentState);
         }
 
         if (cmd_has_trace_marker(iter->fType)) {
             this->getGpu()->removeGpuTraceMarker(&newMarker);
         }
@@ skipping 74 matching lines @@
         cs->fDstPoint = dstPoint;
         this->recordTraceMarkersIfNecessary();
         return true;
     }
     return false;
 }
 
 bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrPipelineBuilder& pipelineBuilder,
                                                    const GrPrimitiveProcessor* primProc,
                                                    const GrScissorState& scissor,
-                                                   const GrDeviceCoordTexture* dstCopy) {
+                                                   const SkRect* devBounds) {
+    GrDeviceCoordTexture dstCopy;
+    if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, devBounds)) {
+        return false;
+    }
     SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
                                             (pipelineBuilder, primProc, *this->getGpu()->caps(),
-                                             scissor, dstCopy));
+                                             scissor, &dstCopy));
     if (ss->fPipeline.mustSkip()) {
         fCmdBuffer.pop_back();
         return false;
     }
 
     ss->fPrimitiveProcessor->initBatchTracker(&ss->fBatchTracker,
                                               ss->fPipeline.getInitBatchTracker());
 
     if (fPrevState && fPrevState->fPrimitiveProcessor.get() &&
         fPrevState->fPrimitiveProcessor->canMakeEqual(fPrevState->fBatchTracker,
                                                       *ss->fPrimitiveProcessor,
                                                       ss->fBatchTracker) &&
         fPrevState->fPipeline.isEqual(ss->fPipeline)) {
         fCmdBuffer.pop_back();
     } else {
         fPrevState = ss;
         this->recordTraceMarkersIfNecessary();
     }
     return true;
 }
 
 bool GrInOrderDrawBuffer::recordStateAndShouldDraw(GrBatch* batch,
                                                    const GrPipelineBuilder& pipelineBuilder,
                                                    const GrScissorState& scissor,
-                                                   const GrDeviceCoordTexture* dstCopy) {
+                                                   const SkRect* devBounds) {
+    GrDeviceCoordTexture dstCopy;
+    if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, devBounds)) {
+        return false;
+    }
     // TODO this gets much simpler when we have batches everywhere.
     // If the previous command is also a set state, then we check to see if it has a Batch.  If so,
     // and we can make the two batches equal, and we can combine the states, then we make them equal
     SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
                                             (batch, pipelineBuilder, *this->getGpu()->caps(), scissor,
-                                             dstCopy));
+                                             &dstCopy));
     if (ss->fPipeline.mustSkip()) {
         fCmdBuffer.pop_back();
         return false;
     }
 
     batch->initBatchTracker(ss->fPipeline.getInitBatchTracker());
 
     if (fPrevState && !fPrevState->fPrimitiveProcessor.get() &&
         fPrevState->fPipeline.isEqual(ss->fPipeline)) {
         fCmdBuffer.pop_back();
@@ skipping 48 matching lines @@
     int vcount = vertexCount;
     int icount = indexCount;
 
     if (!insideGeoPush &&
         !unreleasedVertexSpace &&
         !unreleasedIndexSpace &&
         this->geometryHints(vertexStride, &vcount, &icount)) {
         this->flush();
     }
 }