Create a static instances of SrcOver XferProcessor

src/gpu/GrXferProcessor.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrXferProcessor.h"
 #include "GrPipeline.h"
 #include "GrPipelineBuilder.h"
 #include "GrProcOptInfo.h"
 #include "gl/GrGLCaps.h"
 
 GrXferProcessor::GrXferProcessor()
     : fWillReadDstColor(false)
     , fDstReadUsesMixedSamples(false)
-    , fReadsCoverage(true)
     , fDstTextureOffset() {
 }
 
 GrXferProcessor::GrXferProcessor(const DstTexture* dstTexture,
                                  bool willReadDstColor,
                                  bool hasMixedSamples)
     : fWillReadDstColor(willReadDstColor)
     , fDstReadUsesMixedSamples(willReadDstColor && hasMixedSamples)
-    , fReadsCoverage(true)
     , fDstTextureOffset() {
     if (dstTexture && dstTexture->texture()) {
         SkASSERT(willReadDstColor);
         fDstTexture.reset(dstTexture->texture());
         fDstTextureOffset = dstTexture->offset();
         this->addTextureAccess(&fDstTexture);
         this->setWillReadFragmentPosition();
     }
 }
 
 GrXferProcessor::OptFlags GrXferProcessor::getOptimizations(
                                                        const GrPipelineOptimizations& optimizations,
                                                        bool doesStencilWrite,
                                                        GrColor* overrideColor,
-                                                       const GrCaps& caps) {
+                                                       const GrCaps& caps) const {
     GrXferProcessor::OptFlags flags = this->onGetOptimizations(optimizations,
                                                                doesStencilWrite,
                                                                overrideColor,
                                                                caps);
 
     if (this->willReadDstColor()) {
         // When performing a dst read we handle coverage in the base class.
         SkASSERT(!(flags & GrXferProcessor::kIgnoreCoverage_OptFlag));
         if (optimizations.fCoveragePOI.isSolidWhite()) {
             flags |= GrXferProcessor::kIgnoreCoverage_OptFlag;
         }
     }
-    if (flags & GrXferProcessor::kIgnoreCoverage_OptFlag) {
-        fReadsCoverage = false;
-    }
     return flags;
 }
 
 bool GrXferProcessor::hasSecondaryOutput() const {
     if (!this->willReadDstColor()) {
         return this->onHasSecondaryOutput();
     }
     return this->dstReadUsesMixedSamples();
 }
 
 void GrXferProcessor::getBlendInfo(BlendInfo* blendInfo) const {
     blendInfo->reset();
     if (!this->willReadDstColor()) {
         this->onGetBlendInfo(blendInfo);
     } else if (this->dstReadUsesMixedSamples()) {
         blendInfo->fDstBlend = kIS2A_GrBlendCoeff;
     }
 }
 
 void GrXferProcessor::getGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     uint32_t key = this->willReadDstColor() ? 0x1 : 0x0;
     if (key) {
         if (const GrTexture* dstTexture = this->getDstTexture()) {
             key |= 0x2;
             if (kTopLeft_GrSurfaceOrigin == dstTexture->origin()) {
                 key |= 0x4;
             }
         }
-        if (this->readsCoverage()) {
+        if (this->dstReadUsesMixedSamples()) {
             key |= 0x8;
         }
-        if (this->dstReadUsesMixedSamples()) {
-            key |= 0x10;
-        }
     }
     b->add32(key);
     this->onGetGLSLProcessorKey(caps, b);
 }
 
 GrXferBarrierType GrXferProcessor::xferBarrierType(const GrRenderTarget* rt,
                                                    const GrCaps& caps) const {
     SkASSERT(rt);
     if (static_cast<const GrSurface*>(rt) == this->getDstTexture()) {
         // Texture barriers are required when a shader reads and renders to the same texture.
@@ skipping 117 matching lines @@
 #endif
     return this->onCreateXferProcessor(caps, optimizations, hasMixedSamples, dstTexture);
 }
 
 bool GrXPFactory::willNeedDstTexture(const GrCaps& caps,
                                      const GrPipelineOptimizations& optimizations,
                                      bool hasMixedSamples) const {
     return (this->willReadDstColor(caps, optimizations, hasMixedSamples) &&
             !caps.shaderCaps()->dstReadInShaderSupport());
 }