Reenable GrAAHairlinePathRenderer assert w/ fix

src/gpu/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 720 matching lines @@
 bool GrAAHairLinePathRenderer::createLineGeom(const SkPath& path,
                                               GrDrawTarget* target,
                                               const PtArray& lines,
                                               int lineCnt,
                                               GrDrawTarget::AutoReleaseGeometry* arg,
                                               SkRect* devBounds) {
     GrDrawState* drawState = target->drawState();
 
     const SkMatrix& viewM = drawState->getViewMatrix();
 
-    devBounds->outset(SK_Scalar1, SK_Scalar1);
-
     int vertCnt = kVertsPerLineSeg * lineCnt;
 
     drawState->setVertexAttribs<gHairlineLineAttribs>(SK_ARRAY_COUNT(gHairlineLineAttribs));
     SkASSERT(sizeof(LineVertex) == drawState->getVertexSize());
 
     if (!arg->set(target, vertCnt, 0)) {
         return false;
     }
 
     LineVertex* verts = reinterpret_cast<LineVertex*>(arg->vertices());
 
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
 
     if (viewM.hasPerspective()) {
         if (viewM.invert(&ivm)) {
             toSrc = &ivm;
         }
     }
     devBounds->set(lines.begin(), lines.count());
     for (int i = 0; i < lineCnt; ++i) {
         add_line(&lines[2*i], toSrc, drawState->getCoverage(), &verts);
     }
-    // All the verts computed by add_line are within unit distance of the end points. Add a little
-    // extra to account for vector normalization precision.
-    static const SkScalar kOutset = SK_Scalar1 + SK_Scalar1 / 20;
+    // All the verts computed by add_line are within sqrt(1^2 + 0.5^2) of the end points. 
+    static const SkScalar kSqrtOfOneAndAQuarter = SkFloatToScalar(1.118f);
+    // Add a little extra to account for vector normalization precision.
+    static const SkScalar kOutset = kSqrtOfOneAndAQuarter + SK_Scalar1 / 20;
     devBounds->outset(kOutset, kOutset);
 
     return true;
 }
 
 bool GrAAHairLinePathRenderer::createBezierGeom(
                                           const SkPath& path,
                                           GrDrawTarget* target,
                                           const PtArray& quads,
                                           int quadCnt,
@@ skipping 151 matching lines @@
         // createLineGeom transforms the geometry to device space when the matrix does not have
         // perspective.
         if (target->getDrawState().getViewMatrix().hasPerspective()) {
             asr.set(target, GrDrawTarget::kPreserve_ASRInit);
         } else if (!asr.setIdentity(target, GrDrawTarget::kPreserve_ASRInit)) {
             return false;
         }
         GrDrawState* drawState = target->drawState();
 
         // Check devBounds
-//        SkASSERT(check_bounds<LineVertex>(drawState, devBounds, arg.vertices(),
-//                                          kVertsPerLineSeg * lineCnt));
+        SkASSERT(check_bounds<LineVertex>(drawState, devBounds, arg.vertices(),
+                                          kVertsPerLineSeg * lineCnt));
 
         {
             GrDrawState::AutoRestoreEffects are(drawState);
             target->setIndexSourceToBuffer(fLinesIndexBuffer);
             int lines = 0;
             while (lines < lineCnt) {
                 int n = GrMin(lineCnt - lines, kNumLineSegsInIdxBuffer);
                 target->drawIndexed(kTriangles_GrPrimitiveType,
                                     kVertsPerLineSeg*lines,     // startV
                                     0,                          // startI
@@ skipping 77 matching lines @@
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }