convert pathops to use SkSTArray where possible.

src/pathops/SkOpSegment.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpSegment_DEFINE
 #define SkOpSegment_DEFINE
 
 #include "SkOpAngle.h"
 #include "SkOpSpan.h"
 #include "SkPathOpsBounds.h"
 #include "SkPathOpsCurve.h"
+#include "SkTArray.h"
 #include "SkTDArray.h"
 
 class SkPathWriter;
 
 class SkOpSegment {
 public:
     SkOpSegment() {
 #if DEBUG_DUMP
         fID = ++gSegmentID;
 #endif
@@ skipping 199 matching lines @@
     }
 
     SkScalar yAtT(int index) const {
         return yAtT(&fTs[index]);
     }
 
     SkScalar yAtT(const SkOpSpan* span) const {
         return xyAtT(span).fY;
     }
 
-    bool activeAngle(int index, int* done, SkTDArray<SkOpAngle>* angles);
+    bool activeAngle(int index, int* done, SkTArray<SkOpAngle, true>* angles);
     SkPoint activeLeftTop(bool onlySortable, int* firstT) const;
     bool activeOp(int index, int endIndex, int xorMiMask, int xorSuMask, SkPathOp op);
     bool activeOp(int xorMiMask, int xorSuMask, int index, int endIndex, SkPathOp op,
                   int* sumMiWinding, int* sumSuWinding, int* maxWinding, int* sumWinding,
                   int* oppMaxWinding, int* oppSumWinding);
     bool activeWinding(int index, int endIndex);
     bool activeWinding(int index, int endIndex, int* maxWinding, int* sumWinding);
     void addCubic(const SkPoint pts[4], bool operand, bool evenOdd);
     void addCurveTo(int start, int end, SkPathWriter* path, bool active) const;
     void addLine(const SkPoint pts[2], bool operand, bool evenOdd);
@@ skipping 43 matching lines @@
     void markWinding(int index, int winding, int oppWinding);
     bool nextCandidate(int* start, int* end) const;
     int nextExactSpan(int from, int step) const;
     int nextSpan(int from, int step) const;
     void setUpWindings(int index, int endIndex, int* sumMiWinding, int* sumSuWinding,
             int* maxWinding, int* sumWinding, int* oppMaxWinding, int* oppSumWinding);
     enum SortAngleKind {
         kMustBeOrdered_SortAngleKind, // required for winding calc
         kMayBeUnordered_SortAngleKind // ok for find top
     };
-    static bool SortAngles(const SkTDArray<SkOpAngle>& angles, SkTDArray<SkOpAngle*>* angleList,
+    static bool SortAngles(const SkTArray<SkOpAngle, true>& angles,
+                           SkTArray<SkOpAngle*, true>* angleList,
                            SortAngleKind );
     bool subDivide(int start, int end, SkPoint edge[4]) const;
     bool subDivide(int start, int end, SkDCubic* result) const;
     void undoneSpan(int* start, int* end);
     int updateOppWindingReverse(const SkOpAngle* angle) const;
     int updateWindingReverse(const SkOpAngle* angle) const;
     static bool UseInnerWinding(int outerWinding, int innerWinding);
     int windingAtT(double tHit, int tIndex, bool crossOpp, SkScalar* dx) const;
     int windSum(const SkOpAngle* angle) const;
     int windValue(const SkOpAngle* angle) const;
 
 #if DEBUG_DUMP
     int debugID() const {
         return fID;
     }
 #endif
 #if DEBUG_ACTIVE_SPANS || DEBUG_ACTIVE_SPANS_FIRST_ONLY
     void debugShowActiveSpans() const;
 #endif
 #if DEBUG_SORT || DEBUG_SWAP_TOP
-    void debugShowSort(const char* fun, const SkTDArray<SkOpAngle*>& angles, int first,
+    void debugShowSort(const char* fun, const SkTArray<SkOpAngle*, true>& angles, int first,
             const int contourWinding, const int oppContourWinding) const;
-    void debugShowSort(const char* fun, const SkTDArray<SkOpAngle*>& angles, int first);
+    void debugShowSort(const char* fun, const SkTArray<SkOpAngle*, true>& angles, int first);
 #endif
 #if DEBUG_CONCIDENT
     void debugShowTs() const;
 #endif
 #if DEBUG_SHOW_WINDING
     int debugShowWindingValues(int slotCount, int ofInterest) const;
 #endif
 
 private:
-    bool activeAngleOther(int index, int* done, SkTDArray<SkOpAngle>* angles);
-    bool activeAngleInner(int index, int* done, SkTDArray<SkOpAngle>* angles);
-    void addAngle(SkTDArray<SkOpAngle>* angles, int start, int end) const;
+    bool activeAngleOther(int index, int* done, SkTArray<SkOpAngle, true>* angles);
+    bool activeAngleInner(int index, int* done, SkTArray<SkOpAngle, true>* angles);
+    void addAngle(SkTArray<SkOpAngle, true>* angles, int start, int end) const;
     void addCancelOutsides(double tStart, double oStart, SkOpSegment* other, double oEnd);
-    void addCoinOutsides(const SkTDArray<double>& outsideTs, SkOpSegment* other, double oEnd);
-    void addTwoAngles(int start, int end, SkTDArray<SkOpAngle>* angles) const;
+    void addCoinOutsides(const SkTArray<double, true>& outsideTs, SkOpSegment* other, double oEnd);
+    void addTwoAngles(int start, int end, SkTArray<SkOpAngle, true>* angles) const;
     int advanceCoincidentOther(const SkOpSpan* test, double oEndT, int oIndex);
     int advanceCoincidentThis(const SkOpSpan* oTest, bool opp, int index);
-    void buildAngles(int index, SkTDArray<SkOpAngle>* angles, bool includeOpp) const;
-    void buildAnglesInner(int index, SkTDArray<SkOpAngle>* angles) const;
+    void buildAngles(int index, SkTArray<SkOpAngle, true>* angles, bool includeOpp) const;
+    void buildAnglesInner(int index, SkTArray<SkOpAngle, true>* angles) const;
     int bumpCoincidentThis(const SkOpSpan& oTest, bool opp, int index,
-                           SkTDArray<double>* outsideTs);
+                           SkTArray<double, true>* outsideTs);
     int bumpCoincidentOther(const SkOpSpan& test, double oEndT, int& oIndex,
-                            SkTDArray<double>* oOutsideTs);
+                            SkTArray<double, true>* oOutsideTs);
     bool bumpSpan(SkOpSpan* span, int windDelta, int oppDelta);
     bool clockwise(int tStart, int tEnd) const;
     void decrementSpan(SkOpSpan* span);
     bool equalPoints(int greaterTIndex, int lesserTIndex);
-    int findStartingEdge(const SkTDArray<SkOpAngle*>& sorted, int start, int end);
+    int findStartingEdge(const SkTArray<SkOpAngle*, true>& sorted, int start, int end);
     void init(const SkPoint pts[], SkPath::Verb verb, bool operand, bool evenOdd);
     void matchWindingValue(int tIndex, double t, bool borrowWind);
     SkOpSpan* markAndChaseDone(int index, int endIndex, int winding);
     SkOpSpan* markAndChaseDoneBinary(const SkOpAngle* angle, int winding, int oppWinding);
     SkOpSpan* markAndChaseWinding(const SkOpAngle* angle, const int winding);
     SkOpSpan* markAndChaseWinding(int index, int endIndex, int winding, int oppWinding);
     SkOpSpan* markAngle(int maxWinding, int sumWinding, bool activeAngle, const SkOpAngle* angle);
     void markDoneBinary(int index, int winding, int oppWinding);
     SkOpSpan* markAndChaseDoneUnary(const SkOpAngle* angle, int winding);
     void markOneDone(const char* funName, int tIndex, int winding);
     void markOneDoneBinary(const char* funName, int tIndex);
     void markOneDoneBinary(const char* funName, int tIndex, int winding, int oppWinding);
     void markOneDoneUnary(const char* funName, int tIndex);
     void markUnsortable(int start, int end);
     bool monotonicInY(int tStart, int tEnd) const;
     bool multipleSpans(int end) const;
     SkOpSegment* nextChase(int* index, const int step, int* min, SkOpSpan** last);
     bool serpentine(int tStart, int tEnd) const;
     void subDivideBounds(int start, int end, SkPathOpsBounds* bounds) const;
-    static void TrackOutside(SkTDArray<double>* outsideTs, double end, double start);
+    static void TrackOutside(SkTArray<double, true>* outsideTs, double end, double start);
     int updateOppWinding(int index, int endIndex) const;
     int updateOppWinding(const SkOpAngle* angle) const;
     int updateWinding(int index, int endIndex) const;
     int updateWinding(const SkOpAngle* angle) const;
     SkOpSpan* verifyOneWinding(const char* funName, int tIndex);
     SkOpSpan* verifyOneWindingU(const char* funName, int tIndex);
     int windValueAt(double t) const;
     void zeroSpan(SkOpSpan* span);
 
 #if DEBUG_SWAP_TOP
     bool controlsContainedByEnds(int tStart, int tEnd) const;
 #endif
 #if DEBUG_CONCIDENT
      void debugAddTPair(double t, const SkOpSegment& other, double otherT) const;
 #endif
 #if DEBUG_MARK_DONE || DEBUG_UNSORTABLE
     void debugShowNewWinding(const char* fun, const SkOpSpan& span, int winding);
     void debugShowNewWinding(const char* fun, const SkOpSpan& span, int winding, int oppWinding);
 #endif
 #if DEBUG_WINDING
     static char as_digit(int value) {
         return value < 0 ? '?' : value <= 9 ? '0' + value : '+';
     }
 #endif
 
     const SkPoint* fPts;
     SkPathOpsBounds fBounds;
+    // FIXME: can't convert to SkTArray because it uses insert
     SkTDArray<SkOpSpan> fTs;  // two or more (always includes t=0 t=1)
     // OPTIMIZATION: could pack donespans, verb, operand, xor into 1 int-sized value
     int fDoneSpans;  // quick check that segment is finished
     // OPTIMIZATION: force the following to be byte-sized
     SkPath::Verb fVerb;
     bool fOperand;
     bool fXor;  // set if original contour had even-odd fill
     bool fOppXor;  // set if opposite operand had even-odd fill
 #if DEBUG_DUMP
     int fID;
 #endif
 };
 
 #endif