convert pathops to use SkSTArray where possible.

src/pathops/SkDCubicIntersection.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 "SkIntersections.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 #include "SkPathOpsPoint.h"
 #include "SkPathOpsQuad.h"
 #include "SkPathOpsRect.h"
 #include "SkReduceOrder.h"
-#include "SkTDArray.h"
 #include "SkTSort.h"
 
 #if ONE_OFF_DEBUG
 static const double tLimits1[2][2] = {{0.36, 0.37}, {0.63, 0.64}};
 static const double tLimits2[2][2] = {{-0.865211397, -0.865215212}, {-0.865207696, -0.865208078}};
 #endif
 
 #define DEBUG_QUAD_PART 0
 #define SWAP_TOP_DEBUG 0
 
+static const int kCubicToQuadSubdivisionDepth = 8; // slots reserved for cubic to quads subdivision
+
 static int quadPart(const SkDCubic& cubic, double tStart, double tEnd, SkReduceOrder* reducer) {
     SkDCubic part = cubic.subDivide(tStart, tEnd);
     SkDQuad quad = part.toQuad();
     // FIXME: should reduceOrder be looser in this use case if quartic is going to blow up on an
     // extremely shallow quadratic?
     int order = reducer->reduce(quad, SkReduceOrder::kFill_Style);
 #if DEBUG_QUAD_PART
     SkDebugf("%s cubic=(%1.17g,%1.17g %1.17g,%1.17g %1.17g,%1.17g %1.17g,%1.17g)"
             " t=(%1.17g,%1.17g)\n", __FUNCTION__, cubic[0].fX, cubic[0].fY,
             cubic[1].fX, cubic[1].fY, cubic[2].fX, cubic[2].fY,
@@ skipping 31 matching lines @@
     }
 }
 
 // this flavor centers potential intersections recursively. In contrast, '2' may inadvertently
 // chase intersections near quadratic ends, requiring odd hacks to find them.
 static void intersect(const SkDCubic& cubic1, double t1s, double t1e, const SkDCubic& cubic2,
         double t2s, double t2e, double precisionScale, SkIntersections& i) {
     i.upDepth();
     SkDCubic c1 = cubic1.subDivide(t1s, t1e);
     SkDCubic c2 = cubic2.subDivide(t2s, t2e);
-    SkTDArray<double> ts1;
+    SkSTArray<kCubicToQuadSubdivisionDepth, double, true> ts1;
     // OPTIMIZE: if c1 == c2, call once (happens when detecting self-intersection)
     c1.toQuadraticTs(c1.calcPrecision() * precisionScale, &ts1);
-    SkTDArray<double> ts2;
+    SkSTArray<kCubicToQuadSubdivisionDepth, double, true> ts2;
     c2.toQuadraticTs(c2.calcPrecision() * precisionScale, &ts2);
     double t1Start = t1s;
     int ts1Count = ts1.count();
     for (int i1 = 0; i1 <= ts1Count; ++i1) {
         const double tEnd1 = i1 < ts1Count ? ts1[i1] : 1;
         const double t1 = t1s + (t1e - t1s) * tEnd1;
         SkReduceOrder s1;
         int o1 = quadPart(cubic1, t1Start, t1, &s1);
         double t2Start = t2s;
         int ts2Count = ts2.count();
@@ skipping 166 matching lines @@
 #define LINE_FRACTION 0.1
 
 // intersect the end of the cubic with the other. Try lines from the end to control and opposite
 // end to determine range of t on opposite cubic.
 static void intersectEnd(const SkDCubic& cubic1, bool start, const SkDCubic& cubic2,
                          const SkDRect& bounds2, SkIntersections& i) {
     SkDLine line;
     int t1Index = start ? 0 : 3;
     // don't bother if the two cubics are connnected
 #if 1
-    SkTDArray<double> tVals;  // OPTIMIZE: replace with hard-sized array
+    static const int kPointsInCubic = 4; // FIXME: move to DCubic, replace '4' with this
+    static const int kMaxLineCubicIntersections = 3;
+    SkSTArray<(kMaxLineCubicIntersections - 1) * kMaxLineCubicIntersections, double, true> tVals;
     line[0] = cubic1[t1Index];
     // this variant looks for intersections with the end point and lines parallel to other points
-    for (int index = 0; index < 4; ++index) {
+    for (int index = 0; index < kPointsInCubic; ++index) {
         if (index == t1Index) {
             continue;
         }
         SkDVector dxy1 = cubic1[index] - line[0];
         dxy1 /= SkDCubic::gPrecisionUnit;
         line[1] = line[0] + dxy1;
         SkDRect lineBounds;
         lineBounds.setBounds(line);
         if (!bounds2.intersects(&lineBounds)) {
             continue;
         }
         SkIntersections local;
         if (!local.intersect(cubic2, line)) {
             continue;
         }
         for (int idx2 = 0; idx2 < local.used(); ++idx2) {
             double foundT = local[0][idx2];
             if (approximately_less_than_zero(foundT)
                     || approximately_greater_than_one(foundT)) {
                 continue;
             }
             if (local.pt(idx2).approximatelyEqual(line[0])) {
                 if (i.swapped()) {  // FIXME: insert should respect swap
                     i.insert(foundT, start ? 0 : 1, line[0]);
                 } else {
                     i.insert(start ? 0 : 1, foundT, line[0]);
                 }
             } else {
-                *tVals.append() = foundT;
+                tVals.push_back(foundT);
             }
         }
     }
     if (tVals.count() == 0) {
         return;
     }
     SkTQSort<double>(tVals.begin(), tVals.end() - 1);
     double tMin1 = start ? 0 : 1 - LINE_FRACTION;
     double tMax1 = start ? LINE_FRACTION : 1;
     int tIdx = 0;
@@ skipping 171 matching lines @@
     }
     (void) intersect(c, c);
     if (used() > 0) {
         SkASSERT(used() == 1);
         if (fT[0][0] > fT[1][0]) {
             swapPts();
         }
     }
     return used();
 }