Fix bug where ovals' AA exceed bounds by .5 pixel

src/gpu/GrOvalRenderer.cpp

 /*
  * 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 "GrOvalRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 801 matching lines @@
             SkScalar yRadius = geom.fYRadius;
 
             // Compute the reciprocals of the radii here to save time in the shader
             SkScalar xRadRecip = SkScalarInvert(xRadius);
             SkScalar yRadRecip = SkScalarInvert(yRadius);
             SkScalar xInnerRadRecip = SkScalarInvert(geom.fInnerXRadius);
             SkScalar yInnerRadRecip = SkScalarInvert(geom.fInnerYRadius);
 
             const SkRect& bounds = geom.fDevBounds;
 
+            // fOffsets are expanded from xyRadii to include the half-pixel antialiasing width.
+            SkScalar xMaxOffset = xRadius + SK_ScalarHalf;
+            SkScalar yMaxOffset = yRadius + SK_ScalarHalf;
+
             // The inner radius in the vertex data must be specified in normalized space.
             verts[0].fPos = SkPoint::Make(bounds.fLeft,  bounds.fTop);
             verts[0].fColor = color;
-            verts[0].fOffset = SkPoint::Make(-xRadius, -yRadius);
+            verts[0].fOffset = SkPoint::Make(-xMaxOffset, -yMaxOffset);
             verts[0].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
             verts[0].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
             verts[1].fPos = SkPoint::Make(bounds.fLeft,  bounds.fBottom);
             verts[1].fColor = color;
-            verts[1].fOffset = SkPoint::Make(-xRadius, yRadius);
+            verts[1].fOffset = SkPoint::Make(-xMaxOffset, yMaxOffset);
             verts[1].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
             verts[1].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
             verts[2].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom);
             verts[2].fColor = color;
-            verts[2].fOffset = SkPoint::Make(xRadius, yRadius);
+            verts[2].fOffset = SkPoint::Make(xMaxOffset, yMaxOffset);
             verts[2].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
             verts[2].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
             verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
             verts[3].fColor = color;
-            verts[3].fOffset = SkPoint::Make(xRadius, -yRadius);
+            verts[3].fOffset = SkPoint::Make(xMaxOffset, -yMaxOffset);
             verts[3].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
             verts[3].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
             verts += kVerticesPerQuad;
         }
         helper.recordDraw(target, gp);
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         EllipseBatch* that = t->cast<EllipseBatch>();
@@ skipping 77 matching lines @@
         // this is legit only if scale & translation (which should be the case at the moment)
         if (isStrokeOnly) {
             innerXRadius = xRadius - scaledStroke.fX;
             innerYRadius = yRadius - scaledStroke.fY;
         }
 
         xRadius += scaledStroke.fX;
         yRadius += scaledStroke.fY;
     }
 
-    // We've extended the outer x radius out half a pixel to antialias.
-    // This will also expand the rect so all the pixels will be captured.
-    // TODO: Consider if we should use sqrt(2)/2 instead
-    xRadius += SK_ScalarHalf;
-    yRadius += SK_ScalarHalf;
-
     EllipseBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fXRadius = xRadius;
     geometry.fYRadius = yRadius;
     geometry.fInnerXRadius = innerXRadius;
     geometry.fInnerYRadius = innerYRadius;
     geometry.fDevBounds = SkRect::MakeLTRB(center.fX - xRadius, center.fY - yRadius,
                                            center.fX + xRadius, center.fY + yRadius);
 
+    // outset bounds to include half-pixel width antialiasing. 
+    geometry.fDevBounds.outset(SK_ScalarHalf, SK_ScalarHalf);
+
     return new EllipseBatch(geometry, viewMatrix,
                             isStrokeOnly && innerXRadius > 0 && innerYRadius > 0);
 }
 
 GrDrawBatch* GrOvalRenderer::CreateEllipseBatch(GrColor color,
                                                 const SkMatrix& viewMatrix,
                                                 const SkRect& ellipse,
                                                 const SkStrokeRec& stroke) {
     return create_ellipse_batch(color, viewMatrix, ellipse, stroke);
 }
@@ skipping 751 matching lines @@
 }
 
 DRAW_BATCH_TEST_DEFINE(RRectBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
     GrColor color = GrRandomColor(random);
     const SkRRect& rrect = GrTest::TestRRectSimple(random);
     return create_rrect_batch(color, viewMatrix, rrect, GrTest::TestStrokeRec(random));
 }
 
 #endif