Add mixed samples support to XPs

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 506 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 class CustomXP : public GrXferProcessor {
 public:
     CustomXP(SkXfermode::Mode mode, GrBlendEquation hwBlendEquation)
         : fMode(mode),
           fHWBlendEquation(hwBlendEquation) {
         this->initClassID<CustomXP>();
     }
 
-    CustomXP(SkXfermode::Mode mode, const DstTexture* dstTexture)
-        : INHERITED(dstTexture, true),
+    CustomXP(const DstTexture* dstTexture, bool hasMixedSamples, SkXfermode::Mode mode)
+        : INHERITED(dstTexture, true, hasMixedSamples),
           fMode(mode),
           fHWBlendEquation(static_cast<GrBlendEquation>(-1)) {
         this->initClassID<CustomXP>();
     }
 
     const char* name() const override { return "Custom Xfermode"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
     SkXfermode::Mode mode() const { return fMode; }
@@ skipping 60 matching lines @@
     }
 
 private:
     void emitOutputsForBlendState(const EmitArgs& args) override {
         const CustomXP& xp = args.fXP.cast<CustomXP>();
         SkASSERT(xp.hasHWBlendEquation());
 
         GrGLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
         fsBuilder->enableAdvancedBlendEquationIfNeeded(xp.hwBlendEquation());
 
-        // Apply coverage by multiplying it into the src color before blending.
-        // (See onGetOptimizations())
+        // Apply coverage by multiplying it into the src color before blending. Mixed samples will
+        // "just work" automatically. (See onGetOptimizations())
         if (xp.readsCoverage()) {
             fsBuilder->codeAppendf("%s = %s * %s;",
                                    args.fOutputPrimary, args.fInputCoverage, args.fInputColor);
         } else {
             fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputColor);
         }
     }
 
     void emitBlendCodeForDstRead(GrGLXPBuilder* pb, const char* srcColor, const char* dstColor,
                                  const char* outColor, const GrXferProcessor& proc) override {
@@ skipping 158 matching lines @@
     : fMode(mode),
       fHWBlendEquation(hw_blend_equation(mode)) {
     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)) {
         SkASSERT(!dstTexture || !dstTexture->texture());
         return SkNEW_ARGS(CustomXP, (fMode, fHWBlendEquation));
     }
-    return SkNEW_ARGS(CustomXP, (fMode, dstTexture));
+    return SkNEW_ARGS(CustomXP, (dstTexture, hasMixedSamples, fMode));
 }
 
 bool GrCustomXPFactory::willReadDstColor(const GrCaps& caps,
                                          const GrProcOptInfo& colorPOI,
-                                         const GrProcOptInfo& coveragePOI) const {
+                                         const GrProcOptInfo& coveragePOI,
+                                         bool hasMixedSamples) const {
     return !can_use_hw_blend_equation(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)));
 }