use reversePathTo in place of addPathReverse

src/pathops/SkOpBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "SkOpEdgeBuilder.h"
 #include "SkPathPriv.h"
 #include "SkPathOps.h"
 #include "SkPathOpsCommon.h"
 
 static bool one_contour(const SkPath& path) {
     SkChunkAlloc allocator(256);
     int verbCount = path.countVerbs();
     uint8_t* verbs = (uint8_t*) allocator.alloc(sizeof(uint8_t) * verbCount,
             SkChunkAlloc::kThrow_AllocFailType);
     (void) path.getVerbs(verbs, verbCount);
     for (int index = 1; index < verbCount; ++index) {
         if (verbs[index] == SkPath::kMove_Verb) {
             return false;
         }
     }
     return true;
 }
 
-bool FixWinding(SkPath* path) {
+void SkOpBuilder::ReversePath(SkPath* path) {
+    SkPath temp;
+    SkPoint lastPt;
+    SkAssertResult(path->getLastPt(&lastPt));
+    temp.moveTo(lastPt);
+    temp.reversePathTo(*path);
+    temp.close();
+    *path = temp;
+}
+
+bool SkOpBuilder::FixWinding(SkPath* path) {
     SkPath::FillType fillType = path->getFillType();
     if (fillType == SkPath::kInverseEvenOdd_FillType) {
         fillType = SkPath::kInverseWinding_FillType;
     } else if (fillType == SkPath::kEvenOdd_FillType) {
         fillType = SkPath::kWinding_FillType;
     }
     SkPathPriv::FirstDirection dir;
     if (one_contour(*path) && SkPathPriv::CheapComputeFirstDirection(*path, &dir)) {
         if (dir != SkPathPriv::kCCW_FirstDirection) {
-            SkPath temp;
-            temp.reverseAddPath(*path);
-            *path = temp;
+            ReversePath(path);
         }
         path->setFillType(fillType);
         return true;
     }
     SkChunkAlloc allocator(4096);
     SkOpContourHead contourHead;
     SkOpGlobalState globalState(&contourHead, &allocator  SkDEBUGPARAMS(false)
             SkDEBUGPARAMS(nullptr));
     SkOpEdgeBuilder builder(*path, &contourHead, &globalState);
     if (builder.unparseable() || !builder.finish()) {
@@ skipping 75 matching lines @@
         // If all paths are convex, track direction, reversing as needed.
         if (test->isConvex()) {
             SkPathPriv::FirstDirection dir;
             if (!SkPathPriv::CheapComputeFirstDirection(*test, &dir)) {
                 allUnion = false;
                 break;
             }
             if (firstDir == SkPathPriv::kUnknown_FirstDirection) {
                 firstDir = dir;
             } else if (firstDir != dir) {
-                SkPath temp;
-                temp.reverseAddPath(*test);
-                *test = temp;
+                ReversePath(test);
             }
             continue;
         }
         // If the path is not convex but its bounds do not intersect the others, simplify is enough.
         const SkRect& testBounds = test->getBounds();
         for (int inner = 0; inner < index; ++inner) {
             // OPTIMIZE: check to see if the contour bounds do not intersect other contour bounds?
             if (SkRect::Intersects(fPathRefs[inner].getBounds(), testBounds)) {
                 allUnion = false;
                 break;
@@ skipping 28 matching lines @@
             sum.addPath(fPathRefs[index]);
         }
     }
     reset();
     bool success = Simplify(sum, result);
     if (!success) {
         *result = original;
     }
     return success;
 }