Revert of Revert of stop calling SkScalarDiv

experimental/StrokePathRenderer/GrStrokePathRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStrokePathRenderer.h"
 
 #include "GrDrawTarget.h"
@@ skipping 21 matching lines @@
     SkScalar d = SkScalarMul(x1 - x2, y3 - y4) - SkScalarMul(y1 - y2, x3 - x4);
     // If d is zero, there is no intersection
     if (SkScalarNearlyZero(d)) {
         return kNone_IntersectionType;
     }
 
     // Get the x and y
     SkScalar pre  = SkScalarMul(x1, y2) - SkScalarMul(y1, x2),
              post = SkScalarMul(x3, y4) - SkScalarMul(y3, x4);
     // Compute the point of intersection
-    res.set(SkScalarDiv(SkScalarMul(pre, x3 - x4) - SkScalarMul(x1 - x2, post), d),
-            SkScalarDiv(SkScalarMul(pre, y3 - y4) - SkScalarMul(y1 - y2, post), d));
+    res.set((SkScalarMul(pre, x3 - x4) - SkScalarMul(x1 - x2, post) / d,
+            (SkScalarMul(pre, y3 - y4) - SkScalarMul(y1 - y2, post) / d);
 
     // Check if the x and y coordinates are within both lines
     return (res.x() < GrMin(x1, x2) || res.x() > GrMax(x1, x2) ||
             res.x() < GrMin(x3, x4) || res.x() > GrMax(x3, x4) ||
             res.y() < GrMin(y1, y2) || res.y() > GrMax(y1, y2) ||
             res.y() < GrMin(y3, y4) || res.y() > GrMax(y3, y4)) ?
             kOut_IntersectionType : kIn_IntersectionType;
 }
 
 GrStrokePathRenderer::GrStrokePathRenderer() {
@@ skipping 123 matching lines @@
                                         if (sinHalfAngleSq >= invMiterLimitSq) {
                                             // Find the miter point (or points if it is further
                                             // than the miter limit)
                                             const SkPoint pt2 = *pt0+v0, pt3 = *pt1+v1;
                                             if (intersection(*pt0, pt2, *pt1, pt3, miterPt[0]) !=
                                                 kNone_IntersectionType) {
                                                 SkPoint miterPt0 = miterPt[0] - *pt0;
                                                 SkPoint miterPt1 = miterPt[0] - *pt1;
                                                 SkScalar sqDist0 = miterPt0.dot(miterPt0);
                                                 SkScalar sqDist1 = miterPt1.dot(miterPt1);
-                                                const SkScalar rSq =
-                                                        SkScalarDiv(SkScalarMul(radius, radius),
-                                                                    sinHalfAngleSq);
+                                                const SkScalar rSq = radius*radius / sinHalfAngleSq;
                                                 const SkScalar sqRLimit =
                                                         SkScalarMul(sqMiterLimit, rSq);
                                                 if (sqDist0 > sqRLimit || sqDist1 > sqRLimit) {
                                                     if (sqDist1 > sqRLimit) {
                                                         v1.setLength(SkScalarSqrt(sqRLimit));
                                                         miterPt[1] = *pt1+v1;
                                                     } else {
                                                         miterPt[1] = miterPt[0];
                                                     }
                                                     if (sqDist0 > sqRLimit) {
@@ skipping 91 matching lines @@
     if (vCount > 0) {
         target->drawIndexed(kTriangles_GrPrimitiveType,
                             0,        // start vertex
                             0,        // start index
                             vCount,
                             iCount);
     }
 
     return true;
 }