Revert of Move DstCopy on gpu into the GrXferProcessor.

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"
 #include "GrDrawTargetCaps.h"
 #include "GrProcessor.h"
 #include "GrProcOptInfo.h"
 #include "gl/GrGLXferProcessor.h"
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 class GrGLCoverageSetOpXP : public GrGLXferProcessor {
 public:
     GrGLCoverageSetOpXP(const GrProcessor&) {}
 
     ~GrGLCoverageSetOpXP() SK_OVERRIDE {}
 
+    void emitCode(const EmitArgs& args) SK_OVERRIDE {
+        const GrCoverageSetOpXP& xp = args.fXP.cast<GrCoverageSetOpXP>();
+        GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
+
+        if (xp.invertCoverage()) {
+            fsBuilder->codeAppendf("%s = 1.0 - %s;", args.fOutputPrimary, args.fInputCoverage);
+        } else {
+            fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputCoverage);
+        }
+    }
+
+    void setData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {};
+
     static void GenKey(const GrProcessor& processor, const GrGLCaps& caps,
                        GrProcessorKeyBuilder* b) {
         const GrCoverageSetOpXP& xp = processor.cast<GrCoverageSetOpXP>();
         uint32_t key = xp.invertCoverage() ?  0x0 : 0x1;
         b->add32(key);
     };
 
 private:
-    void onEmitCode(const EmitArgs& args) SK_OVERRIDE {
-        const GrCoverageSetOpXP& xp = args.fXP.cast<GrCoverageSetOpXP>();
-        GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
-
-        if (xp.invertCoverage()) {
-            fsBuilder->codeAppendf("%s = 1.0 - %s;", args.fOutputPrimary, args.fInputCoverage);
-        } else {
-            fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputCoverage);
-        }
-    }
-
-    void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {};
-
     typedef GrGLXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrCoverageSetOpXP::GrCoverageSetOpXP(SkRegion::Op regionOp, bool invertCoverage)
     : fRegionOp(regionOp)
     , fInvertCoverage(invertCoverage) {
     this->initClassID<GrCoverageSetOpXP>();
 }
 
 GrCoverageSetOpXP::~GrCoverageSetOpXP() {
 }
 
-void GrCoverageSetOpXP::onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const {
+void GrCoverageSetOpXP::getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const {
     GrGLCoverageSetOpXP::GenKey(*this, caps, b);
 }
 
 GrGLXferProcessor* GrCoverageSetOpXP::createGLInstance() const {
     return SkNEW_ARGS(GrGLCoverageSetOpXP, (*this));
 }
 
 GrXferProcessor::OptFlags
 GrCoverageSetOpXP::getOptimizations(const GrProcOptInfo& colorPOI,
                                     const GrProcOptInfo& coveragePOI,
@@ skipping 102 matching lines @@
                 static GrCoverageSetOpXPFactory gRevDiffCDXPF(regionOp, invertCoverage);
                 return SkRef(&gRevDiffCDXPF);
             }
             break;
         }
         default:
             return NULL;
     }
 }
 
-GrXferProcessor*
-GrCoverageSetOpXPFactory::onCreateXferProcessor(const GrProcOptInfo& colorPOI,
-                                                const GrProcOptInfo& covPOI,
-                                                const GrDeviceCoordTexture* dstCopy) const {
+GrXferProcessor* GrCoverageSetOpXPFactory::createXferProcessor(const GrProcOptInfo& /* colorPOI*/,
+                                                               const GrProcOptInfo& covPOI) const {
     return GrCoverageSetOpXP::Create(fRegionOp, fInvertCoverage);
 }
 
 void GrCoverageSetOpXPFactory::getInvariantOutput(const GrProcOptInfo& colorPOI,
                                                   const GrProcOptInfo& coveragePOI,
                                                   GrXPFactory::InvariantOutput* output) const {
     if (SkRegion::kReplace_Op == fRegionOp) {
         if (coveragePOI.isSolidWhite()) {
             output->fBlendedColor = GrColor_WHITE;
             output->fBlendedColorFlags = kRGBA_GrColorComponentFlags;
@@ skipping 12 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);
 }