Use static XPF for porter duff xp factories.

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 "GrPorterDuffXferProcessor.h"
 
 #include "GrBackendProcessorFactory.h"
@@ skipping 43 matching lines @@
 const GrBackendFragmentProcessorFactory& GrPorterDuffXferProcessor::getFactory() const {
     return GrTBackendFragmentProcessorFactory<GrPorterDuffXferProcessor>::getInstance();
 }
 
 void GrPorterDuffXferProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+GrXPFactory* GrPorterDuffXPFactory::Create(SkXfermode::Mode mode) {
+    switch (mode) {
+        case SkXfermode::kClear_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gClearPDXPF, GrPorterDuffXPFactory, (kZero_GrBlendCoeff,
+                                                                             kZero_GrBlendCoeff));
+            return SkRef(gClearPDXPF);
+            break;
+        case SkXfermode::kSrc_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gSrcPDXPF, GrPorterDuffXPFactory, (kOne_GrBlendCoeff,
+                                                                           kZero_GrBlendCoeff));
+            return SkRef(gSrcPDXPF);
+            break;
+        case SkXfermode::kDst_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gDstPDXPF, GrPorterDuffXPFactory, (kZero_GrBlendCoeff,
+                                                                           kOne_GrBlendCoeff));
+            return SkRef(gDstPDXPF);
+            break;
+        case SkXfermode::kSrcOver_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gSrcOverPDXPF, GrPorterDuffXPFactory, (kOne_GrBlendCoeff,
+                                                                               kISA_GrBlendCoeff));
+            return SkRef(gSrcOverPDXPF);
+            break;
+        case SkXfermode::kDstOver_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gDstOverPDXPF, GrPorterDuffXPFactory, (kIDA_GrBlendCoeff,
+                                                                               kOne_GrBlendCoeff));
+            return SkRef(gDstOverPDXPF);
+            break;
+        case SkXfermode::kSrcIn_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gSrcInPDXPF, GrPorterDuffXPFactory, (kDA_GrBlendCoeff,
+                                                                             kZero_GrBlendCoeff));
+            return SkRef(gSrcInPDXPF);
+            break;
+        case SkXfermode::kDstIn_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gDstInPDXPF, GrPorterDuffXPFactory, (kZero_GrBlendCoeff,
+                                                                             kSA_GrBlendCoeff));
+            return SkRef(gDstInPDXPF);
+            break;
+        case SkXfermode::kSrcOut_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gSrcOutPDXPF, GrPorterDuffXPFactory, (kIDA_GrBlendCoeff,
+                                                                              kZero_GrBlendCoeff));
+            return SkRef(gSrcOutPDXPF);
+            break;
+        case SkXfermode::kDstOut_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gDstOutPDXPF, GrPorterDuffXPFactory, (kZero_GrBlendCoeff,
+                                                                              kISA_GrBlendCoeff));
+            return SkRef(gDstOutPDXPF);
+            break;
+        case SkXfermode::kSrcATop_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gSrcATopPDXPF, GrPorterDuffXPFactory, (kDA_GrBlendCoeff,
+                                                                               kISA_GrBlendCoeff));
+            return SkRef(gSrcATopPDXPF);
+            break;
+        case SkXfermode::kDstATop_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gDstATopPDXPF, GrPorterDuffXPFactory, (kIDA_GrBlendCoeff,
+                                                                               kSA_GrBlendCoeff));
+            return SkRef(gDstATopPDXPF);
+            break;
+        case SkXfermode::kXor_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gXorPDXPF, GrPorterDuffXPFactory, (kIDA_GrBlendCoeff,
+                                                                           kISA_GrBlendCoeff));
+            return SkRef(gXorPDXPF);
+            break;
+        case SkXfermode::kPlus_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gPlusPDXPF, GrPorterDuffXPFactory, (kOne_GrBlendCoeff,
+                                                                            kOne_GrBlendCoeff));
+            return SkRef(gPlusPDXPF);
+            break;
+        case SkXfermode::kModulate_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gModulatePDXPF, GrPorterDuffXPFactory, (kZero_GrBlendCoeff,
+                                                                                kSC_GrBlendCoeff));
+            return SkRef(gModulatePDXPF);
+            break;
+        case SkXfermode::kScreen_Mode:
+            GR_CREATE_STATIC_XP_FACTORY(gScreenPDXPF, GrPorterDuffXPFactory, (kOne_GrBlendCoeff,
+                                                                              kISC_GrBlendCoeff));
+            return SkRef(gScreenPDXPF);
+            break;
+        default:
+            return NULL;
+    }
+}
+
 const GrXferProcessor* GrPorterDuffXPFactory::createXferProcessor() const {
     return GrPorterDuffXferProcessor::Create(fSrc, fDst);
 }
 
 bool GrPorterDuffXPFactory::supportsRGBCoverage(GrColor /*knownColor*/,
                                                 uint32_t knownColorFlags) const {
     if (kOne_GrBlendCoeff == fSrc && kISA_GrBlendCoeff == fDst &&
         kRGBA_GrColorComponentFlags == knownColorFlags) {
         return true;
     }
     return false;
 }