diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp
index 041cfd7..9ab3a95 100644
--- a/src/gpu/effects/GrBezierEffect.cpp
+++ b/src/gpu/effects/GrBezierEffect.cpp
@@ -200,11 +200,6 @@
                                                         kVec4f_GrVertexAttribType));
 }
 
-bool GrConicEffect::onIsEqual(const GrGeometryProcessor& other) const {
-    const GrConicEffect& ce = other.cast<GrConicEffect>();
-    return (ce.fEdgeType == fEdgeType);
-}
-
 void GrConicEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     ConicBatchTracker* local = bt->cast<ConicBatchTracker>();
     local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
@@ -212,18 +207,6 @@
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool GrConicEffect::onCanMakeEqual(const GrBatchTracker& m,
-                                   const GrGeometryProcessor& that,
-                                   const GrBatchTracker& t) const {
-    const ConicBatchTracker& mine = m.cast<ConicBatchTracker>();
-    const ConicBatchTracker& theirs = t.cast<ConicBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                   that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor) &&
-           mine.fCoverageScale == theirs.fCoverageScale;
-}
-
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrConicEffect);
@@ -421,11 +404,6 @@
                                                         kVec4f_GrVertexAttribType));
 }
 
-bool GrQuadEffect::onIsEqual(const GrGeometryProcessor& other) const {
-    const GrQuadEffect& ce = other.cast<GrQuadEffect>();
-    return (ce.fEdgeType == fEdgeType);
-}
-
 void GrQuadEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     QuadBatchTracker* local = bt->cast<QuadBatchTracker>();
     local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
@@ -433,18 +411,6 @@
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool GrQuadEffect::onCanMakeEqual(const GrBatchTracker& m,
-                                  const GrGeometryProcessor& that,
-                                  const GrBatchTracker& t) const {
-    const QuadBatchTracker& mine = m.cast<QuadBatchTracker>();
-    const QuadBatchTracker& theirs = t.cast<QuadBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                   that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor) &&
-           mine.fCoverageScale == theirs.fCoverageScale;
-}
-
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrQuadEffect);
@@ -663,28 +629,12 @@
                                                         kVec4f_GrVertexAttribType));
 }
 
-bool GrCubicEffect::onIsEqual(const GrGeometryProcessor& other) const {
-    const GrCubicEffect& ce = other.cast<GrCubicEffect>();
-    return (ce.fEdgeType == fEdgeType);
-}
-
 void GrCubicEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     CubicBatchTracker* local = bt->cast<CubicBatchTracker>();
     local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool GrCubicEffect::onCanMakeEqual(const GrBatchTracker& m,
-                                   const GrGeometryProcessor& that,
-                                   const GrBatchTracker& t) const {
-    const CubicBatchTracker& mine = m.cast<CubicBatchTracker>();
-    const CubicBatchTracker& theirs = t.cast<CubicBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                   that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor);
-}
-
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrCubicEffect);
diff --git a/src/gpu/effects/GrBezierEffect.h b/src/gpu/effects/GrBezierEffect.h
index 07d255c..df582b8 100644
--- a/src/gpu/effects/GrBezierEffect.h
+++ b/src/gpu/effects/GrBezierEffect.h
@@ -106,20 +106,11 @@
                                                      const GrGLSLCaps&) const override;
 
     void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
 
 private:
     GrConicEffect(GrColor, const SkMatrix& viewMatrix, uint8_t coverage, GrPrimitiveEdgeType,
                   const SkMatrix& localMatrix);
 
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
-        out->setUnknownSingleComponent();
-    }
-
     uint8_t               fCoverageScale;
     GrPrimitiveEdgeType   fEdgeType;
     const Attribute*    fInPosition;
@@ -191,20 +182,11 @@
                                                      const GrGLSLCaps&) const override;
 
     void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
 
 private:
     GrQuadEffect(GrColor, const SkMatrix& viewMatrix, uint8_t coverage, GrPrimitiveEdgeType,
                  const SkMatrix& localMatrix);
 
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
-        out->setUnknownSingleComponent();
-    }
-
     uint8_t               fCoverageScale;
     GrPrimitiveEdgeType   fEdgeType;
     const Attribute*    fInPosition;
@@ -272,19 +254,10 @@
                                                      const GrGLSLCaps&) const override;
 
     void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
 
 private:
     GrCubicEffect(GrColor, const SkMatrix& viewMatrix, GrPrimitiveEdgeType);
 
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
-        out->setUnknownSingleComponent();
-    }
-
     GrPrimitiveEdgeType   fEdgeType;
     const Attribute*    fInPosition;
     const Attribute*    fInCubicCoeffs;
diff --git a/src/gpu/effects/GrBitmapTextGeoProc.cpp b/src/gpu/effects/GrBitmapTextGeoProc.cpp
index fab7ec2..ade0904 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.cpp
+++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp
@@ -118,8 +118,8 @@
 
 GrBitmapTextGeoProc::GrBitmapTextGeoProc(GrColor color, GrTexture* texture,
                                          const GrTextureParams& params, GrMaskFormat format,
-                                         bool opaqueVertexColors, const SkMatrix& localMatrix)
-    : INHERITED(color, SkMatrix::I(), localMatrix, opaqueVertexColors)
+                                         const SkMatrix& localMatrix)
+    : INHERITED(color, SkMatrix::I(), localMatrix)
     , fTextureAccess(texture, params)
     , fInColor(NULL)
     , fMaskFormat(format) {
@@ -129,40 +129,12 @@
     bool hasVertexColor = kA8_GrMaskFormat == fMaskFormat;
     if (hasVertexColor) {
         fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
-        this->setHasVertexColor();
     }
     fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords",
                                                         kVec2s_GrVertexAttribType));
     this->addTextureAccess(&fTextureAccess);
 }
 
-bool GrBitmapTextGeoProc::onIsEqual(const GrGeometryProcessor& other) const {
-    const GrBitmapTextGeoProc& gp = other.cast<GrBitmapTextGeoProc>();
-    return SkToBool(this->inColor()) == SkToBool(gp.inColor());
-}
-
-void GrBitmapTextGeoProc::onGetInvariantOutputColor(GrInitInvariantOutput* out) const {
-    if (kARGB_GrMaskFormat == fMaskFormat) {
-        out->setUnknownFourComponents();
-    }
-}
-
-void GrBitmapTextGeoProc::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const {
-    if (kARGB_GrMaskFormat != fMaskFormat) {
-        if (GrPixelConfigIsAlphaOnly(this->texture(0)->config())) {
-            out->setUnknownSingleComponent();
-        } else if (GrPixelConfigIsOpaque(this->texture(0)->config())) {
-            out->setUnknownOpaqueFourComponents();
-            out->setUsingLCDCoverage();
-        } else {
-            out->setUnknownFourComponents();
-            out->setUsingLCDCoverage();
-        }
-    } else {
-        out->setKnownSingleComponent(0xff);
-    }
-}
-
 void GrBitmapTextGeoProc::getGLProcessorKey(const GrBatchTracker& bt,
                                             const GrGLSLCaps& caps,
                                             GrProcessorKeyBuilder* b) const {
@@ -182,17 +154,6 @@
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool GrBitmapTextGeoProc::onCanMakeEqual(const GrBatchTracker& m,
-                                         const GrGeometryProcessor& that,
-                                         const GrBatchTracker& t) const {
-    const BitmapTextBatchTracker& mine = m.cast<BitmapTextBatchTracker>();
-    const BitmapTextBatchTracker& theirs = t.cast<BitmapTextBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                   that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrBitmapTextGeoProc);
@@ -231,6 +192,5 @@
     }
 
     return GrBitmapTextGeoProc::Create(GrRandomColor(random), textures[texIdx], params,
-                                       format, random->nextBool(),
-                                       GrTest::TestMatrix(random));
+                                       format, GrTest::TestMatrix(random));
 }
diff --git a/src/gpu/effects/GrBitmapTextGeoProc.h b/src/gpu/effects/GrBitmapTextGeoProc.h
index 136fd32..d2d0422 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.h
+++ b/src/gpu/effects/GrBitmapTextGeoProc.h
@@ -22,10 +22,9 @@
 class GrBitmapTextGeoProc : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(GrColor color, GrTexture* tex, const GrTextureParams& p,
-                                       GrMaskFormat format, bool opaqueVertexColors,
+                                       GrMaskFormat format,
                                        const SkMatrix& localMatrix) {
-        return SkNEW_ARGS(GrBitmapTextGeoProc, (color, tex, p, format, opaqueVertexColors,
-                                                localMatrix));
+        return SkNEW_ARGS(GrBitmapTextGeoProc, (color, tex, p, format, localMatrix));
     }
 
     virtual ~GrBitmapTextGeoProc() {}
@@ -45,19 +44,10 @@
                                                      const GrGLSLCaps& caps) const override;
 
     void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
 
 private:
     GrBitmapTextGeoProc(GrColor, GrTexture* texture, const GrTextureParams& params,
-                        GrMaskFormat format, bool opaqueVertexColors, const SkMatrix& localMatrix);
-
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputColor(GrInitInvariantOutput*) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
+                        GrMaskFormat format, const SkMatrix& localMatrix);
 
     GrTextureAccess  fTextureAccess;
     const Attribute* fInPosition;
diff --git a/src/gpu/effects/GrDashingEffect.cpp b/src/gpu/effects/GrDashingEffect.cpp
index 1ca5648..d3df886 100644
--- a/src/gpu/effects/GrDashingEffect.cpp
+++ b/src/gpu/effects/GrDashingEffect.cpp
@@ -773,8 +773,6 @@
                                        DashAAMode aaMode,
                                        const SkMatrix& localMatrix);
 
-    virtual ~DashingCircleEffect();
-
     const char* name() const override { return "DashingCircleEffect"; }
 
     const Attribute* inPosition() const { return fInPosition; }
@@ -794,17 +792,9 @@
 
     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
 
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
-
 private:
     DashingCircleEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix);
 
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
-
     DashAAMode          fAAMode;
     const Attribute*    fInPosition;
     const Attribute*    fInDashParams;
@@ -933,12 +923,6 @@
     return SkNEW_ARGS(DashingCircleEffect, (color, aaMode, localMatrix));
 }
 
-DashingCircleEffect::~DashingCircleEffect() {}
-
-void DashingCircleEffect::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const {
-    out->setUnknownSingleComponent();
-}
-
 void DashingCircleEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                             const GrGLSLCaps& caps,
                                             GrProcessorKeyBuilder* b) const {
@@ -961,28 +945,12 @@
                                                        kVec2f_GrVertexAttribType));
 }
 
-bool DashingCircleEffect::onIsEqual(const GrGeometryProcessor& other) const {
-    const DashingCircleEffect& dce = other.cast<DashingCircleEffect>();
-    return fAAMode == dce.fAAMode;
-}
-
 void DashingCircleEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     DashingCircleBatchTracker* local = bt->cast<DashingCircleBatchTracker>();
     local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool DashingCircleEffect::onCanMakeEqual(const GrBatchTracker& m,
-                                         const GrGeometryProcessor& that,
-                                         const GrBatchTracker& t) const {
-    const DashingCircleBatchTracker& mine = m.cast<DashingCircleBatchTracker>();
-    const DashingCircleBatchTracker& theirs = t.cast<DashingCircleBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                   that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor);
-}
-
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect);
 
 GrGeometryProcessor* DashingCircleEffect::TestCreate(SkRandom* random,
@@ -1021,8 +989,6 @@
                                        DashAAMode aaMode,
                                        const SkMatrix& localMatrix);
 
-    virtual ~DashingLineEffect();
-
     const char* name() const override { return "DashingEffect"; }
 
     const Attribute* inPosition() const { return fInPosition; }
@@ -1042,17 +1008,9 @@
 
     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
 
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
-
 private:
     DashingLineEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix);
 
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
-
     DashAAMode          fAAMode;
     const Attribute*    fInPosition;
     const Attribute*    fInDashParams;
@@ -1193,12 +1151,6 @@
     return SkNEW_ARGS(DashingLineEffect, (color, aaMode, localMatrix));
 }
 
-DashingLineEffect::~DashingLineEffect() {}
-
-void DashingLineEffect::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const {
-    out->setUnknownSingleComponent();
-}
-
 void DashingLineEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                           const GrGLSLCaps& caps,
                                           GrProcessorKeyBuilder* b) const {
@@ -1220,28 +1172,12 @@
     fInRectParams = &this->addVertexAttrib(Attribute("inRect", kVec4f_GrVertexAttribType));
 }
 
-bool DashingLineEffect::onIsEqual(const GrGeometryProcessor& other) const {
-    const DashingLineEffect& de = other.cast<DashingLineEffect>();
-    return fAAMode == de.fAAMode;
-}
-
 void DashingLineEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     DashingLineBatchTracker* local = bt->cast<DashingLineBatchTracker>();
     local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool DashingLineEffect::onCanMakeEqual(const GrBatchTracker& m,
-                                       const GrGeometryProcessor& that,
-                                       const GrBatchTracker& t) const {
-    const DashingLineBatchTracker& mine = m.cast<DashingLineBatchTracker>();
-    const DashingLineBatchTracker& theirs = t.cast<DashingLineBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                  that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor);
-}
-
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect);
 
 GrGeometryProcessor* DashingLineEffect::TestCreate(SkRandom* random,
diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.cpp b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
index 64811a5..bd48e51 100755
--- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
@@ -196,8 +196,8 @@
 #ifdef SK_GAMMA_APPLY_TO_A8
                                                            float distanceAdjust,
 #endif
-                                                           uint32_t flags, bool opaqueVertexColors)
-    : INHERITED(color, viewMatrix, SkMatrix::I(), opaqueVertexColors)
+                                                           uint32_t flags)
+    : INHERITED(color, viewMatrix, SkMatrix::I())
     , fTextureAccess(texture, params)
 #ifdef SK_GAMMA_APPLY_TO_A8
     , fDistanceAdjust(distanceAdjust)
@@ -209,26 +209,12 @@
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     if (flags & kColorAttr_DistanceFieldEffectFlag) {
         fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
-        this->setHasVertexColor();
     }
     fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords",
                                                           kVec2s_GrVertexAttribType));
     this->addTextureAccess(&fTextureAccess);
 }
 
-bool GrDistanceFieldA8TextGeoProc::onIsEqual(const GrGeometryProcessor& other) const {
-    const GrDistanceFieldA8TextGeoProc& cte = other.cast<GrDistanceFieldA8TextGeoProc>();
-    return
-#ifdef SK_GAMMA_APPLY_TO_A8
-           fDistanceAdjust == cte.fDistanceAdjust &&
-#endif
-           fFlags == cte.fFlags;
-}
-
-void GrDistanceFieldA8TextGeoProc::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const {
-    out->setUnknownSingleComponent();
-}
-
 void GrDistanceFieldA8TextGeoProc::getGLProcessorKey(const GrBatchTracker& bt,
                                                      const GrGLSLCaps& caps,
                                                      GrProcessorKeyBuilder* b) const {
@@ -249,17 +235,6 @@
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool GrDistanceFieldA8TextGeoProc::onCanMakeEqual(const GrBatchTracker& m,
-                                                  const GrGeometryProcessor& that,
-                                                  const GrBatchTracker& t) const {
-    const DistanceFieldBatchTracker& mine = m.cast<DistanceFieldBatchTracker>();
-    const DistanceFieldBatchTracker& theirs = t.cast<DistanceFieldBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                   that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldA8TextGeoProc);
@@ -289,8 +264,7 @@
                                                 random->nextF(),
 #endif
                                                 random->nextBool() ?
-                                                    kSimilarity_DistanceFieldEffectFlag : 0,
-                                                random->nextBool());
+                                                    kSimilarity_DistanceFieldEffectFlag : 0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -448,9 +422,8 @@
         const SkMatrix& viewMatrix,
         GrTexture* texture,
         const GrTextureParams& params,
-        uint32_t flags,
-        bool opaqueVertexColors)
-    : INHERITED(color, viewMatrix, SkMatrix::I(), opaqueVertexColors)
+        uint32_t flags)
+    : INHERITED(color, viewMatrix, SkMatrix::I())
     , fTextureAccess(texture, params)
     , fFlags(flags & kNonLCD_DistanceFieldEffectMask)
     , fInColor(NULL) {
@@ -459,22 +432,12 @@
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     if (flags & kColorAttr_DistanceFieldEffectFlag) {
         fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
-        this->setHasVertexColor();
     }
     fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords",
                                                           kVec2f_GrVertexAttribType));
     this->addTextureAccess(&fTextureAccess);
 }
 
-bool GrDistanceFieldPathGeoProc::onIsEqual(const GrGeometryProcessor& other) const {
-    const GrDistanceFieldPathGeoProc& cte = other.cast<GrDistanceFieldPathGeoProc>();
-    return fFlags == cte.fFlags;
-}
-
-void GrDistanceFieldPathGeoProc::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const {
-    out->setUnknownSingleComponent();
-}
-
 void GrDistanceFieldPathGeoProc::getGLProcessorKey(const GrBatchTracker& bt,
                                                    const GrGLSLCaps& caps,
                                                    GrProcessorKeyBuilder* b) const {
@@ -494,17 +457,6 @@
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool GrDistanceFieldPathGeoProc::onCanMakeEqual(const GrBatchTracker& m,
-                                                const GrGeometryProcessor& that,
-                                                const GrBatchTracker& t) const {
-    const DistanceFieldPathBatchTracker& mine = m.cast<DistanceFieldPathBatchTracker>();
-    const DistanceFieldPathBatchTracker& theirs = t.cast<DistanceFieldPathBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                   that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldPathGeoProc);
@@ -531,7 +483,7 @@
                                               GrTest::TestMatrix(random),
                                               textures[texIdx],
                                               params,
-        random->nextBool() ? kSimilarity_DistanceFieldEffectFlag : 0, random->nextBool());
+        random->nextBool() ? kSimilarity_DistanceFieldEffectFlag : 0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -751,17 +703,6 @@
     this->addTextureAccess(&fTextureAccess);
 }
 
-bool GrDistanceFieldLCDTextGeoProc::onIsEqual(const GrGeometryProcessor& other) const {
-    const GrDistanceFieldLCDTextGeoProc& cte = other.cast<GrDistanceFieldLCDTextGeoProc>();
-    return (fDistanceAdjust == cte.fDistanceAdjust &&
-            fFlags == cte.fFlags);
-}
-
-void GrDistanceFieldLCDTextGeoProc::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const {
-    out->setUnknownFourComponents();
-    out->setUsingLCDCoverage();
-}
-
 void GrDistanceFieldLCDTextGeoProc::getGLProcessorKey(const GrBatchTracker& bt,
                                                       const GrGLSLCaps& caps,
                                                       GrProcessorKeyBuilder* b) const {
@@ -781,17 +722,6 @@
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
-bool GrDistanceFieldLCDTextGeoProc::onCanMakeEqual(const GrBatchTracker& m,
-                                                   const GrGeometryProcessor& that,
-                                                   const GrBatchTracker& t) const {
-    const DistanceFieldLCDBatchTracker& mine = m.cast<DistanceFieldLCDBatchTracker>();
-    const DistanceFieldLCDBatchTracker& theirs = t.cast<DistanceFieldLCDBatchTracker>();
-    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
-                                   that, theirs.fUsesLocalCoords) &&
-           CanCombineOutput(mine.fInputColorType, mine.fColor,
-                            theirs.fInputColorType, theirs.fColor);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldLCDTextGeoProc);
diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.h b/src/gpu/effects/GrDistanceFieldGeoProc.h
index 362278f..44f0283 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.h
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.h
@@ -49,16 +49,15 @@
 #ifdef SK_GAMMA_APPLY_TO_A8
     static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix,
                                        GrTexture* tex, const GrTextureParams& params,
-                                       float lum, uint32_t flags, bool opaqueVertexColors) {
-        return SkNEW_ARGS(GrDistanceFieldA8TextGeoProc, (color, viewMatrix, tex,
-                                                         params, lum, flags, opaqueVertexColors));
+                                       float lum, uint32_t flags) {
+        return SkNEW_ARGS(GrDistanceFieldA8TextGeoProc, (color, viewMatrix, tex, params, lum,
+                                                         flags));
     }
 #else
     static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix,
                                        GrTexture* tex, const GrTextureParams& params,
-                                       uint32_t flags, bool opaqueVertexColors) {
-        return SkNEW_ARGS(GrDistanceFieldA8TextGeoProc, (color, viewMatrix, tex,
-                                                         params, flags, opaqueVertexColors));
+                                       uint32_t flags) {
+        return SkNEW_ARGS(GrDistanceFieldA8TextGeoProc, (color, viewMatrix, tex,  params, flags));
     }
 #endif
 
@@ -83,21 +82,13 @@
 
     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
 
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
-
 private:
     GrDistanceFieldA8TextGeoProc(GrColor, const SkMatrix& viewMatrix,
                                  GrTexture* texture, const GrTextureParams& params,
 #ifdef SK_GAMMA_APPLY_TO_A8
                                  float distanceAdjust,
 #endif
-                                 uint32_t flags, bool opaqueVertexColors);
-
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
+                                 uint32_t flags);
 
     GrTextureAccess  fTextureAccess;
 #ifdef SK_GAMMA_APPLY_TO_A8
@@ -124,9 +115,8 @@
 public:
     static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, GrTexture* tex,
                                        const GrTextureParams& params,
-                                       uint32_t flags, bool opaqueVertexColors) {
-        return SkNEW_ARGS(GrDistanceFieldPathGeoProc, (color, viewMatrix, tex, params,
-                                                       flags, opaqueVertexColors));
+                                       uint32_t flags) {
+        return SkNEW_ARGS(GrDistanceFieldPathGeoProc, (color, viewMatrix, tex, params, flags));
     }
 
     virtual ~GrDistanceFieldPathGeoProc() {}
@@ -147,18 +137,9 @@
 
     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
 
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
-
 private:
     GrDistanceFieldPathGeoProc(GrColor, const SkMatrix& viewMatrix, GrTexture* texture,
-                               const GrTextureParams& params, uint32_t flags,
-                               bool opaqueVertexColors);
-
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
+                               const GrTextureParams& params, uint32_t flags);
 
     GrTextureAccess    fTextureAccess;
     uint32_t           fFlags;
@@ -219,19 +200,11 @@
 
     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
 
-    bool onCanMakeEqual(const GrBatchTracker&,
-                        const GrGeometryProcessor&,
-                        const GrBatchTracker&) const override;
-
 private:
     GrDistanceFieldLCDTextGeoProc(GrColor, const SkMatrix& viewMatrix,
                                   GrTexture* texture, const GrTextureParams& params,
                                   DistanceAdjust wa, uint32_t flags);
 
-    bool onIsEqual(const GrGeometryProcessor& other) const override;
-
-    void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
-
     GrTextureAccess  fTextureAccess;
     DistanceAdjust   fDistanceAdjust;
     uint32_t         fFlags;