convert pathops to use SkSTArray where possible.

src/pathops/SkOpEdgeBuilder.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 "SkReduceOrder.h"
 
 void SkOpEdgeBuilder::init() {
     fCurrentContour = NULL;
     fOperand = false;
     fXorMask[0] = fXorMask[1] = (fPath->getFillType() & 1) ? kEvenOdd_PathOpsMask
             : kWinding_PathOpsMask;
 #if DEBUG_DUMP
     gContourID = 0;
     gSegmentID = 0;
 #endif
     fUnparseable = false;
     fSecondHalf = preFetch();
 }
 
 void SkOpEdgeBuilder::addOperand(const SkPath& path) {
     SkASSERT(fPathVerbs.count() > 0 && fPathVerbs.end()[-1] == SkPath::kDone_Verb);
-    fPathVerbs.pop();
+    fPathVerbs.pop_back();
     fPath = &path;
     fXorMask[1] = (fPath->getFillType() & 1) ? kEvenOdd_PathOpsMask
             : kWinding_PathOpsMask;
     preFetch();
 }
 
 bool SkOpEdgeBuilder::finish() {
     if (fUnparseable || !walk()) {
         return false;
     }
@@ skipping 29 matching lines @@
 int SkOpEdgeBuilder::preFetch() {
     if (!fPath->isFinite()) {
         fUnparseable = true;
         return 0;
     }
     SkPath::RawIter iter(*fPath);
     SkPoint pts[4];
     SkPath::Verb verb;
     do {
         verb = iter.next(pts);
-        *fPathVerbs.append() = verb;
+        fPathVerbs.push_back(verb);
         if (verb == SkPath::kMove_Verb) {
-            *fPathPts.append() = pts[0];
+            fPathPts.push_back(pts[0]);
         } else if (verb >= SkPath::kLine_Verb && verb <= SkPath::kCubic_Verb) {
-            fPathPts.append(SkPathOpsVerbToPoints(verb), &pts[1]);
+            fPathPts.push_back_n(SkPathOpsVerbToPoints(verb), &pts[1]);
         }
     } while (verb != SkPath::kDone_Verb);
     return fPathVerbs.count() - 1;
 }
 
 bool SkOpEdgeBuilder::close() {
     if (fFinalCurveStart && fFinalCurveEnd && *fFinalCurveStart != *fFinalCurveEnd) {
-        *fReducePts.append() = *fFinalCurveStart;
-        *fReducePts.append() = *fFinalCurveEnd;
+        fReducePts.push_back(*fFinalCurveStart);
+        fReducePts.push_back(*fFinalCurveEnd);
         const SkPoint* lineStart = fReducePts.end() - 2;
-        *fExtra.append() = fCurrentContour->addLine(lineStart);
+        fExtra.push_back(fCurrentContour->addLine(lineStart));
     }
     complete();
     return true;
 }
 
 bool SkOpEdgeBuilder::walk() {
     SkPath::Verb reducedVerb;
     uint8_t* verbPtr = fPathVerbs.begin();
     uint8_t* endOfFirstHalf = &verbPtr[fSecondHalf];
     const SkPoint* pointsPtr = fPathPts.begin();
@@ skipping 11 matching lines @@
                     if (fAllowOpenContours) {
                         complete();
                     } else if (!close()) {
                         return false;
                     }
                 }
                 if (!fCurrentContour) {
                     fCurrentContour = fContours.push_back_n(1);
                     fCurrentContour->setOperand(fOperand);
                     fCurrentContour->setXor(fXorMask[fOperand] == kEvenOdd_PathOpsMask);
-                    *fExtra.append() = -1;  // start new contour
+                    fExtra.push_back(-1);  // start new contour
                 }
                 fFinalCurveEnd = pointsPtr++;
                 continue;
             case SkPath::kLine_Verb: {
                 const SkPoint& lineEnd = pointsPtr[0];
                 const SkPoint& lineStart = pointsPtr[-1];
                 // skip degenerate points
                 if (lineStart.fX != lineEnd.fX || lineStart.fY != lineEnd.fY) {
                     fCurrentContour->addLine(&lineStart);
                 }
                 } break;
             case SkPath::kQuad_Verb: {
                 const SkPoint* quadStart = &pointsPtr[-1];
                 reducedVerb = SkReduceOrder::Quad(quadStart, &fReducePts);
                 if (reducedVerb == 0) {
                     break;  // skip degenerate points
                 }
                 if (reducedVerb == SkPath::kLine_Verb) {
                     const SkPoint* lineStart = fReducePts.end() - 2;
-                   *fExtra.append() = fCurrentContour->addLine(lineStart);
+                    fExtra.push_back(fCurrentContour->addLine(lineStart));
                     break;
                 }
                 fCurrentContour->addQuad(quadStart);
                 } break;
             case SkPath::kCubic_Verb: {
                 const SkPoint* cubicStart = &pointsPtr[-1];
                 reducedVerb = SkReduceOrder::Cubic(cubicStart, &fReducePts);
                 if (reducedVerb == 0) {
                     break;  // skip degenerate points
                 }
                 if (reducedVerb == SkPath::kLine_Verb) {
                     const SkPoint* lineStart = fReducePts.end() - 2;
-                    *fExtra.append() = fCurrentContour->addLine(lineStart);
+                    fExtra.push_back(fCurrentContour->addLine(lineStart));
                     break;
                 }
                 if (reducedVerb == SkPath::kQuad_Verb) {
                     const SkPoint* quadStart = fReducePts.end() - 3;
-                    *fExtra.append() = fCurrentContour->addQuad(quadStart);
+                    fExtra.push_back(fCurrentContour->addQuad(quadStart));
                     break;
                 }
                 fCurrentContour->addCubic(cubicStart);
                 } break;
             case SkPath::kClose_Verb:
                 SkASSERT(fCurrentContour);
                 if (!close()) {
                     return false;
                 }
                 continue;
             default:
                 SkDEBUGFAIL("bad verb");
                 return false;
         }
         fFinalCurveStart = &pointsPtr[SkPathOpsVerbToPoints(verb) - 1];
         pointsPtr += SkPathOpsVerbToPoints(verb);
         SkASSERT(fCurrentContour);
     }
    if (fCurrentContour && !fAllowOpenContours && !close()) {
        return false;
    }
    return true;
 }