convert pathops to use SkSTArray where possible.

src/pathops/SkPathOpsCommon.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 "SkOpEdgeBuilder.h"
 #include "SkPathOpsCommon.h"
 #include "SkPathWriter.h"
 #include "SkTSort.h"
 
-static int contourRangeCheckY(const SkTDArray<SkOpContour*>& contourList, SkOpSegment** currentPtr,
+static int contourRangeCheckY(const SkTArray<SkOpContour*, true>& contourList, SkOpSegment** currentPtr,
                               int* indexPtr, int* endIndexPtr, double* bestHit, SkScalar* bestDx,
                               bool* tryAgain, double* midPtr, bool opp) {
     const int index = *indexPtr;
     const int endIndex = *endIndexPtr;
     const double mid = *midPtr;
     const SkOpSegment* current = *currentPtr;
     double tAtMid = current->tAtMid(index, endIndex, mid);
     SkPoint basePt = current->xyAtT(tAtMid);
     int contourCount = contourList.count();
     SkScalar bestY = SK_ScalarMin;
@@ skipping 67 matching lines @@
         }
         result = bestSeg->windingAtT(*bestHit, bestTIndex, bestOpp, bestDx);
         SkASSERT(result == SK_MinS32 || *bestDx);
     }
     double baseT = current->t(index);
     double endT = current->t(endIndex);
     *bestHit = baseT + mid * (endT - baseT);
     return result;
 }
 
-SkOpSegment* FindUndone(SkTDArray<SkOpContour*>& contourList, int* start, int* end) {
+SkOpSegment* FindUndone(SkTArray<SkOpContour*, true>& contourList, int* start, int* end) {
     int contourCount = contourList.count();
     SkOpSegment* result;
     for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
         SkOpContour* contour = contourList[cIndex];
         result = contour->undoneSegment(start, end);
         if (result) {
             return result;
         }
     }
     return NULL;
 }
 
 SkOpSegment* FindChase(SkTDArray<SkOpSpan*>& chase, int& tIndex, int& endIndex) {
     while (chase.count()) {
         SkOpSpan* span;
         chase.pop(&span);
         const SkOpSpan& backPtr = span->fOther->span(span->fOtherIndex);
         SkOpSegment* segment = backPtr.fOther;
         tIndex = backPtr.fOtherIndex;
-        SkTDArray<SkOpAngle> angles;
+        SkSTArray<SkOpAngle::kStackBasedCount, SkOpAngle, true> angles;
         int done = 0;
         if (segment->activeAngle(tIndex, &done, &angles)) {
             SkOpAngle* last = angles.end() - 1;
             tIndex = last->start();
             endIndex = last->end();
    #if TRY_ROTATE
             *chase.insert(0) = span;
    #else
             *chase.append() = span;
    #endif
             return last->segment();
         }
         if (done == angles.count()) {
             continue;
         }
-        SkTDArray<SkOpAngle*> sorted;
+        SkSTArray<SkOpAngle::kStackBasedCount, SkOpAngle*, true> sorted;
         bool sortable = SkOpSegment::SortAngles(angles, &sorted,
                 SkOpSegment::kMayBeUnordered_SortAngleKind);
         int angleCount = sorted.count();
 #if DEBUG_SORT
         sorted[0]->segment()->debugShowSort(__FUNCTION__, sorted, 0, 0, 0);
 #endif
         if (!sortable) {
             continue;
         }
         // find first angle, initialize winding to computed fWindSum
@@ skipping 54 matching lines @@
                 break;
             }
         } while (++nextIndex != lastIndex);
         *chase.insert(0) = span;
         return segment;
     }
     return NULL;
 }
 
 #if DEBUG_ACTIVE_SPANS || DEBUG_ACTIVE_SPANS_FIRST_ONLY
-void DebugShowActiveSpans(SkTDArray<SkOpContour*>& contourList) {
+void DebugShowActiveSpans(SkTArray<SkOpContour*, true>& contourList) {
     int index;
     for (index = 0; index < contourList.count(); ++ index) {
         contourList[index]->debugShowActiveSpans();
     }
 }
 #endif
 
-static SkOpSegment* findSortableTop(const SkTDArray<SkOpContour*>& contourList,
+static SkOpSegment* findSortableTop(const SkTArray<SkOpContour*, true>& contourList,
                                     int* index, int* endIndex, SkPoint* topLeft, bool* unsortable,
                                     bool* done, bool onlySortable) {
     SkOpSegment* result;
     do {
         SkPoint bestXY = {SK_ScalarMax, SK_ScalarMax};
         int contourCount = contourList.count();
         SkOpSegment* topStart = NULL;
         *done = true;
         for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
             SkOpContour* contour = contourList[cIndex];
@@ skipping 16 matching lines @@
         }
         if (!topStart) {
             return NULL;
         }
         *topLeft = bestXY;
         result = topStart->findTop(index, endIndex, unsortable, onlySortable);
     } while (!result);
     return result;
 }
 
-static int rightAngleWinding(const SkTDArray<SkOpContour*>& contourList,
+static int rightAngleWinding(const SkTArray<SkOpContour*, true>& contourList,
                              SkOpSegment** current, int* index, int* endIndex, double* tHit,
                              SkScalar* hitDx, bool* tryAgain, bool opp) {
     double test = 0.9;
     int contourWinding;
     do {
         contourWinding = contourRangeCheckY(contourList, current, index, endIndex, tHit, hitDx,
                 tryAgain, &test, opp);
         if (contourWinding != SK_MinS32 || *tryAgain) {
             return contourWinding;
         }
         test /= 2;
     } while (!approximately_negative(test));
     SkASSERT(0);  // should be OK to comment out, but interested when this hits
     return contourWinding;
 }
 
-static void skipVertical(const SkTDArray<SkOpContour*>& contourList,
+static void skipVertical(const SkTArray<SkOpContour*, true>& contourList,
         SkOpSegment** current, int* index, int* endIndex) {
     if (!(*current)->isVertical(*index, *endIndex)) {
         return;
     }
     int contourCount = contourList.count();
     for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
         SkOpContour* contour = contourList[cIndex];
         if (contour->done()) {
             continue;
         }
         *current = contour->nonVerticalSegment(index, endIndex);
         if (*current) {
             return;
         }
     }
 }
 
-SkOpSegment* FindSortableTop(const SkTDArray<SkOpContour*>& contourList, bool* firstContour,
+SkOpSegment* FindSortableTop(const SkTArray<SkOpContour*, true>& contourList, bool* firstContour,
                              int* indexPtr, int* endIndexPtr, SkPoint* topLeft, bool* unsortable,
                              bool* done,  bool binary) {
     SkOpSegment* current = findSortableTop(contourList, indexPtr, endIndexPtr, topLeft, unsortable,
             done, true);
     if (!current) {
         return NULL;
     }
     const int index = *indexPtr;
     const int endIndex = *endIndexPtr;
     if (*firstContour) {
@@ skipping 35 matching lines @@
             break;
         }
         oppContourWinding = rightAngleWinding(contourList, &current, indexPtr, endIndexPtr, &tHit,
                 &hitOppDx, &tryAgain, true);
     } while (tryAgain);
     current->initWinding(*indexPtr, *endIndexPtr, tHit, contourWinding, hitDx, oppContourWinding,
             hitOppDx);
     return current;
 }
 
-void FixOtherTIndex(SkTDArray<SkOpContour*>* contourList) {
+void FixOtherTIndex(SkTArray<SkOpContour*, true>* contourList) {
     int contourCount = (*contourList).count();
     for (int cTest = 0; cTest < contourCount; ++cTest) {
         SkOpContour* contour = (*contourList)[cTest];
         contour->fixOtherTIndex();
     }
 }
 
-void SortSegments(SkTDArray<SkOpContour*>* contourList) {
+void SortSegments(SkTArray<SkOpContour*, true>* contourList) {
     int contourCount = (*contourList).count();
     for (int cTest = 0; cTest < contourCount; ++cTest) {
         SkOpContour* contour = (*contourList)[cTest];
         contour->sortSegments();
     }
 }
 
-void MakeContourList(SkTArray<SkOpContour>& contours, SkTDArray<SkOpContour*>& list,
+void MakeContourList(SkTArray<SkOpContour>& contours, SkTArray<SkOpContour*, true>& list,
                      bool evenOdd, bool oppEvenOdd) {
     int count = contours.count();
     if (count == 0) {
         return;
     }
     for (int index = 0; index < count; ++index) {
         SkOpContour& contour = contours[index];
         contour.setOppXor(contour.operand() ? evenOdd : oppEvenOdd);
-        *list.append() = &contour;
+        list.push_back(&contour);
     }
     SkTQSort<SkOpContour>(list.begin(), list.end() - 1);
 }
 
 static bool approximatelyEqual(const SkPoint& a, const SkPoint& b) {
     return AlmostEqualUlps(a.fX, b.fX) && AlmostEqualUlps(a.fY, b.fY);
 }
 
 class DistanceLessThan {
 public:
@@ skipping 13 matching lines @@
     */
 void Assemble(const SkPathWriter& path, SkPathWriter* simple) {
 #if DEBUG_PATH_CONSTRUCTION
     SkDebugf("%s\n", __FUNCTION__);
 #endif
     SkTArray<SkOpContour> contours;
     SkOpEdgeBuilder builder(path, contours);
     builder.finish();
     int count = contours.count();
     int outer;
-    SkTDArray<int> runs;  // indices of partial contours
+    SkTArray<int, true> runs(count);  // indices of partial contours
     for (outer = 0; outer < count; ++outer) {
         const SkOpContour& eContour = contours[outer];
         const SkPoint& eStart = eContour.start();
         const SkPoint& eEnd = eContour.end();
 #if DEBUG_ASSEMBLE
         SkDebugf("%s contour", __FUNCTION__);
         if (!approximatelyEqual(eStart, eEnd)) {
             SkDebugf("[%d]", runs.count());
         } else {
             SkDebugf("   ");
         }
         SkDebugf(" start=(%1.9g,%1.9g) end=(%1.9g,%1.9g)\n",
                 eStart.fX, eStart.fY, eEnd.fX, eEnd.fY);
 #endif
         if (approximatelyEqual(eStart, eEnd)) {
             eContour.toPath(simple);
             continue;
         }
-        *runs.append() = outer;
+        runs.push_back(outer);
     }
     count = runs.count();
     if (count == 0) {
         return;
     }
-    SkTDArray<int> sLink, eLink;
-    sLink.setCount(count);
-    eLink.setCount(count);
+    SkTArray<int, true> sLink, eLink;
+    sLink.push_back_n(count);
+    eLink.push_back_n(count);
     int rIndex, iIndex;
     for (rIndex = 0; rIndex < count; ++rIndex) {
         sLink[rIndex] = eLink[rIndex] = SK_MaxS32;
     }
-    SkTDArray<double> distances;
     const int ends = count * 2;  // all starts and ends
     const int entries = (ends - 1) * count;  // folded triangle : n * (n - 1) / 2
-    distances.setCount(entries);
+    SkTArray<double, true> distances;
+    distances.push_back_n(entries);
     for (rIndex = 0; rIndex < ends - 1; ++rIndex) {
         outer = runs[rIndex >> 1];
         const SkOpContour& oContour = contours[outer];
         const SkPoint& oPt = rIndex & 1 ? oContour.end() : oContour.start();
         const int row = rIndex < count - 1 ? rIndex * ends : (ends - rIndex - 2)
                 * ends - rIndex - 1;
         for (iIndex = rIndex + 1; iIndex < ends; ++iIndex) {
             int inner = runs[iIndex >> 1];
             const SkOpContour& iContour = contours[inner];
             const SkPoint& iPt = iIndex & 1 ? iContour.end() : iContour.start();
             double dx = iPt.fX - oPt.fX;
             double dy = iPt.fY - oPt.fY;
             double dist = dx * dx + dy * dy;
             distances[row + iIndex] = dist;  // oStart distance from iStart
         }
     }
-    SkTDArray<int> sortedDist;
-    sortedDist.setCount(entries);
+    SkTArray<int, true> sortedDist;
+    sortedDist.push_back_n(entries);
     for (rIndex = 0; rIndex < entries; ++rIndex) {
         sortedDist[rIndex] = rIndex;
     }
     SkTQSort<int>(sortedDist.begin(), sortedDist.end() - 1, DistanceLessThan(distances.begin()));
     int remaining = count;  // number of start/end pairs
     for (rIndex = 0; rIndex < entries; ++rIndex) {
         int pair = sortedDist[rIndex];
         int row = pair / ends;
         int col = pair - row * ends;
         int thingOne = row < col ? row : ends - row - 2;
@@ skipping 105 matching lines @@
             }
         }
     } while (rIndex < count);
 #if DEBUG_ASSEMBLE
     for (rIndex = 0; rIndex < count; ++rIndex) {
        SkASSERT(sLink[rIndex] == SK_MaxS32);
        SkASSERT(eLink[rIndex] == SK_MaxS32);
     }
 #endif
 }