diff --git a/gyp/gpu.gypi b/gyp/gpu.gypi
index 5374976..c28045d 100644
--- a/gyp/gpu.gypi
+++ b/gyp/gpu.gypi
@@ -131,6 +131,8 @@
       '<(skia_src_path)/gpu/effects/GrConfigConversionEffect.h',
       '<(skia_src_path)/gpu/effects/GrConvolutionEffect.cpp',
       '<(skia_src_path)/gpu/effects/GrConvolutionEffect.h',
+      '<(skia_src_path)/gpu/effects/GrEdgeEffect.cpp',
+      '<(skia_src_path)/gpu/effects/GrEdgeEffect.h',
       '<(skia_src_path)/gpu/effects/GrEllipseEdgeEffect.cpp',
       '<(skia_src_path)/gpu/effects/GrEllipseEdgeEffect.h',
       '<(skia_src_path)/gpu/effects/GrSimpleTextureEffect.cpp',
diff --git a/src/gpu/GrAAConvexPathRenderer.cpp b/src/gpu/GrAAConvexPathRenderer.cpp
index cff6324..9f24190 100644
--- a/src/gpu/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/GrAAConvexPathRenderer.cpp
@@ -16,6 +16,8 @@
 #include "SkStrokeRec.h"
 #include "SkTrace.h"
 
+#include "effects/GrEdgeEffect.h"
+
 GrAAConvexPathRenderer::GrAAConvexPathRenderer() {
 }
 
@@ -446,6 +448,8 @@
     if (path->isEmpty()) {
         return true;
     }
+
+    GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
     GrDrawState* drawState = target->drawState();
 
     GrDrawState::AutoDeviceCoordDraw adcd(drawState);
@@ -484,12 +488,21 @@
         {kVec2f_GrVertexAttribType, 0},
         {kVec4f_GrVertexAttribType, sizeof(GrPoint)}
     };
-    static const GrAttribBindings bindings = GrDrawState::kEdge_AttribBindingsBit;
 
     drawState->setVertexAttribs(kAttribs, SK_ARRAY_COUNT(kAttribs));
     drawState->setAttribIndex(GrDrawState::kPosition_AttribIndex, 0);
-    drawState->setAttribIndex(GrDrawState::kEdge_AttribIndex, 1);
-    drawState->setAttribBindings(bindings);
+    drawState->setAttribBindings(GrDrawState::kDefault_AttribBindings);
+
+    enum {
+        // the edge effects share this stage with glyph rendering
+        // (kGlyphMaskStage in GrTextContext) && SW path rendering
+        // (kPathMaskStage in GrSWMaskHelper)
+        kEdgeEffectStage = GrPaint::kTotalStages,
+    };
+    static const int kEdgeAttrIndex = 1;
+    GrEffectRef* quadEffect = GrEdgeEffect::Create(GrEdgeEffect::kQuad_EdgeType);
+    drawState->setEffect(kEdgeEffectStage, quadEffect, kEdgeAttrIndex)->unref();
+
     GrDrawTarget::AutoReleaseGeometry arg(target, vCount, iCount);
     if (!arg.succeeded()) {
         return false;
@@ -500,14 +513,11 @@
 
     create_vertices(segments, fanPt, verts, idxs);
 
-    GrDrawState::VertexEdgeType oldEdgeType = drawState->getVertexEdgeType();
-    drawState->setVertexEdgeType(GrDrawState::kQuad_EdgeType);
     target->drawIndexed(kTriangles_GrPrimitiveType,
                         0,        // start vertex
                         0,        // start index
                         vCount,
                         iCount);
-    drawState->setVertexEdgeType(oldEdgeType);
 
     return true;
 }
diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp
index 80304f8..079c826 100644
--- a/src/gpu/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/GrAAHairLinePathRenderer.cpp
@@ -18,6 +18,8 @@
 #include "SkStroke.h"
 #include "SkTemplates.h"
 
+#include "effects/GrEdgeEffect.h"
+
 namespace {
 // quadratics are rendered as 5-sided polys in order to bound the
 // AA stroke around the center-curve. See comments in push_quad_index_buffer and
@@ -508,7 +510,6 @@
         {kVec2f_GrVertexAttribType, 0},
         {kVec4f_GrVertexAttribType, sizeof(GrPoint)}
     };
-    static const GrAttribBindings kBindings = GrDrawState::kEdge_AttribBindingsBit;
     SkMatrix viewM = drawState->getViewMatrix();
 
     PREALLOC_PTARRAY(128) lines;
@@ -522,8 +523,7 @@
 
     target->drawState()->setVertexAttribs(kAttribs, SK_ARRAY_COUNT(kAttribs));
     target->drawState()->setAttribIndex(GrDrawState::kPosition_AttribIndex, 0);
-    target->drawState()->setAttribIndex(GrDrawState::kEdge_AttribIndex, 1);
-    target->drawState()->setAttribBindings(kBindings);
+    target->drawState()->setAttribBindings(GrDrawState::kDefault_AttribBindings);
     GrAssert(sizeof(Vertex) == target->getDrawState().getVertexSize());
 
     if (!arg->set(target, vertCnt, 0)) {
@@ -589,8 +589,10 @@
         return false;
     }
 
-    GrDrawState::AutoDeviceCoordDraw adcd;
+    GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
     GrDrawState* drawState = target->drawState();
+
+    GrDrawState::AutoDeviceCoordDraw adcd;
     // createGeom transforms the geometry to device space when the matrix does not have
     // perspective.
     if (!drawState->getViewMatrix().hasPerspective()) {
@@ -603,12 +605,21 @@
     // TODO: See whether rendering lines as degenerate quads improves perf
     // when we have a mix
 
-    GrDrawState::VertexEdgeType oldEdgeType = drawState->getVertexEdgeType();
+    enum {
+        // the edge effects share this stage with glyph rendering
+        // (kGlyphMaskStage in GrTextContext) && SW path rendering
+        // (kPathMaskStage in GrSWMaskHelper)
+        kEdgeEffectStage = GrPaint::kTotalStages,
+    };
+    static const int kEdgeAttrIndex = 1;
 
+    GrEffectRef* hairLineEffect = GrEdgeEffect::Create(GrEdgeEffect::kHairLine_EdgeType);
+    GrEffectRef* hairQuadEffect = GrEdgeEffect::Create(GrEdgeEffect::kHairQuad_EdgeType);
+ 
     target->setIndexSourceToBuffer(fLinesIndexBuffer);
     int lines = 0;
     int nBufLines = fLinesIndexBuffer->maxQuads();
-    drawState->setVertexEdgeType(GrDrawState::kHairLine_EdgeType);
+    drawState->setEffect(kEdgeEffectStage, hairLineEffect, kEdgeAttrIndex)->unref();
     while (lines < lineCnt) {
         int n = GrMin(lineCnt - lines, nBufLines);
         target->drawIndexed(kTriangles_GrPrimitiveType,
@@ -621,7 +632,7 @@
 
     target->setIndexSourceToBuffer(fQuadsIndexBuffer);
     int quads = 0;
-    drawState->setVertexEdgeType(GrDrawState::kHairQuad_EdgeType);
+    drawState->setEffect(kEdgeEffectStage, hairQuadEffect, kEdgeAttrIndex)->unref();
     while (quads < quadCnt) {
         int n = GrMin(quadCnt - quads, kNumQuadsInIdxBuffer);
         target->drawIndexed(kTriangles_GrPrimitiveType,
@@ -631,6 +642,6 @@
                             kIdxsPerQuad*n);                   // iCount
         quads += n;
     }
-    drawState->setVertexEdgeType(oldEdgeType);
+
     return true;
 }
diff --git a/src/gpu/GrDrawState.cpp b/src/gpu/GrDrawState.cpp
index 7982935..e108999 100644
--- a/src/gpu/GrDrawState.cpp
+++ b/src/gpu/GrDrawState.cpp
@@ -59,7 +59,7 @@
 #if GR_DEBUG
     uint32_t overlapCheck = 0;
 #endif
-    GrAssert(count <= GrDrawState::kAttribIndexCount);
+    GrAssert(count <= GrDrawState::kVertexAttribCnt);
     size_t size = 0;
     for (int index = 0; index < count; ++index) {
         size_t attribSize = GrDrawState::kVertexAttribSizes[attribs[index].fType];
@@ -83,14 +83,13 @@
     0,                            // position is not reflected in the bindings
     kColor_AttribBindingsBit,
     kCoverage_AttribBindingsBit,
-    kEdge_AttribBindingsBit,
     kLocalCoords_AttribBindingsBit,
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::setVertexAttribs(const GrVertexAttrib* attribs, int count) {
-    GrAssert(count <= GrDrawState::kAttribIndexCount);
+    GrAssert(count <= GrDrawState::kVertexAttribCnt);
     fVertexAttribs.reset();
     for (int index = 0; index < count; ++index) {
         fVertexAttribs.push_back(attribs[index]);
@@ -140,18 +139,16 @@
             attributeTypes[attributeIndex] = kBuiltInAttributeType;
         }
     }
-    for (int j = kEdge_AttribIndex; j < kAttribIndexCount; ++j) {
-        if (fCommon.fAttribBindings & kAttribIndexMasks[j]) {
-            int attributeIndex = fAttribIndices[j];
-            if (attributeIndex >= kVertexAttribCnt) {
-                return false;
-            }
-            // they should not be shared at all
-            if (attributeTypes[attributeIndex] != -1) {
-                return false;
-            }
-            attributeTypes[attributeIndex] = kBuiltInAttributeType;
+    if (fCommon.fAttribBindings & kAttribIndexMasks[kLocalCoords_AttribIndex]) {
+        int attributeIndex = fAttribIndices[kLocalCoords_AttribIndex];
+        if (attributeIndex >= kVertexAttribCnt) {
+            return false;
         }
+        // they should not be shared at all
+        if (attributeTypes[attributeIndex] != -1) {
+            return false;
+        }
+        attributeTypes[attributeIndex] = kBuiltInAttributeType;
     }
 
     // now those set by effects
@@ -371,12 +368,10 @@
         }
     }
 
-    // check for coverage due to constant coverage, per-vertex coverage,
-    // edge aa or coverage stage
+    // check for coverage due to constant coverage, per-vertex coverage, or coverage stage
     bool hasCoverage = forceCoverage ||
                        0xffffffff != this->getCoverage() ||
-                       (bindings & GrDrawState::kCoverage_AttribBindingsBit) ||
-                       (bindings & GrDrawState::kEdge_AttribBindingsBit);
+                       (bindings & GrDrawState::kCoverage_AttribBindingsBit);
     for (int s = this->getFirstCoverageStage();
          !hasCoverage && s < GrDrawState::kNumStages;
          ++s) {
diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h
index ffa7b09..fed89db 100644
--- a/src/gpu/GrDrawState.h
+++ b/src/gpu/GrDrawState.h
@@ -76,9 +76,7 @@
      *
      * The input color to the first enabled color-stage is either the constant color or interpolated
      * per-vertex colors, depending upon GrAttribBindings. The input to the first coverage stage is
-     * either a constant coverage (usually full-coverage), interpolated per-vertex coverage, or
-     * edge-AA computed coverage. (This latter is going away as soon as it can be rewritten as a
-     * GrEffect).
+     * either a constant coverage (usually full-coverage) or interpolated per-vertex coverage.
      *
      * See the documentation of kCoverageDrawing_StateBit for information about disabling the
      * the color / coverage distinction.
@@ -125,7 +123,6 @@
         fCommon.fDstBlend = kZero_GrBlendCoeff;
         fCommon.fBlendConstant = 0x0;
         fCommon.fFlagBits = 0x0;
-        fCommon.fVertexEdgeType = kHairLine_EdgeType;
         fCommon.fStencilSettings.setDisabled();
         fCommon.fFirstCoverageStage = kNumStages;
         fCommon.fCoverage = 0xffffffff;
@@ -273,10 +270,6 @@
         /* program uses coverage (GrColor)
          */
         kCoverage_AttribBindingsBit           = 0x4,
-        /* program uses edge data. Distance to the edge is used to
-         * compute a coverage. See GrDrawState::setVertexEdgeType().
-         */
-        kEdge_AttribBindingsBit               = 0x8,
         // for below assert
         kDummyAttribBindingsBit,
         kHighAttribBindingsBit = kDummyAttribBindingsBit - 1
@@ -332,7 +325,6 @@
         kPosition_AttribIndex = 0,
         kColor_AttribIndex,
         kCoverage_AttribIndex,
-        kEdge_AttribIndex,
         kLocalCoords_AttribIndex,
 
         kLast_AttribIndex = kLocalCoords_AttribIndex
@@ -947,52 +939,6 @@
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
-    // @name Edge AA
-    // Edge equations can be specified to perform anti-aliasing. Because the
-    // edges are specified as per-vertex data, vertices that are shared by
-    // multiple edges must be split.
-    //
-    ////
-
-    /**
-     * When specifying edges as vertex data this enum specifies what type of
-     * edges are in use. The edges are always 4 SkScalars in memory, even when
-     * the edge type requires fewer than 4.
-     *
-     * TODO: Fix the fact that HairLine and Circle edge types use y-down coords.
-     *       (either adjust in VS or use origin_upper_left in GLSL)
-     */
-    enum VertexEdgeType {
-        /* 1-pixel wide line
-           2D implicit line eq (a*x + b*y +c = 0). 4th component unused */
-        kHairLine_EdgeType,
-        /* Quadratic specified by u^2-v canonical coords (only 2
-           components used). Coverage based on signed distance with negative
-           being inside, positive outside. Edge specified in window space
-           (y-down) */
-        kQuad_EdgeType,
-        /* Same as above but for hairline quadratics. Uses unsigned distance.
-           Coverage is min(0, 1-distance). */
-        kHairQuad_EdgeType,
-
-        kVertexEdgeTypeCnt
-    };
-
-    /**
-     * Determines the interpretation per-vertex edge data when the
-     * kEdge_AttribBindingsBit is set (see GrDrawTarget). When per-vertex edges
-     * are not specified the value of this setting has no effect.
-     */
-    void setVertexEdgeType(VertexEdgeType type) {
-        GrAssert(type >=0 && type < kVertexEdgeTypeCnt);
-        fCommon.fVertexEdgeType = type;
-    }
-
-    VertexEdgeType getVertexEdgeType() const { return fCommon.fVertexEdgeType; }
-
-    /// @}
-
-    ///////////////////////////////////////////////////////////////////////////
     /// @name State Flags
     ////
 
@@ -1188,7 +1134,6 @@
         GrBlendCoeff                    fDstBlend;
         GrColor                         fBlendConstant;
         uint32_t                        fFlagBits;
-        VertexEdgeType                  fVertexEdgeType;
         GrStencilSettings               fStencilSettings;
         int                             fFirstCoverageStage;
         GrColor                         fCoverage;
@@ -1203,7 +1148,6 @@
                    fDstBlend == other.fDstBlend &&
                    fBlendConstant == other.fBlendConstant &&
                    fFlagBits == other.fFlagBits &&
-                   fVertexEdgeType == other.fVertexEdgeType &&
                    fStencilSettings == other.fStencilSettings &&
                    fFirstCoverageStage == other.fFirstCoverageStage &&
                    fCoverage == other.fCoverage &&
diff --git a/src/gpu/effects/GrEdgeEffect.cpp b/src/gpu/effects/GrEdgeEffect.cpp
new file mode 100644
index 0000000..f02fa35
--- /dev/null
+++ b/src/gpu/effects/GrEdgeEffect.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrEdgeEffect.h"
+#include "gl/GrGLEffect.h"
+#include "gl/GrGLSL.h"
+#include "GrTBackendEffectFactory.h"
+
+class GrGLEdgeEffect : public GrGLEffect {
+public:
+    GrGLEdgeEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
+    : INHERITED (factory) {}
+
+    virtual void emitCode(GrGLShaderBuilder* builder,
+                          const GrDrawEffect& drawEffect,
+                          EffectKey key,
+                          const char* outputColor,
+                          const char* inputColor,
+                          const TextureSamplerArray& samplers) SK_OVERRIDE {
+        const GrEdgeEffect& edgeEffect = drawEffect.castEffect<GrEdgeEffect>();
+        GrEdgeEffect::EdgeType type = edgeEffect.edgeType();
+
+        const char *vsName, *fsName;
+        const SkString* attrName =
+            builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
+        builder->fsCodeAppendf("\t\tfloat edgeAlpha;\n");
+
+        switch (type) {
+        case GrEdgeEffect::kHairLine_EdgeType:
+            builder->addVarying(kVec4f_GrSLType, "HairEdge", &vsName, &fsName);
+
+            builder->fsCodeAppendf("\t\tedgeAlpha = abs(dot(vec3(%s.xy,1), %s.xyz));\n",
+                                   builder->fragmentPosition(), fsName);
+            builder->fsCodeAppendf("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
+            break;
+        case GrEdgeEffect::kQuad_EdgeType:
+            GrAssert(builder->ctxInfo().caps()->shaderDerivativeSupport());
+            builder->addVarying(kVec4f_GrSLType, "QuadEdge", &vsName, &fsName);
+
+            // keep the derivative instructions outside the conditional
+            builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
+            builder->fsCodeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
+            builder->fsCodeAppendf("\t\tif (%s.z > 0.0 && %s.w > 0.0) {\n", fsName, fsName);
+            // today we know z and w are in device space. We could use derivatives
+            builder->fsCodeAppendf("\t\t\tedgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);\n", fsName,
+                                   fsName);
+            builder->fsCodeAppendf ("\t\t} else {\n");
+            builder->fsCodeAppendf("\t\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
+                                   "\t\t\t               2.0*%s.x*duvdy.x - duvdy.y);\n",
+                                    fsName, fsName);
+            builder->fsCodeAppendf("\t\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, 
+                                   fsName);
+            builder->fsCodeAppendf("\t\t\tedgeAlpha = "
+                                   "clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);\n\t\t}\n");
+            if (kES2_GrGLBinding == builder->ctxInfo().binding()) {
+                builder->fHeader.append("#extension GL_OES_standard_derivatives: enable\n");
+            }
+            break;
+        case GrEdgeEffect::kHairQuad_EdgeType:
+            GrAssert(builder->ctxInfo().caps()->shaderDerivativeSupport());
+            builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName);
+
+            builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
+            builder->fsCodeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
+            builder->fsCodeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
+                                   "\t\t               2.0*%s.x*duvdy.x - duvdy.y);\n",
+                                   fsName, fsName);
+            builder->fsCodeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName,
+                                   fsName);
+            builder->fsCodeAppend("\t\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / dot(gF, gF));\n");
+            builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
+            if (kES2_GrGLBinding == builder->ctxInfo().binding()) {
+                builder->fHeader.append("#extension GL_OES_standard_derivatives: enable\n");
+            }
+            break;
+        };
+
+        SkString modulate;
+        GrGLSLModulate4f(&modulate, inputColor, "edgeAlpha");
+        builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
+
+        builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str());
+    }
+
+    static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
+        const GrEdgeEffect& QuadEffect = drawEffect.castEffect<GrEdgeEffect>();
+
+        return QuadEffect.edgeType();
+    }
+
+    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {
+    }
+
+private:
+    typedef GrGLEffect INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrEdgeEffect::GrEdgeEffect(EdgeType edgeType) : GrEffect() {
+    if (edgeType == kQuad_EdgeType) {
+        this->addVertexAttrib(kVec4f_GrSLType);
+    } else {
+        this->addVertexAttrib(kVec4f_GrSLType);  // TODO: use different vec sizes for differnt edge
+                                                 // types.
+    }
+    fEdgeType = edgeType;
+}
+
+void GrEdgeEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
+    *validFlags = 0;
+}
+
+const GrBackendEffectFactory& GrEdgeEffect::getFactory() const {
+    return GrTBackendEffectFactory<GrEdgeEffect>::getInstance();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GR_DEFINE_EFFECT_TEST(GrEdgeEffect);
+
+GrEffectRef* GrEdgeEffect::TestCreate(SkMWCRandom* random,
+                                      GrContext*,
+                                      const GrDrawTargetCaps& caps,
+                                      GrTexture*[]) {
+    // Only kHairLine works without derivative instructions.
+    EdgeType edgeType;
+    if (caps.shaderDerivativeSupport()) {
+        edgeType = static_cast<EdgeType>(random->nextULessThan(kEdgeTypeCount));
+    } else {
+        edgeType = kHairLine_EdgeType;
+    }
+    return GrEdgeEffect::Create(edgeType);
+}
diff --git a/src/gpu/effects/GrEdgeEffect.h b/src/gpu/effects/GrEdgeEffect.h
new file mode 100644
index 0000000..c6238a2
--- /dev/null
+++ b/src/gpu/effects/GrEdgeEffect.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrEdgeEffect_DEFINED
+#define GrEdgeEffect_DEFINED
+
+#include "GrEffect.h"
+
+class GrGLEdgeEffect;
+
+/**
+ * The output of this effect is one of three different edge types: hairlines, quads, 
+ * and hairline quads.
+ */
+
+class GrEdgeEffect : public GrEffect {
+public:
+    enum EdgeType {
+        /* 1-pixel wide line
+           2D implicit device coord line eq (a*x + b*y +c = 0). 4th component unused. */
+        kHairLine_EdgeType = 0,
+        /* Quadratic specified by 0=u^2-v canonical coords. u and v are the first
+           two components of the vertex attribute. Coverage is based on signed
+           distance with negative being inside, positive outside. The edge is specified in
+           window space (y-down). If either the third or fourth component of the interpolated
+           vertex coord is > 0 then the pixel is considered outside the edge. This is used to
+           attempt to trim to a portion of the infinite quad. Requires shader derivative
+           instruction support. */
+        kQuad_EdgeType,
+        /* Similar to above but for hairline quadratics. Uses unsigned distance.
+           Coverage is min(0, 1-distance). 3rd & 4th component unused. Requires
+           shader derivative instruction support. */
+        kHairQuad_EdgeType,
+
+        kLast_EdgeType = kHairQuad_EdgeType
+    };
+    static const int kEdgeTypeCount = kLast_EdgeType + 1;
+
+    static GrEffectRef* Create(EdgeType type) {
+        // we go through this so we only have one copy of each effect
+        static GrEffectRef* gEdgeEffectRef[kEdgeTypeCount] = {
+            CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(GrEdgeEffect, (kHairLine_EdgeType)))),
+            CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(GrEdgeEffect, (kQuad_EdgeType)))),
+            CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(GrEdgeEffect, (kHairQuad_EdgeType)))),
+        };
+        static SkAutoTUnref<GrEffectRef> gUnref0(gEdgeEffectRef[0]);
+        static SkAutoTUnref<GrEffectRef> gUnref1(gEdgeEffectRef[1]);
+        static SkAutoTUnref<GrEffectRef> gUnref2(gEdgeEffectRef[2]);
+        
+        gEdgeEffectRef[type]->ref();
+        return gEdgeEffectRef[type];
+    }
+
+    virtual ~GrEdgeEffect() {}
+
+    static const char* Name() { return "Edge"; }
+
+    virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
+
+    typedef GrGLEdgeEffect GLEffect;
+
+    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+
+    EdgeType edgeType() const { return fEdgeType; }
+
+private:
+    GrEdgeEffect(EdgeType edgeType);
+
+    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
+        const GrEdgeEffect& qee = CastEffect<GrEdgeEffect>(other);
+        return qee.fEdgeType == fEdgeType;
+    }
+
+    EdgeType fEdgeType;
+
+    GR_DECLARE_EFFECT_TEST;
+
+    typedef GrEffect INHERITED;
+};
+
+#endif
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 3331468..fc80a78 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -87,8 +87,7 @@
 
     // no reason to do edge aa or look at per-vertex coverage if coverage is ignored
     if (skipCoverage) {
-        desc->fAttribBindings &= ~(GrDrawState::kEdge_AttribBindingsBit |
-                                   GrDrawState::kCoverage_AttribBindingsBit);
+        desc->fAttribBindings &= ~(GrDrawState::kCoverage_AttribBindingsBit);
     }
 
     bool colorIsTransBlack = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag);
@@ -118,12 +117,10 @@
 
     int lastEnabledStage = -1;
 
-    if (!skipCoverage && (desc->fAttribBindings & GrDrawState::kEdge_AttribBindingsBit)) {
-        desc->fVertexEdgeType = drawState.getVertexEdgeType();
+    if (!skipCoverage) {
         desc->fDiscardIfOutsideEdge = drawState.getStencil().doesWrite();
     } else {
         // Use canonical values when edge-aa is not enabled to avoid program cache misses.
-        desc->fVertexEdgeType = GrDrawState::kHairLine_EdgeType;
         desc->fDiscardIfOutsideEdge = false;
     }
 
@@ -167,8 +164,7 @@
 
     // other coverage inputs
     if (!hasCoverage) {
-        hasCoverage = requiresAttributeCoverage ||
-                      (desc->fAttribBindings & GrDrawState::kEdge_AttribBindingsBit);
+        hasCoverage = requiresAttributeCoverage;
     }
 
     if (hasCoverage) {
@@ -207,9 +203,6 @@
     } else {
         desc->fCoverageAttributeIndex = GrDrawState::kCoverageOverrideAttribIndexValue;
     }
-    if (desc->fAttribBindings & GrDrawState::kEdge_AttribBindingsBit) {
-        desc->fEdgeAttributeIndex = drawState.getAttribIndex(GrDrawState::kEdge_AttribIndex);
-    }
     if (desc->fAttribBindings & GrDrawState::kLocalCoords_AttribBindingsBit) {
         desc->fLocalCoordsAttributeIndex = drawState.getAttribIndex(GrDrawState::kLocalCoords_AttribIndex);
     }
@@ -227,10 +220,6 @@
         GrAssert(desc->fCoverageAttributeIndex < GrDrawState::kVertexAttribCnt);
         GrAssert(kAttribLayouts[vertexAttribs[desc->fCoverageAttributeIndex].fType].fCount == 4);
     }
-    if (desc->fAttribBindings & GrDrawState::kEdge_AttribBindingsBit) {
-        GrAssert(desc->fEdgeAttributeIndex < GrDrawState::kVertexAttribCnt);
-        GrAssert(kAttribLayouts[vertexAttribs[desc->fEdgeAttributeIndex].fType].fCount == 4);
-    }
     if (desc->fAttribBindings & GrDrawState::kLocalCoords_AttribBindingsBit) {
         GrAssert(desc->fLocalCoordsAttributeIndex < GrDrawState::kVertexAttribCnt);
         GrAssert(kAttribLayouts[vertexAttribs[desc->fLocalCoordsAttributeIndex].fType].fCount == 2);
@@ -419,68 +408,6 @@
 }
 }
 
-bool GrGLProgram::genEdgeCoverage(SkString* coverageVar,
-                                  GrGLShaderBuilder* builder) const {
-    if (fDesc.fAttribBindings & GrDrawState::kEdge_AttribBindingsBit) {
-        const char *vsName, *fsName;
-        builder->addVarying(kVec4f_GrSLType, "Edge", &vsName, &fsName);
-        builder->addAttribute(kVec4f_GrSLType, EDGE_ATTR_NAME);
-        builder->vsCodeAppendf("\t%s = " EDGE_ATTR_NAME ";\n", vsName);
-        switch (fDesc.fVertexEdgeType) {
-        case GrDrawState::kHairLine_EdgeType:
-            builder->fsCodeAppendf("\tfloat edgeAlpha = abs(dot(vec3(%s.xy,1), %s.xyz));\n",
-                                   builder->fragmentPosition(), fsName);
-            builder->fsCodeAppendf("\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
-            break;
-        case GrDrawState::kQuad_EdgeType:
-            builder->fsCodeAppendf("\tfloat edgeAlpha;\n");
-            // keep the derivative instructions outside the conditional
-            builder->fsCodeAppendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
-            builder->fsCodeAppendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
-            builder->fsCodeAppendf("\tif (%s.z > 0.0 && %s.w > 0.0) {\n", fsName, fsName);
-            // today we know z and w are in device space. We could use derivatives
-            builder->fsCodeAppendf("\t\tedgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);\n", fsName,
-                                   fsName);
-            builder->fsCodeAppendf ("\t} else {\n");
-            builder->fsCodeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
-                                   "\t\t               2.0*%s.x*duvdy.x - duvdy.y);\n",
-                                    fsName, fsName);
-            builder->fsCodeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, fsName);
-            builder->fsCodeAppendf("\t\tedgeAlpha = clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);\n"
-                                   "\t}\n");
-            if (kES2_GrGLBinding == fContext.info().binding()) {
-                builder->fHeader.append("#extension GL_OES_standard_derivatives: enable\n");
-            }
-            break;
-        case GrDrawState::kHairQuad_EdgeType:
-            builder->fsCodeAppendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
-            builder->fsCodeAppendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
-            builder->fsCodeAppendf("\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
-                                   "\t               2.0*%s.x*duvdy.x - duvdy.y);\n",
-                                   fsName, fsName);
-            builder->fsCodeAppendf("\tfloat edgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName,
-                                   fsName);
-            builder->fsCodeAppend("\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / dot(gF, gF));\n");
-            builder->fsCodeAppend("\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
-            if (kES2_GrGLBinding == fContext.info().binding()) {
-                builder->fHeader.printf("#extension GL_OES_standard_derivatives: enable\n");
-            }
-            break;
-        default:
-            GrCrash("Unknown Edge Type!");
-            break;
-        }
-        if (fDesc.fDiscardIfOutsideEdge) {
-            builder->fsCodeAppend("\tif (edgeAlpha <= 0.0) {\n\t\tdiscard;\n\t}\n");
-        }
-        *coverageVar = "edgeAlpha";
-        return true;
-    } else {
-        coverageVar->reset();
-        return false;
-    }
-}
-
 void GrGLProgram::genInputColor(GrGLShaderBuilder* builder, SkString* inColor) {
     switch (fDesc.fColorInput) {
         case GrGLProgram::Desc::kAttribute_ColorInput: {
@@ -834,19 +761,15 @@
     if (!wroteFragColorZero || Desc::kNone_DualSrcOutput != fDesc.fDualSrcOutput) {
 
         if (!coverageIsZero) {
-            bool inCoverageIsScalar  = this->genEdgeCoverage(&inCoverage, &builder);
-
             switch (fDesc.fCoverageInput) {
                 case Desc::kSolidWhite_ColorInput:
                     // empty string implies solid white
                     break;
                 case Desc::kAttribute_ColorInput:
                     gen_attribute_coverage(&builder, &inCoverage);
-                    inCoverageIsScalar = false;
                     break;
                 case Desc::kUniform_ColorInput:
                     this->genUniformCoverage(&builder, &inCoverage);
-                    inCoverageIsScalar = false;
                     break;
                 default:
                     GrCrash("Unexpected input coverage.");
@@ -861,13 +784,6 @@
                     outCoverage.appendS32(s);
                     builder.fsCodeAppendf("\tvec4 %s;\n", outCoverage.c_str());
 
-                    // stages don't know how to deal with a scalar input. (Maybe they should. We
-                    // could pass a GrGLShaderVar)
-                    if (inCoverageIsScalar) {
-                        builder.fsCodeAppendf("\tvec4 %s4 = vec4(%s);\n",
-                                              inCoverage.c_str(), inCoverage.c_str());
-                        inCoverage.append("4");
-                    }
                     builder.setCurrentStage(s);
                     fEffects[s] = builder.createAndEmitGLEffect(
                                                     *stages[s],
@@ -984,9 +900,6 @@
     GL_CALL(BindAttribLocation(fProgramID, fDesc.fColorAttributeIndex, COL_ATTR_NAME));
     GL_CALL(BindAttribLocation(fProgramID, fDesc.fCoverageAttributeIndex, COV_ATTR_NAME));
 
-    if (fDesc.fAttribBindings & GrDrawState::kEdge_AttribBindingsBit) {
-        GL_CALL(BindAttribLocation(fProgramID, fDesc.fEdgeAttributeIndex, EDGE_ATTR_NAME));
-    }
     if (fDesc.fAttribBindings & GrDrawState::kLocalCoords_AttribBindingsBit) {
         GL_CALL(BindAttribLocation(fProgramID,
                                    fDesc.fLocalCoordsAttributeIndex,
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index 9fd01fd..a6ece6c 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -165,8 +165,6 @@
             kDualSrcOutputCnt
         };
 
-        // TODO: remove these two members when edge-aa can be rewritten as a GrEffect.
-        GrDrawState::VertexEdgeType fVertexEdgeType;
         // should the FS discard if the edge-aa coverage is zero (to avoid stencil manipulation)
         bool                        fDiscardIfOutsideEdge;
 
@@ -191,7 +189,6 @@
         int8_t                      fPositionAttributeIndex;
         int8_t                      fColorAttributeIndex;
         int8_t                      fCoverageAttributeIndex;
-        int8_t                      fEdgeAttributeIndex;
         int8_t                      fLocalCoordsAttributeIndex;
 
         friend class GrGLProgram;
@@ -225,11 +222,6 @@
 
     void genUniformCoverage(GrGLShaderBuilder* segments, SkString* inOutCoverage);
 
-    // generates code to compute coverage based on edge AA. Returns true if edge coverage was
-    // inserted in which case coverageVar will be updated to refer to a scalar. Otherwise,
-    // coverageVar is set to an empty string.
-    bool genEdgeCoverage(SkString* coverageVar, GrGLShaderBuilder* builder) const;
-
     // Creates a GL program ID, binds shader attributes to GL vertex attrs, and links the program
     bool bindOutputsAttribsAndLinkProgram(const GrGLShaderBuilder& builder,
                                           bool bindColorOut,
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 1270b93..50ba9c3 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -39,17 +39,10 @@
     fExperimentalGS = gpu->caps()->geometryShaderSupport() && random->nextBool();
 #endif
 
-    bool edgeAA = random->nextBool();
-    if (edgeAA) {
-        fAttribBindings |= GrDrawState::kEdge_AttribBindingsBit;
-        if (gpu->caps()->shaderDerivativeSupport()) {
-            fVertexEdgeType = (GrDrawState::VertexEdgeType)
-                              random->nextULessThan(GrDrawState::kVertexEdgeTypeCnt);
-            fDiscardIfOutsideEdge = random->nextBool();
-        } else {
-            fVertexEdgeType = GrDrawState::kHairLine_EdgeType;
-            fDiscardIfOutsideEdge = false;
-        }
+    if (gpu->caps()->shaderDerivativeSupport()) {
+        fDiscardIfOutsideEdge = random->nextBool();
+    } else {
+        fDiscardIfOutsideEdge = false;
     }
 
     if (gpu->caps()->dualSourceBlendingSupport()) {
@@ -84,10 +77,6 @@
         fCoverageAttributeIndex = attributeIndex;
         ++attributeIndex;
     }
-    if (fAttribBindings & GrDrawState::kEdge_AttribBindingsBit) {
-        fEdgeAttributeIndex = attributeIndex;
-        ++attributeIndex;
-    }
     if (fAttribBindings & GrDrawState::kLocalCoords_AttribBindingsBit) {
         fLocalCoordsAttributeIndex = attributeIndex;
         ++attributeIndex;