cumulative pathops patch

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 "SkPath.h"
 #include "SkPathOps.h"
 
 void SkOpBuilder::add(const SkPath& path, SkPathOp op) {
-    if (0 == fOps.count() && op != kUnion_PathOp) {
+    if (0 == fOps.count() && op != kUnion_SkPathOp) {
         fPathRefs.push_back() = SkPath();
-        *fOps.append() = kUnion_PathOp;
+        *fOps.append() = kUnion_SkPathOp;
     }
     fPathRefs.push_back() = path;
     *fOps.append() = op;
 }
 
 void SkOpBuilder::reset() {
     fPathRefs.reset();
     fOps.reset();
 }
 
 /* OPTIMIZATION: Union doesn't need to be all-or-nothing. A run of three or more convex
    paths with union ops could be locally resolved and still improve over doing the
    ops one at a time. */
 bool SkOpBuilder::resolve(SkPath* result) {
     int count = fOps.count();
     bool allUnion = true;
     SkPath::Direction firstDir;
     for (int index = 0; index < count; ++index) {
         SkPath* test = &fPathRefs[index];
-        if (kUnion_PathOp != fOps[index] || test->isInverseFillType()) {
+        if (kUnion_SkPathOp != fOps[index] || test->isInverseFillType()) {
             allUnion = false;
             break;
         }
         // If all paths are convex, track direction, reversing as needed.
         if (test->isConvex()) {
             SkPath::Direction dir;
             if (!test->cheapComputeDirection(&dir)) {
                 allUnion = false;
                 break;
             }
@@ skipping 31 matching lines @@
     for (int index = 0; index < count; ++index) {
         if (!Simplify(fPathRefs[index], &fPathRefs[index])) {
             reset();
             return false;
         }
         sum.addPath(fPathRefs[index]);
     }
     reset();
     return Simplify(sum, result);
 }