path ops : fix empty-diff bug, op-in-place

tests/PathOpsExtendedTest.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 "PathOpsExtendedTest.h"
 #include "PathOpsThreadedCommon.h"
 #include "SkBitmap.h"
@@ skipping 11 matching lines @@
     "\n"
     "<script type=\"text/javascript\">\n"
     "\n"
     "var testDivs = [\n";
 
 static const char* opStrs[] = {
     "kDifference_PathOp",
     "kIntersect_PathOp",
     "kUnion_PathOp",
     "kXor_PathOp",
+    "kReverseDifference_PathOp",
 };
 
 static const char* opSuffixes[] = {
     "d",
     "i",
     "u",
     "o",
 };
 
 static bool gShowPath = false;
 static bool gComparePaths = true;
 static bool gComparePathsAssert = true;
 static bool gPathStrAssert = true;
 
-static void showPathContour(SkPath::Iter& iter) {
+static void showPathContours(SkPath::Iter& iter) {
     uint8_t verb;
     SkPoint pts[4];
     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kMove_Verb:
                 SkDebugf("path.moveTo(%1.9g,%1.9g);\n", pts[0].fX, pts[0].fY);
                 continue;
             case SkPath::kLine_Verb:
                 SkDebugf("path.lineTo(%1.9g,%1.9g);\n", pts[1].fX, pts[1].fY);
                 break;
@@ skipping 13 matching lines @@
                 return;
         }
     }
 }
 
 void showPath(const SkPath& path, const char* str) {
     SkDebugf("%s\n", !str ? "original:" : str);
     showPath(path);
 }
 
+const char* fillTypeStr[] = {
+    "kWinding_FillType",
+    "kEvenOdd_FillType",
+    "kInverseWinding_FillType",
+    "kInverseEvenOdd_FillType"
+};
+
 void showPath(const SkPath& path) {
     SkPath::Iter iter(path, true);
 #define SUPPORT_RECT_CONTOUR_DETECTION 0
 #if SUPPORT_RECT_CONTOUR_DETECTION
     int rectCount = path.isRectContours() ? path.rectContours(NULL, NULL) : 0;
     if (rectCount > 0) {
         SkTDArray<SkRect> rects;
         SkTDArray<SkPath::Direction> directions;
         rects.setCount(rectCount);
         directions.setCount(rectCount);
         path.rectContours(rects.begin(), directions.begin());
         for (int contour = 0; contour < rectCount; ++contour) {
             const SkRect& rect = rects[contour];
             SkDebugf("path.addRect(%1.9g, %1.9g, %1.9g, %1.9g, %s);\n", rect.fLeft, rect.fTop,
                     rect.fRight, rect.fBottom, directions[contour] == SkPath::kCCW_Direction
                     ? "SkPath::kCCW_Direction" : "SkPath::kCW_Direction");
         }
         return;
     }
 #endif
+    SkPath::FillType fillType = path.getFillType();
+    SkASSERT(fillType >= SkPath::kWinding_FillType && fillType <= SkPath::kInverseEvenOdd_FillType);
+    SkDebugf("path.setFillType(%s);\n", fillTypeStr[fillType]);
     iter.setPath(path, true);
-    showPathContour(iter);
+    showPathContours(iter);
 }
 
 void showPathData(const SkPath& path) {
     SkPath::Iter iter(path, true);
     uint8_t verb;
     SkPoint pts[4];
     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kMove_Verb:
                 continue;
@@ skipping 26 matching lines @@
             break;
         case kIntersect_PathOp:
             SkDebugf("op intersect\n");
             break;
         case kUnion_PathOp:
             SkDebugf("op union\n");
             break;
         case kXOR_PathOp:
             SkDebugf("op xor\n");
             break;
+        case kReverseDifference_PathOp:
+            SkDebugf("op reverse difference\n");
+            break;
         default:
             SkASSERT(0);
     }
 }
 
 static void showPath(const SkPath& path, const char* str, const SkMatrix& scale) {
     SkPath scaled;
     SkMatrix inverse;
     bool success = scale.invert(&inverse);
     if (!success) {
@@ skipping 191 matching lines @@
     drawAsciiPaths(scaledOne, scaledTwo, true);
 }
 
 static int comparePaths(skiatest::Reporter* reporter, const SkPath& one, const SkPath& scaledOne,
                         const SkPath& two, const SkPath& scaledTwo, SkBitmap& bitmap,
                         const SkPath& a, const SkPath& b, const SkPathOp shapeOp,
                         const SkMatrix& scale) {
     int errors2x2;
     int errors = pathsDrawTheSame(bitmap, scaledOne, scaledTwo, errors2x2);
     if (errors2x2 == 0) {
+        if (gShowPath) {
+            showPathOpPath(one, two, a, b, scaledOne, scaledTwo, shapeOp, scale);
+        }
         return 0;
     }
     const int MAX_ERRORS = 8;
-    if (errors2x2 == MAX_ERRORS || errors2x2 == MAX_ERRORS - 1) {
+    if (gShowPath || errors2x2 == MAX_ERRORS || errors2x2 == MAX_ERRORS - 1) {
         showPathOpPath(one, two, a, b, scaledOne, scaledTwo, shapeOp, scale);
     }
     if (errors2x2 > MAX_ERRORS && gComparePathsAssert) {
         SkDebugf("%s errors=%d\n", __FUNCTION__, errors);
         showPathOpPath(one, two, a, b, scaledOne, scaledTwo, shapeOp, scale);
         REPORTER_ASSERT(reporter, 0);
     }
     return errors2x2 > MAX_ERRORS ? errors2x2 : 0;
 }
 
@@ skipping 211 matching lines @@
         }
         if (tests[index].fun == stopTest) {
             SkDebugf("lastTest\n");
         }
         if (index == last) {
             break;
         }
         index += reverse ? -1 : 1;
     } while (true);
 }