Create a static instances of SrcOver XferProcessor

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 "GrCoordTransform.h"
@@ skipping 85 matching lines @@
 
     GrBlendEquation hwBlendEquation() const {
         SkASSERT(this->hasHWBlendEquation());
         return fHWBlendEquation;
     }
 
 private:
     GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
-                                                 const GrCaps& caps) override;
+                                                 const GrCaps& caps) const override;
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     GrXferBarrierType onXferBarrier(const GrRenderTarget*, const GrCaps&) const override;
 
     void onGetBlendInfo(BlendInfo*) const override;
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override;
 
     const SkXfermode::Mode fMode;
     const GrBlendEquation  fHWBlendEquation;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GLCustomXP : public GrGLSLXferProcessor {
 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 = 0;
         if (xp.hasHWBlendEquation()) {
             SkASSERT(caps.advBlendEqInteraction() > 0);  // 0 will mean !xp.hasHWBlendEquation().
             key |= caps.advBlendEqInteraction();
-            key |= xp.readsCoverage() << 2;
             GR_STATIC_ASSERT(GrGLSLCaps::kLast_AdvBlendEqInteraction < 4);
         }
         if (!xp.hasHWBlendEquation() || caps.mustEnableSpecificAdvBlendEqs()) {
             key |= xp.mode() << 3;
         }
         b->add32(key);
     }
 
 private:
     void emitOutputsForBlendState(const EmitArgs& args) override {
         const CustomXP& xp = args.fXP.cast<CustomXP>();
         SkASSERT(xp.hasHWBlendEquation());
 
         GrGLSLXPFragmentBuilder* fragBuilder = args.fXPFragBuilder;
         fragBuilder->enableAdvancedBlendEquationIfNeeded(xp.hwBlendEquation());
 
         // Apply coverage by multiplying it into the src color before blending. Mixed samples will
         // "just work" automatically. (See onGetOptimizations())
-        if (xp.readsCoverage()) {
+        if (args.fInputCoverage) {
             fragBuilder->codeAppendf("%s = %s * %s;",
                                      args.fOutputPrimary, args.fInputCoverage, args.fInputColor);
         } else {
             fragBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputColor);
         }
     }
 
     void emitBlendCodeForDstRead(GrGLSLXPBuilder* pb,
                                  GrGLSLXPFragmentBuilder* fragBuilder,
                                  const char* srcColor,
@@ skipping 23 matching lines @@
 }
 
 bool CustomXP::onIsEqual(const GrXferProcessor& other) const {
     const CustomXP& s = other.cast<CustomXP>();
     return fMode == s.fMode && fHWBlendEquation == s.fHWBlendEquation;
 }
 
 GrXferProcessor::OptFlags CustomXP::onGetOptimizations(const GrPipelineOptimizations& optimizations,
                                                        bool doesStencilWrite,
                                                        GrColor* overrideColor,
-                                                       const GrCaps& caps) {
+                                                       const GrCaps& caps) const {
   /*
     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)
       Da'  = X * Sa * Da + Y * Sa * (1-Da) + Z * Da * (1-Sa)
 
     (Note that Sca, Dca indicate RGB vectors that are premultiplied by alpha,
      and that B(Sc, Dc) is a mode-specific function that accepts non-multiplied
@@ skipping 177 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrXPFactory* GrCustomXfermode::CreateXPFactory(SkXfermode::Mode mode) {
     if (!GrCustomXfermode::IsSupportedMode(mode)) {
         return nullptr;
     } else {
         return new CustomXPFactory(mode);
     }
 }