Use GLSLCaps for creating processor keys and GLSL-specific programs

src/gpu/effects/GrCoverageSetOpXP.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrCoverageSetOpXP.h"
 #include "GrColor.h"
@@ skipping 22 matching lines @@
                                                const GrProcOptInfo& coveragePOI,
                                                bool doesStencilWrite,
                                                GrColor* color,
                                                const GrDrawTargetCaps& caps) override;
 
     bool invertCoverage() const { return fInvertCoverage; }
 
 private:
     CoverageSetOpXP(SkRegion::Op regionOp, bool fInvertCoverage);
 
-    void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
+    void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     void onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override;
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override {
         const CoverageSetOpXP& xp = xpBase.cast<CoverageSetOpXP>();
         return (fRegionOp == xp.fRegionOp &&
                 fInvertCoverage == xp.fInvertCoverage);
     }
 
     SkRegion::Op fRegionOp;
     bool         fInvertCoverage;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GLCoverageSetOpXP : public GrGLXferProcessor {
 public:
     GLCoverageSetOpXP(const GrProcessor&) {}
 
     ~GLCoverageSetOpXP() override {}
 
-    static void GenKey(const GrProcessor& processor, const GrGLCaps& caps,
+    static void GenKey(const GrProcessor& processor, const GrGLSLCaps& caps,
                        GrProcessorKeyBuilder* b) {
         const CoverageSetOpXP& xp = processor.cast<CoverageSetOpXP>();
         uint32_t key = xp.invertCoverage() ?  0x0 : 0x1;
         b->add32(key);
     };
 
 private:
     void onEmitCode(const EmitArgs& args) override {
         const CoverageSetOpXP& xp = args.fXP.cast<CoverageSetOpXP>();
         GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
@@ skipping 14 matching lines @@
 
 CoverageSetOpXP::CoverageSetOpXP(SkRegion::Op regionOp, bool invertCoverage)
     : fRegionOp(regionOp)
     , fInvertCoverage(invertCoverage) {
     this->initClassID<CoverageSetOpXP>();
 }
 
 CoverageSetOpXP::~CoverageSetOpXP() {
 }
 
-void CoverageSetOpXP::onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const {
+void CoverageSetOpXP::onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLCoverageSetOpXP::GenKey(*this, caps, b);
 }
 
 GrGLXferProcessor* CoverageSetOpXP::createGLInstance() const {
     return SkNEW_ARGS(GLCoverageSetOpXP, (*this));
 }
 
 GrXferProcessor::OptFlags
 CoverageSetOpXP::getOptimizations(const GrProcOptInfo& colorPOI,
                                   const GrProcOptInfo& coveragePOI,
@@ skipping 139 matching lines @@
 
 GrXPFactory* GrCoverageSetOpXPFactory::TestCreate(SkRandom* random,
                                                   GrContext*,
                                                   const GrDrawTargetCaps&,
                                                   GrTexture*[]) {
     SkRegion::Op regionOp = SkRegion::Op(random->nextULessThan(SkRegion::kLastOp + 1));
     bool invertCoverage = random->nextBool();
     return GrCoverageSetOpXPFactory::Create(regionOp, invertCoverage);
 }