Only discard for XP dstCopies if we have a coverage value.

src/gpu/effects/GrCustomXfermode.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 "effects/GrCustomXfermode.h"
 #include "effects/GrCustomXfermodePriv.h"
 
@@ skipping 507 matching lines @@
     }
 
     ~CustomXP() override {};
 
     const char* name() const override { return "Custom Xfermode"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
     bool hasSecondaryOutput() const override { return false; }
 
-    GrXferProcessor::OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
-                                               const GrProcOptInfo& coveragePOI,
-                                               bool doesStencilWrite,
-                                               GrColor* overrideColor,
-                                               const GrDrawTargetCaps& caps) override;
-
     SkXfermode::Mode mode() const { return fMode; }
-    bool hasCoverage() const { return fHasCoverage; }
     bool hasHWBlendEquation() const { return kInvalid_GrBlendEquation != fHWBlendEquation; }
 
     GrBlendEquation hwBlendEquation() const {
         SkASSERT(this->hasHWBlendEquation());
         return fHWBlendEquation;
     }
 
 private:
     CustomXP(SkXfermode::Mode mode, const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
 
+    GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
+                                                 const GrProcOptInfo& coveragePOI,
+                                                 bool doesStencilWrite,
+                                                 GrColor* overrideColor,
+                                                 const GrDrawTargetCaps& caps) override;
+
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onWillNeedXferBarrier(const GrRenderTarget* rt,
                                const GrDrawTargetCaps& caps,
                                GrXferBarrierType* outBarrierType) const override;
 
     void onGetBlendInfo(BlendInfo*) const override;
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override;
 
     SkXfermode::Mode fMode;
-    bool             fHasCoverage;
     GrBlendEquation  fHWBlendEquation;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrXPFactory* GrCustomXfermode::CreateXPFactory(SkXfermode::Mode mode) {
     if (!GrCustomXfermode::IsSupportedMode(mode)) {
         return NULL;
     } else {
         return SkNEW_ARGS(GrCustomXPFactory, (mode));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GLCustomXP : public GrGLXferProcessor {
 public:
     GLCustomXP(const GrXferProcessor&) {}
     ~GLCustomXP() override {}
 
     static void GenKey(const GrXferProcessor& p, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) {
         const CustomXP& xp = p.cast<CustomXP>();
         uint32_t key = xp.numTextures();
         SkASSERT(key <= 1);
-        key |= xp.hasCoverage() << 1;
+        key |= xp.readsCoverage() << 1;
         if (xp.hasHWBlendEquation()) {
             SkASSERT(caps.advBlendEqInteraction() > 0);  // 0 will mean !xp.hasHWBlendEquation().
             key |= caps.advBlendEqInteraction() << 2;
         }
         if (!xp.hasHWBlendEquation() || caps.mustEnableSpecificAdvBlendEqs()) {
             GR_STATIC_ASSERT(GrGLSLCaps::kLast_AdvBlendEqInteraction < 4);
             key |= xp.mode() << 4;
         }
         b->add32(key);
     }
 
 private:
     void onEmitCode(const EmitArgs& args) override {
         const CustomXP& xp = args.fXP.cast<CustomXP>();
         GrGLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
 
         if (xp.hasHWBlendEquation()) {
             // The blend mode will be implemented in hardware; only output the src color.
             fsBuilder->enableAdvancedBlendEquationIfNeeded(xp.hwBlendEquation());
-            if (xp.hasCoverage()) {
+            if (xp.readsCoverage()) {
                 // Do coverage modulation by multiplying it into the src color before blending.
                 // (See getOptimizations())
                 fsBuilder->codeAppendf("%s = %s * %s;",
                                        args.fOutputPrimary, args.fInputCoverage, args.fInputColor);
             } else {
                 fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputColor);
             }
         } else {
             const char* dstColor = fsBuilder->dstColor();
             emit_custom_xfermode_code(xp.mode(), fsBuilder, args.fOutputPrimary, args.fInputColor,
                                       dstColor);
-            if (xp.hasCoverage()) {
+            if (xp.readsCoverage()) {
                 fsBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
                                        args.fOutputPrimary, args.fOutputPrimary,
                                        args.fInputCoverage, args.fInputCoverage, dstColor);
             }
         }
     }
 
     void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CustomXP::CustomXP(SkXfermode::Mode mode, const GrDeviceCoordTexture* dstCopy,
                    bool willReadDstColor)
     : INHERITED(dstCopy, willReadDstColor),
       fMode(mode),
-      fHasCoverage(true),
       fHWBlendEquation(kInvalid_GrBlendEquation) {
     this->initClassID<CustomXP>();
 }
 
 void CustomXP::onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLCustomXP::GenKey(*this, caps, b);
 }
 
 GrGLXferProcessor* CustomXP::createGLInstance() const {
     SkASSERT(this->willReadDstColor() != this->hasHWBlendEquation());
     return SkNEW_ARGS(GLCustomXP, (*this));
 }
 
 bool CustomXP::onIsEqual(const GrXferProcessor& other) const {
     const CustomXP& s = other.cast<CustomXP>();
-    return fMode == s.fMode &&
-           fHasCoverage == s.fHasCoverage &&
-           fHWBlendEquation == s.fHWBlendEquation;
+    return fMode == s.fMode && fHWBlendEquation == s.fHWBlendEquation;
 }
 
-GrXferProcessor::OptFlags CustomXP::getOptimizations(const GrProcOptInfo& colorPOI,
+GrXferProcessor::OptFlags CustomXP::onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                        const GrProcOptInfo& coveragePOI,
                                                        bool doesStencilWrite,
                                                        GrColor* overrideColor,
                                                        const GrDrawTargetCaps& caps) {
   /*
     Most the optimizations we do here are based on tweaking alpha for coverage.
 
     The general SVG blend equation is defined in the spec as follows:
 
       Dca' = B(Sc, Dc) * Sa * Da + Y * Sca * (1-Da) + Z * Dca * (1-Sa)
@@ skipping 86 matching lines @@
         = f*Sa + Da - f*Sa * Da
         = blend(f*Sa, Da)
    */
 
     OptFlags flags = kNone_Opt;
     if (colorPOI.allStagesMultiplyInput()) {
         flags = flags | kCanTweakAlphaForCoverage_OptFlag;
     }
     if (coveragePOI.isSolidWhite()) {
         flags = flags | kIgnoreCoverage_OptFlag;
-        fHasCoverage = false;
     }
     if (caps.advancedBlendEquationSupport() && !coveragePOI.isFourChannelOutput()) {
         // This blend mode can be implemented in hardware.
         fHWBlendEquation = hw_blend_equation(fMode);
     }
     return flags;
 }
 
 bool CustomXP::onWillNeedXferBarrier(const GrRenderTarget* rt,
                                      const GrDrawTargetCaps& caps,
@@ skipping 50 matching lines @@
 GR_DEFINE_XP_FACTORY_TEST(GrCustomXPFactory);
 GrXPFactory* GrCustomXPFactory::TestCreate(SkRandom* rand,
                                            GrContext*,
                                            const GrDrawTargetCaps&,
                                            GrTexture*[]) {
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(GrCustomXPFactory, (static_cast<SkXfermode::Mode>(mode)));
 }