Revert of Make specialized SrcOver XPFactory

src/gpu/effects/GrPorterDuffXferProcessor.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/GrPorterDuffXferProcessor.h"
 
 #include "GrBlend.h"
@@ skipping 673 matching lines @@
         // We want to force our primary output to be alpha * Coverage, where alpha is the alpha
         // value of the blend the constant. We should already have valid blend coeff's if we are at
         // a point where we have RGB coverage. We don't need any color stages since the known color
         // output is already baked into the blendConstant.
         *overrideColor = GrColorPackRGBA(fAlpha, fAlpha, fAlpha, fAlpha);
         return GrXferProcessor::kOverrideColor_OptFlag;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrPDXPFactory::GrPDXPFactory(SkXfermode::Mode xfermode)
+GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkXfermode::Mode xfermode)
     : fXfermode(xfermode) {
     SkASSERT(fXfermode <= SkXfermode::kLastCoeffMode);
-    this->initClassID<GrPDXPFactory>();
+    this->initClassID<GrPorterDuffXPFactory>();
 }
 
-const GrXPFactory* GrPDXPFactory::Create(SkXfermode::Mode xfermode) {
-    static const GrPDXPFactory gClearPDXPF(SkXfermode::kClear_Mode);
-    static const GrPDXPFactory gSrcPDXPF(SkXfermode::kSrc_Mode);
-    static const GrPDXPFactory gDstPDXPF(SkXfermode::kDst_Mode);
-    static const GrPDXPFactory gSrcOverPDXPF(SkXfermode::kSrcOver_Mode);
-    static const GrPDXPFactory gDstOverPDXPF(SkXfermode::kDstOver_Mode);
-    static const GrPDXPFactory gSrcInPDXPF(SkXfermode::kSrcIn_Mode);
-    static const GrPDXPFactory gDstInPDXPF(SkXfermode::kDstIn_Mode);
-    static const GrPDXPFactory gSrcOutPDXPF(SkXfermode::kSrcOut_Mode);
-    static const GrPDXPFactory gDstOutPDXPF(SkXfermode::kDstOut_Mode);
-    static const GrPDXPFactory gSrcATopPDXPF(SkXfermode::kSrcATop_Mode);
-    static const GrPDXPFactory gDstATopPDXPF(SkXfermode::kDstATop_Mode);
-    static const GrPDXPFactory gXorPDXPF(SkXfermode::kXor_Mode);
-    static const GrPDXPFactory gPlusPDXPF(SkXfermode::kPlus_Mode);
-    static const GrPDXPFactory gModulatePDXPF(SkXfermode::kModulate_Mode);
-    static const GrPDXPFactory gScreenPDXPF(SkXfermode::kScreen_Mode);
+GrXPFactory* GrPorterDuffXPFactory::Create(SkXfermode::Mode xfermode) {
+    static GrPorterDuffXPFactory gClearPDXPF(SkXfermode::kClear_Mode);
+    static GrPorterDuffXPFactory gSrcPDXPF(SkXfermode::kSrc_Mode);
+    static GrPorterDuffXPFactory gDstPDXPF(SkXfermode::kDst_Mode);
+    static GrPorterDuffXPFactory gSrcOverPDXPF(SkXfermode::kSrcOver_Mode);
+    static GrPorterDuffXPFactory gDstOverPDXPF(SkXfermode::kDstOver_Mode);
+    static GrPorterDuffXPFactory gSrcInPDXPF(SkXfermode::kSrcIn_Mode);
+    static GrPorterDuffXPFactory gDstInPDXPF(SkXfermode::kDstIn_Mode);
+    static GrPorterDuffXPFactory gSrcOutPDXPF(SkXfermode::kSrcOut_Mode);
+    static GrPorterDuffXPFactory gDstOutPDXPF(SkXfermode::kDstOut_Mode);
+    static GrPorterDuffXPFactory gSrcATopPDXPF(SkXfermode::kSrcATop_Mode);
+    static GrPorterDuffXPFactory gDstATopPDXPF(SkXfermode::kDstATop_Mode);
+    static GrPorterDuffXPFactory gXorPDXPF(SkXfermode::kXor_Mode);
+    static GrPorterDuffXPFactory gPlusPDXPF(SkXfermode::kPlus_Mode);
+    static GrPorterDuffXPFactory gModulatePDXPF(SkXfermode::kModulate_Mode);
+    static GrPorterDuffXPFactory gScreenPDXPF(SkXfermode::kScreen_Mode);
 
-    static const GrPDXPFactory* gFactories[] = {
+    static GrPorterDuffXPFactory* gFactories[] = {
         &gClearPDXPF, &gSrcPDXPF, &gDstPDXPF, &gSrcOverPDXPF, &gDstOverPDXPF, &gSrcInPDXPF,
         &gDstInPDXPF, &gSrcOutPDXPF, &gDstOutPDXPF, &gSrcATopPDXPF, &gDstATopPDXPF, &gXorPDXPF,
         &gPlusPDXPF, &gModulatePDXPF, &gScreenPDXPF
     };
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFactories) == SkXfermode::kLastCoeffMode + 1);
 
     if (xfermode < 0 || xfermode > SkXfermode::kLastCoeffMode) {
         return nullptr;
     }
     return SkRef(gFactories[xfermode]);
 }
 
 GrXferProcessor*
-GrPDXPFactory::onCreateXferProcessor(const GrCaps& caps,
+GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& covPOI,
                                              bool hasMixedSamples,
                                              const DstTexture* dstTexture) const {
     BlendFormula blendFormula;
     if (covPOI.isFourChannelOutput()) {
         if (SkXfermode::kSrcOver_Mode == fXfermode &&
             kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
             !caps.shaderCaps()->dualSourceBlendingSupport() &&
             !caps.shaderCaps()->dstReadInShaderSupport()) {
             // If we don't have dual source blending or in shader dst reads, we fall back to this
             // trick for rendering SrcOver LCD text instead of doing a dst copy.
             SkASSERT(!dstTexture || !dstTexture->texture());
             return PDLCDXferProcessor::Create(fXfermode, colorPOI);
         }
         blendFormula = get_lcd_blend_formula(covPOI, fXfermode);
     } else {
         blendFormula = get_blend_formula(colorPOI, covPOI, hasMixedSamples, fXfermode);
     }
 
     if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) {
         return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, fXfermode);
     }
 
     SkASSERT(!dstTexture || !dstTexture->texture());
     return new PorterDuffXferProcessor(blendFormula);
 }
 
-void GrPDXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
+void GrPorterDuffXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                                      InvariantBlendedColor* blendedColor) const {
     // Find the blended color info based on the formula that does not have coverage.
     BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][fXfermode];
     if (colorFormula.usesDstColor()) {
         blendedColor->fWillBlendWithDst = true;
         blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
         return;
     }
 
     blendedColor->fWillBlendWithDst = false;
@@ skipping 10 matching lines @@
             blendedColor->fKnownColor = colorPOI.color();
             blendedColor->fKnownColorFlags = colorPOI.validFlags();
             return;
 
         default:
             blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
             return;
     }
 }
 
-bool GrPDXPFactory::willReadDstColor(const GrCaps& caps,
+bool GrPorterDuffXPFactory::willReadDstColor(const GrCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& covPOI,
                                              bool hasMixedSamples) const {
     if (caps.shaderCaps()->dualSourceBlendingSupport()) {
         return false;
     }
     
     // When we have four channel coverage we always need to read the dst in order to correctly
     // blend. The one exception is when we are using srcover mode and we know the input color into
     // the XP.
     if (covPOI.isFourChannelOutput()) {
         if (SkXfermode::kSrcOver_Mode == fXfermode &&
             kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
             !caps.shaderCaps()->dstReadInShaderSupport()) {
             return false;
         }
         return get_lcd_blend_formula(covPOI, fXfermode).hasSecondaryOutput();
     }
     // We fallback on the shader XP when the blend formula would use dual source blending but we
     // don't have support for it.
     return get_blend_formula(colorPOI, covPOI, hasMixedSamples, fXfermode).hasSecondaryOutput();
 }
 
-GR_DEFINE_XP_FACTORY_TEST(GrPDXPFactory);
+GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
-const GrXPFactory* GrPDXPFactory::TestCreate(GrProcessorTestData* d) {
+const GrXPFactory* GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) {
     SkXfermode::Mode mode = SkXfermode::Mode(d->fRandom->nextULessThan(SkXfermode::kLastCoeffMode));
-    return GrPDXPFactory::Create(mode);
+    return GrPorterDuffXPFactory::Create(mode);
 }
 
-void GrPDXPFactory::TestGetXPOutputTypes(const GrXferProcessor* xp,
-                                         int* outPrimary,
-                                         int* outSecondary) {
+void GrPorterDuffXPFactory::TestGetXPOutputTypes(const GrXferProcessor* xp,
+                                                 int* outPrimary,
+                                                 int* outSecondary) {
     if (!!strcmp(xp->name(), "Porter Duff")) {
         *outPrimary = *outSecondary = -1;
         return;
     }
     BlendFormula blendFormula = static_cast<const PorterDuffXferProcessor*>(xp)->getBlendFormula();
     *outPrimary = blendFormula.fPrimaryOutputType;
     *outSecondary = blendFormula.fSecondaryOutputType;
 }
-
-////////////////////////////////////////////////////////////////////////////////
-
-GrSrcOverPDXPFactory::GrSrcOverPDXPFactory() {
-    this->initClassID<GrSrcOverPDXPFactory>();
-}
-
-GrXferProcessor*
-GrSrcOverPDXPFactory::onCreateXferProcessor(const GrCaps& caps,
-                                            const GrProcOptInfo& colorPOI,
-                                            const GrProcOptInfo& covPOI,
-                                            bool hasMixedSamples,
-                                            const DstTexture* dstTexture) const {
-    BlendFormula blendFormula;
-    if (covPOI.isFourChannelOutput()) {
-        if (kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
-            !caps.shaderCaps()->dualSourceBlendingSupport() &&
-            !caps.shaderCaps()->dstReadInShaderSupport()) {
-            // If we don't have dual source blending or in shader dst reads, we fall back to this
-            // trick for rendering SrcOver LCD text instead of doing a dst copy.
-            SkASSERT(!dstTexture || !dstTexture->texture());
-            return PDLCDXferProcessor::Create(SkXfermode::kSrcOver_Mode, colorPOI);
-        }
-        blendFormula = get_lcd_blend_formula(covPOI, SkXfermode::kSrcOver_Mode);
-    } else {
-        blendFormula = get_blend_formula(colorPOI, covPOI, hasMixedSamples,
-                                         SkXfermode::kSrcOver_Mode);
-    }
-
-    if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) {
-        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkXfermode::kSrcOver_Mode);
-    }
-
-    SkASSERT(!dstTexture || !dstTexture->texture());
-    return new PorterDuffXferProcessor(blendFormula);
-}
-
-void GrSrcOverPDXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
-                                                    InvariantBlendedColor* blendedColor) const {
-    if (!colorPOI.isOpaque()) {
-        blendedColor->fWillBlendWithDst = true;
-        blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
-        return;
-    }
-
-    blendedColor->fWillBlendWithDst = false;
-
-    blendedColor->fKnownColor = colorPOI.color();
-    blendedColor->fKnownColorFlags = colorPOI.validFlags();
-}
-
-bool GrSrcOverPDXPFactory::willReadDstColor(const GrCaps& caps,
-                                            const GrProcOptInfo& colorPOI,
-                                            const GrProcOptInfo& covPOI,
-                                            bool hasMixedSamples) const {
-    if (caps.shaderCaps()->dualSourceBlendingSupport()) {
-        return false;
-    }
-
-    // When we have four channel coverage we always need to read the dst in order to correctly
-    // blend. The one exception is when we are using srcover mode and we know the input color into
-    // the XP.
-    if (covPOI.isFourChannelOutput()) {
-        if (kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
-            !caps.shaderCaps()->dstReadInShaderSupport()) {
-            return false;
-        }
-        return get_lcd_blend_formula(covPOI, SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
-    }
-    // We fallback on the shader XP when the blend formula would use dual source blending but we
-    // don't have support for it.
-    return get_blend_formula(colorPOI, covPOI,
-                             hasMixedSamples, SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
-}
-
-GR_DEFINE_XP_FACTORY_TEST(GrSrcOverPDXPFactory);
-
-const GrXPFactory* GrSrcOverPDXPFactory::TestCreate(GrProcessorTestData* d) {
-    return SkRef(&GrPorterDuffXPFactory::gSrcOverPDXPFactory);
-}
-