Move DstCoordTexture to GrXP, rename and remove the word "copy" from dstcopytexture names.

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"
 
@@ skipping 25 matching lines @@
     , fGpuTraceMarkerCount(0)
     , fFlushing(false) {
     SkASSERT(context);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder,
                                            const GrProcOptInfo& colorPOI,
                                            const GrProcOptInfo& coveragePOI,
-                                           GrDeviceCoordTexture* dstCopy,
+                                           GrXferProcessor::DstTexture* dstTexture,
                                            const SkRect* drawBounds) {
-    if (!pipelineBuilder.willXPNeedDstCopy(*this->caps(), colorPOI, coveragePOI)) {
+    if (!pipelineBuilder.willXPNeedDstTexture(*this->caps(), colorPOI, coveragePOI)) {
         return true;
     }
 
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
 
     if (this->caps()->textureBarrierSupport()) {
         if (GrTexture* rtTex = rt->asTexture()) {
             // The render target is a texture, se we can read from it directly in the shader. The XP
             // will be responsible to detect this situation and request a texture barrier.
-            dstCopy->setTexture(rtTex);
-            dstCopy->setOffset(0, 0);
+            dstTexture->setTexture(rtTex);
+            dstTexture->setOffset(0, 0);
             return true;
         }
     }
 
     SkIRect copyRect;
     pipelineBuilder.clip().getConservativeBounds(rt, &copyRect);
 
     if (drawBounds) {
         SkIRect drawIBounds;
         drawBounds->roundOut(&drawIBounds);
@@ skipping 25 matching lines @@
 
     SkAutoTUnref<GrTexture> copy(fContext->textureProvider()->refScratchTexture(desc,
         GrTextureProvider::kApprox_ScratchTexMatch));
 
     if (!copy) {
         SkDebugf("Failed to create temporary copy of destination texture.\n");
         return false;
     }
     SkIPoint dstPoint = {0, 0};
     if (this->copySurface(copy, rt, copyRect, dstPoint)) {
-        dstCopy->setTexture(copy);
-        dstCopy->setOffset(copyRect.fLeft, copyRect.fTop);
+        dstTexture->setTexture(copy);
+        dstTexture->setOffset(copyRect.fLeft, copyRect.fTop);
         return true;
     } else {
         return false;
     }
 }
 
 void GrDrawTarget::flush() {
     if (fFlushing) {
         return;
     }
@@ skipping 373 matching lines @@
            this->getGpu()->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
 }
 
 void GrDrawTarget::setupPipeline(const PipelineInfo& pipelineInfo,
                                  GrPipeline* pipeline) {
     SkNEW_PLACEMENT_ARGS(pipeline, GrPipeline, (*pipelineInfo.fPipelineBuilder,
                                                 pipelineInfo.fColorPOI,
                                                 pipelineInfo.fCoveragePOI,
                                                 *this->caps(),
                                                 *pipelineInfo.fScissor,
-                                                &pipelineInfo.fDstCopy));
+                                                &pipelineInfo.fDstTexture));
 }
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget::PipelineInfo::PipelineInfo(GrPipelineBuilder* pipelineBuilder,
                                          GrScissorState* scissor,
                                          const GrPrimitiveProcessor* primProc,
                                          const SkRect* devBounds,
                                          GrDrawTarget* target)
     : fPipelineBuilder(pipelineBuilder)
     , fScissor(scissor) {
     fColorPOI = fPipelineBuilder->colorProcInfo(primProc);
     fCoveragePOI = fPipelineBuilder->coverageProcInfo(primProc);
     if (!target->setupDstReadIfNecessary(*fPipelineBuilder, fColorPOI, fCoveragePOI,
-                                         &fDstCopy, devBounds)) {
+                                         &fDstTexture, devBounds)) {
         fPipelineBuilder = NULL;
     }
 }
 
 GrDrawTarget::PipelineInfo::PipelineInfo(GrPipelineBuilder* pipelineBuilder,
                                          GrScissorState* scissor,
                                          const GrBatch* batch,
                                          const SkRect* devBounds,
                                          GrDrawTarget* target)
     : fPipelineBuilder(pipelineBuilder)
     , fScissor(scissor) {
     fColorPOI = fPipelineBuilder->colorProcInfo(batch);
     fCoveragePOI = fPipelineBuilder->coverageProcInfo(batch);
     if (!target->setupDstReadIfNecessary(*fPipelineBuilder, fColorPOI, fCoveragePOI,
-                                         &fDstCopy, devBounds)) {
+                                         &fDstTexture, devBounds)) {
         fPipelineBuilder = NULL;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrShaderCaps::GrShaderCaps() {
     fShaderDerivativeSupport = false;
     fGeometryShaderSupport = false;
     fPathRenderingSupport = false;
@@ skipping 202 matching lines @@
                              GrPipelineBuilder::AutoRestoreFragmentProcessors* arfp,
                              GrPipelineBuilder::AutoRestoreStencil* ars,
                              GrScissorState* scissorState,
                              const SkRect* devBounds) {
     return fClipMaskManager.setupClipping(pipelineBuilder,
                                           arfp,
                                           ars,
                                           scissorState,
                                           devBounds);
 }