fix the error that path is inversed for stroke and strokeAndFill styles

tests/EmptyPathTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkPath.h"
 #include "Test.h"
@@ skipping 36 matching lines @@
         }
         ERRORF(reporter, "%s style[%d] cap[%d] join[%d] antialias[%d]"
                " filltype[%d] ptcount[%d]", str, paint.getStyle(),
                paint.getStrokeCap(), paint.getStrokeJoin(),
                paint.isAntiAlias(), path.getFillType(), path.countPoints());
 // uncomment this if you want to step in to see the failure
 //        canvas.drawPath(path, p);
     }
 }
 
-static void iter_paint(skiatest::Reporter* reporter, const SkPath& path, bool shouldDraw) {
+static void iter_paint(skiatest::Reporter* reporter, const SkPath& path) {
     static const SkPaint::Cap gCaps[] = {
         SkPaint::kButt_Cap,
         SkPaint::kRound_Cap,
         SkPaint::kSquare_Cap
     };
     static const SkPaint::Join gJoins[] = {
         SkPaint::kMiter_Join,
         SkPaint::kRound_Join,
         SkPaint::kBevel_Join
     };
     static const SkPaint::Style gStyles[] = {
         SkPaint::kFill_Style,
         SkPaint::kStroke_Style,
         SkPaint::kStrokeAndFill_Style
     };
     for (size_t cap = 0; cap < SK_ARRAY_COUNT(gCaps); ++cap) {
         for (size_t join = 0; join < SK_ARRAY_COUNT(gJoins); ++join) {
             for (size_t style = 0; style < SK_ARRAY_COUNT(gStyles); ++style) {
                 SkPaint paint;
                 paint.setStrokeWidth(SkIntToScalar(10));
 
                 paint.setStrokeCap(gCaps[cap]);
                 paint.setStrokeJoin(gJoins[join]);
                 paint.setStyle(gStyles[style]);
 
+                bool shouldDraw = path.isInverseFillType() &&
+                                  SkPaint::kFill_Style == paint.getStyle();
                 paint.setAntiAlias(false);
                 drawAndTest(reporter, path, paint, shouldDraw);
                 paint.setAntiAlias(true);
                 drawAndTest(reporter, path, paint, shouldDraw);
             }
         }
     }
 }
 
 #define CX  (SkIntToScalar(DIMENSION) / 2)
 #define CY  (SkIntToScalar(DIMENSION) / 2)
 
 static void make_empty(SkPath*) {}
 static void make_M(SkPath* path) { path->moveTo(CX, CY); }
 static void make_MM(SkPath* path) { path->moveTo(CX, CY); path->moveTo(CX, CY); }
 static void make_MZM(SkPath* path) { path->moveTo(CX, CY); path->close(); path->moveTo(CX, CY); }
 static void make_L(SkPath* path) { path->moveTo(CX, CY); path->lineTo(CX, CY); }
 static void make_Q(SkPath* path) { path->moveTo(CX, CY); path->quadTo(CX, CY, CX, CY); }
 static void make_C(SkPath* path) { path->moveTo(CX, CY); path->cubicTo(CX, CY, CX, CY, CX, CY); }
 
 /*  Two invariants are tested: How does an empty/degenerate path draw?
- *  - if the path is drawn inverse, it should draw everywhere
+ *  - if the path is drawn inverse, it should draw everywhere for fill style,
+ *    but draw nowhere for other styles.
  *  - if the path is drawn non-inverse, it should draw nowhere
  *
  *  Things to iterate on:
  *  - path (empty, degenerate line/quad/cubic w/ and w/o close
  *  - paint style
  *  - path filltype
  *  - path stroke variants (e.g. caps, joins, width)
  */
 static void test_emptydrawing(skiatest::Reporter* reporter) {
     static void (*gMakeProc[])(SkPath*) = {
         make_empty, make_M, make_MM, make_MZM, make_L, make_Q, make_C
     };
     static SkPath::FillType gFills[] = {
         SkPath::kWinding_FillType,
         SkPath::kEvenOdd_FillType,
         SkPath::kInverseWinding_FillType,
         SkPath::kInverseEvenOdd_FillType
     };
     for (int doClose = 0; doClose < 2; ++doClose) {
         for  (size_t i = 0; i < SK_ARRAY_COUNT(gMakeProc); ++i) {
             SkPath path;
             gMakeProc[i](&path);
             if (doClose) {
                 path.close();
             }
             for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) {
                 path.setFillType(gFills[fill]);
-                bool shouldDraw = path.isInverseFillType();
-                iter_paint(reporter, path, shouldDraw);
+                iter_paint(reporter, path);
             }
         }
     }
 }
 
 DEF_TEST(EmptyPath, reporter) {
     test_emptydrawing(reporter);
 }