convert pathops to use SkSTArray where possible.

src/pathops/SkDCubicToQuads.cpp

 /*
 http://stackoverflow.com/questions/2009160/how-do-i-convert-the-2-control-points-of-a-cubic-curve-to-the-single-control-poi
 */
 
 /*
 Let's call the control points of the cubic Q0..Q3 and the control points of the quadratic P0..P2.
 Then for degree elevation, the equations are:
 
 Q0 = P0
 Q1 = 1/3 P0 + 2/3 P1
@@ skipping 31 matching lines @@
 http://www.caffeineowl.com/graphics/2d/vectorial/cubic2quad01.html
 // maybe in turn derived from  http://www.cccg.ca/proceedings/2004/36.pdf
 // also stored at http://www.cis.usouthal.edu/~hain/general/Publications/Bezier/bezier%20cccg04%20paper.pdf
 
 */
 
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 #include "SkPathOpsQuad.h"
 #include "SkReduceOrder.h"
-#include "SkTDArray.h"
+#include "SkTArray.h"
 #include "SkTSort.h"
 
 #define USE_CUBIC_END_POINTS 1
 
 static double calc_t_div(const SkDCubic& cubic, double precision, double start) {
     const double adjust = sqrt(3.) / 36;
     SkDCubic sub;
     const SkDCubic* cPtr;
     if (start == 0) {
         cPtr = &cubic;
@@ skipping 18 matching lines @@
     SkDQuad quad;
     quad[0] = fPts[0];
     const SkDPoint fromC1 = {(3 * fPts[1].fX - fPts[0].fX) / 2, (3 * fPts[1].fY - fPts[0].fY) / 2};
     const SkDPoint fromC2 = {(3 * fPts[2].fX - fPts[3].fX) / 2, (3 * fPts[2].fY - fPts[3].fY) / 2};
     quad[1].fX = (fromC1.fX + fromC2.fX) / 2;
     quad[1].fY = (fromC1.fY + fromC2.fY) / 2;
     quad[2] = fPts[3];
     return quad;
 }
 
-static bool add_simple_ts(const SkDCubic& cubic, double precision, SkTDArray<double>* ts) {
+static bool add_simple_ts(const SkDCubic& cubic, double precision, SkTArray<double, true>* ts) {
     double tDiv = calc_t_div(cubic, precision, 0);
     if (tDiv >= 1) {
         return true;
     }
     if (tDiv >= 0.5) {
-        *ts->append() = 0.5;
+        ts->push_back(0.5);
         return true;
     }
     return false;
 }
 
 static void addTs(const SkDCubic& cubic, double precision, double start, double end,
-        SkTDArray<double>* ts) {
+        SkTArray<double, true>* ts) {
     double tDiv = calc_t_div(cubic, precision, 0);
     double parts = ceil(1.0 / tDiv);
     for (double index = 0; index < parts; ++index) {
         double newT = start + (index / parts) * (end - start);
         if (newT > 0 && newT < 1) {
-            *ts->append() = newT;
+            ts->push_back(newT);
         }
     }
 }
 
 // flavor that returns T values only, deferring computing the quads until they are needed
 // FIXME: when called from recursive intersect 2, this could take the original cubic
 // and do a more precise job when calling chop at and sub divide by computing the fractional ts.
 // it would still take the prechopped cubic for reduce order and find cubic inflections
-void SkDCubic::toQuadraticTs(double precision, SkTDArray<double>* ts) const {
+void SkDCubic::toQuadraticTs(double precision, SkTArray<double, true>* ts) const {
     SkReduceOrder reducer;
     int order = reducer.reduce(*this, SkReduceOrder::kAllow_Quadratics, SkReduceOrder::kFill_Style);
     if (order < 3) {
         return;
     }
     double inflectT[5];
     int inflections = findInflections(inflectT);
     SkASSERT(inflections <= 2);
     if (!endsAreExtremaInXOrY()) {
         inflections += findMaxCurvature(&inflectT[inflections]);
@@ skipping 51 matching lines @@
         for (int idx = 0; idx < last; ++idx) {
             part = subDivide(inflectT[idx], inflectT[idx + 1]);
             addTs(part, precision, inflectT[idx], inflectT[idx + 1], ts);
         }
         part = subDivide(inflectT[last], 1);
         addTs(part, precision, inflectT[last], 1, ts);
         return;
     }
     addTs(*this, precision, 0, 1, ts);
 }