Re-enable advanced blend with a blacklist

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 "effects/GrCustomXfermodePriv.h"
 
@@ skipping 33 matching lines @@
     GR_STATIC_ASSERT(kDifference_GrBlendEquation == SkXfermode::kDifference_Mode + kOffset);
     GR_STATIC_ASSERT(kExclusion_GrBlendEquation == SkXfermode::kExclusion_Mode + kOffset);
     GR_STATIC_ASSERT(kMultiply_GrBlendEquation == SkXfermode::kMultiply_Mode + kOffset);
     GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == SkXfermode::kHue_Mode + kOffset);
     GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == SkXfermode::kSaturation_Mode + kOffset);
     GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == SkXfermode::kColor_Mode + kOffset);
     GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == SkXfermode::kLuminosity_Mode + kOffset);
     GR_STATIC_ASSERT(kGrBlendEquationCnt == SkXfermode::kLastMode + 1 + kOffset);
 }
 
-static bool can_use_hw_blend_equation(const GrProcOptInfo& coveragePOI, const GrCaps& caps) {
+static bool can_use_hw_blend_equation(GrBlendEquation equation,
+                                      const GrProcOptInfo& coveragePOI,
+                                      const GrCaps& caps) {
     if (!caps.advancedBlendEquationSupport()) {
         return false;
     }
     if (coveragePOI.isFourChannelOutput()) {
         return false; // LCD coverage must be applied after the blend equation.
     }
+    if (caps.canUseAdvancedBlendEquation(equation)) {
+        return false;
+    }
     return true;
 }
 
 static void hard_light(GrGLFragmentBuilder* fsBuilder,
                        const char* final,
                        const char* src,
                        const char* dst) {
     static const char kComponents[] = {'r', 'g', 'b'};
     for (size_t i = 0; i < SK_ARRAY_COUNT(kComponents); ++i) {
         char component = kComponents[i];
@@ skipping 710 matching lines @@
     SkASSERT(GrCustomXfermode::IsSupportedMode(fMode));
     this->initClassID<GrCustomXPFactory>();
 }
 
 GrXferProcessor*
 GrCustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
                                          const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI,
                                          bool hasMixedSamples,
                                          const DstTexture* dstTexture) const {
-    if (can_use_hw_blend_equation(coveragePOI, caps)) {
+    if (can_use_hw_blend_equation(fHWBlendEquation, coveragePOI, caps)) {
         SkASSERT(!dstTexture || !dstTexture->texture());
         return SkNEW_ARGS(CustomXP, (fMode, fHWBlendEquation));
     }
     return SkNEW_ARGS(CustomXP, (dstTexture, hasMixedSamples, fMode));
 }
 
 bool GrCustomXPFactory::willReadDstColor(const GrCaps& caps,
                                          const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI,
                                          bool hasMixedSamples) const {
-    return !can_use_hw_blend_equation(coveragePOI, caps);
+    return !can_use_hw_blend_equation(fHWBlendEquation, coveragePOI, caps);
 }
 
 void GrCustomXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                                  InvariantBlendedColor* blendedColor) const {
     blendedColor->fWillBlendWithDst = true;
     blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrCustomXPFactory);
 GrXPFactory* GrCustomXPFactory::TestCreate(SkRandom* rand,
                                            GrContext*,
                                            const GrCaps&,
                                            GrTexture*[]) {
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(GrCustomXPFactory, (static_cast<SkXfermode::Mode>(mode)));
 }