Modify interface to GrPathUtils::convertCubicToQuads

src/gpu/GrPathUtils.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPathUtils_DEFINED
 #define GrPathUtils_DEFINED
 
@@ skipping 90 matching lines @@
     // conic, K^2 - LM.
     //
     // Output:
     //  K = (klm[0], klm[1], klm[2])
     //  L = (klm[3], klm[4], klm[5])
     //  M = (klm[6], klm[7], klm[8])
     void getConicKLM(const SkPoint p[3], const SkScalar weight, SkScalar klm[9]);
 
     // Converts a cubic into a sequence of quads. If working in device space
     // use tolScale = 1, otherwise set based on stretchiness of the matrix. The
-    // result is sets of 3 points in quads (TODO: share endpoints in returned
-    // array)
+    // result is sets of 3 points in quads.
+    void convertCubicToQuads(const SkPoint p[4],
+                             SkScalar tolScale,
+                             SkTArray<SkPoint, true>* quads);
+
     // When we approximate a cubic {a,b,c,d} with a quadratic we may have to
     // ensure that the new control point lies between the lines ab and cd. The
     // convex path renderer requires this. It starts with a path where all the
     // control points taken together form a convex polygon. It relies on this
     // property and the quadratic approximation of cubics step cannot alter it.
-    // Setting constrainWithinTangents to true enforces this property. When this
-    // is true the cubic must be simple and dir must specify the orientation of
-    // the cubic. Otherwise, dir is ignored.
-    void convertCubicToQuads(const SkPoint p[4],
-                             SkScalar tolScale,
-                             bool constrainWithinTangents,
-                             SkPathPriv::FirstDirection dir,
-                             SkTArray<SkPoint, true>* quads);
+    // This variation enforces this constraint. The cubic must be simple and dir
+    // must specify the orientation of the contour containing the cubic.
+    void convertCubicToQuadsConstrainToTangents(const SkPoint p[4],
+                                                SkScalar tolScale,
+                                                SkPathPriv::FirstDirection dir,
+                                                SkTArray<SkPoint, true>* quads);
 
     // Chops the cubic bezier passed in by src, at the double point (intersection point)
     // if the curve is a cubic loop. If it is a loop, there will be two parametric values for
     // the double point: ls and ms. We chop the cubic at these values if they are between 0 and 1.
     // Return value:
     // Value of 3: ls and ms are both between (0,1), and dst will contain the three cubics,
     //             dst[0..3], dst[3..6], and dst[6..9] if dst is not nullptr
     // Value of 2: Only one of ls and ms are between (0,1), and dst will contain the two cubics,
     //             dst[0..3] and dst[3..6] if dst is not nullptr
     // Value of 1: Neither ls or ms are between (0,1), and dst will contain the one original cubic,
@@ skipping 34 matching lines @@
     void getCubicKLM(const SkPoint p[4], SkScalar klm[9]);
 
     // When tessellating curved paths into linear segments, this defines the maximum distance
     // in screen space which a segment may deviate from the mathmatically correct value.
     // Above this value, the segment will be subdivided.
     // This value was chosen to approximate the supersampling accuracy of the raster path (16
     // samples, or one quarter pixel).
     static const SkScalar kDefaultTolerance = SkDoubleToScalar(0.25);
 };
 #endif