diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index 1f632cf..4da2898 100644
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -102,47 +102,41 @@
     // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
     // respectively.
     fRectUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
-                                                    kHalf4_GrSLType,
+                                                    kFloat4_GrSLType,
                                                     "rect",
                                                     &rectName);
 
-    GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+    GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
     if (GrProcessorEdgeTypeIsAA(aare.getEdgeType())) {
         // The amount of coverage removed in x and y by the edges is computed as a pair of negative
         // numbers, xSub and ySub.
-        fragBuilder->codeAppend("\t\thalf xSub, ySub;\n");
-        fragBuilder->codeAppendf("\t\txSub = min(sk_FragCoord.x - %s.x, 0.0);\n", rectName);
-        fragBuilder->codeAppendf("\t\txSub += min(%s.z - sk_FragCoord.x, 0.0);\n", rectName);
-        fragBuilder->codeAppendf("\t\tySub = min(sk_FragCoord.y - %s.y, 0.0);\n", rectName);
-        fragBuilder->codeAppendf("\t\tySub += min(%s.w - sk_FragCoord.y, 0.0);\n", rectName);
+        f->codeAppend("half xSub, ySub;\n");
+        f->codeAppendf("xSub = min(sk_FragCoord.x - %s.x, 0.0);\n", rectName);
+        f->codeAppendf("xSub += min(%s.z - sk_FragCoord.x, 0.0);\n", rectName);
+        f->codeAppendf("ySub = min(sk_FragCoord.y - %s.y, 0.0);\n", rectName);
+        f->codeAppendf("ySub += min(%s.w - sk_FragCoord.y, 0.0);\n", rectName);
         // Now compute coverage in x and y and multiply them to get the fraction of the pixel
         // covered.
-        fragBuilder->codeAppendf("\t\thalf alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));\n");
+        f->codeAppendf("half alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));\n");
     } else {
-        fragBuilder->codeAppendf("\t\thalf alpha = 1.0;\n");
-        fragBuilder->codeAppendf("\t\talpha *= (sk_FragCoord.x - %s.x) > -0.5 ? 1.0 : 0.0;\n",
-                                 rectName);
-        fragBuilder->codeAppendf("\t\talpha *= (%s.z - sk_FragCoord.x) > -0.5 ? 1.0 : 0.0;\n",
-                                 rectName);
-        fragBuilder->codeAppendf("\t\talpha *= (sk_FragCoord.y - %s.y) > -0.5 ? 1.0 : 0.0;\n",
-                                 rectName);
-        fragBuilder->codeAppendf("\t\talpha *= (%s.w - sk_FragCoord.y) > -0.5 ? 1.0 : 0.0;\n",
-                                 rectName);
+        f->codeAppendf("half alpha = all(greaterThan(float4(sk_FragCoord.xy, %s.zw), "
+                                                    "float4(%s.xy, sk_FragCoord.xy))) ? 1 : 0;",
+                                                    rectName, rectName);
     }
 
     if (GrProcessorEdgeTypeIsInverseFill(aare.getEdgeType())) {
-        fragBuilder->codeAppend("\t\talpha = 1.0 - alpha;\n");
+        f->codeAppend("alpha = 1.0 - alpha;\n");
     }
-    fragBuilder->codeAppendf("\t\t%s = %s * alpha;\n", args.fOutputColor, args.fInputColor);
+    f->codeAppendf("%s = %s * alpha;\n", args.fOutputColor, args.fInputColor);
 }
 
 void GLAARectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
                                const GrFragmentProcessor& processor) {
     const AARectEffect& aare = processor.cast<AARectEffect>();
-    const SkRect& rect = aare.getRect();
+    const SkRect& rect = GrProcessorEdgeTypeIsAA(aare.getEdgeType()) ?
+                         aare.getRect().makeInset(.5f, .5f) : aare.getRect();
     if (rect != fPrevRect) {
-        pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f,
-                   rect.fRight - 0.5f, rect.fBottom - 0.5f);
+        pdman.set4f(fRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
         fPrevRect = rect;
     }
 }