Fix Rob's nits from https://codereview.chromium.org/2085913003

tests/GrShapeTest.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <initializer_list>
 #include <functional>
 #include "Test.h"
@@ skipping 245 matching lines @@
         fAppliedPE.asPath(&b);
         REPORTER_ASSERT(reporter, a == b);
         if (expectations.fStrokeApplies) {
             REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey);
         } else {
             REPORTER_ASSERT(reporter, fBaseKey == fAppliedFullKey);
         }
     }
 }
 
-void check_equivalence(skiatest::Reporter* r, const GrShape& a, const GrShape& b,
-                       const Key& keyA, const Key& keyB) {
+static bool can_interchange_winding_and_even_odd_fill(const GrShape& shape) {
+    SkPath path;
+    shape.asPath(&path);
+    if (shape.style().hasNonDashPathEffect()) {
+        return false;
+    }
+    const SkStrokeRec::Style strokeRecStyle = shape.style().strokeRec().getStyle();
+    return strokeRecStyle == SkStrokeRec::kStroke_Style ||
+           strokeRecStyle == SkStrokeRec::kHairline_Style ||
+           (shape.style().isSimpleFill() && path.isConvex());
+}
+
+static void check_equivalence(skiatest::Reporter* r, const GrShape& a, const GrShape& b,
+                              const Key& keyA, const Key& keyB) {
     // GrShape only respects the input winding direction and start point for rrect shapes
     // when there is a path effect. Thus, if there are two GrShapes representing the same rrect
     // but one has a path effect in its style and the other doesn't then asPath() and the unstyled
     // key will differ. GrShape will have canonicalized the direction and start point for the shape
     // without the path effect. If *both* have path effects then they should have both preserved
     // the direction and starting point.
 
     // The asRRect() output params are all initialized just to silence compiler warnings about
     // uninitialized variables.
     SkRRect rrectA = SkRRect::MakeEmpty(), rrectB = SkRRect::MakeEmpty();
@@ skipping 17 matching lines @@
     if (pathA.isInverseFillType() != pathB.isInverseFillType()) {
         const GrShape* s1 = pathA.isInverseFillType() ? &a : &b;
         const GrShape* s2 = pathA.isInverseFillType() ? &b : &a;
         bool canDropInverse1 = s1->style().isDashed();
         bool canDropInverse2 = s2->style().isDashed();
         ignoreInversenessDifference = (canDropInverse1 != canDropInverse2);
     }
     bool ignoreWindingVsEvenOdd = false;
     if (SkPath::ConvertToNonInverseFillType(pathA.getFillType()) !=
         SkPath::ConvertToNonInverseFillType(pathB.getFillType())) {
-        const SkStrokeRec::Style  strokeRecStyleA = a.style().strokeRec().getStyle();
-        const SkStrokeRec::Style  strokeRecStyleB = b.style().strokeRec().getStyle();
-        bool aCanChange = !a.style().hasNonDashPathEffect() &&
-                          (strokeRecStyleA == SkStrokeRec::kStroke_Style ||
-                           strokeRecStyleA == SkStrokeRec::kHairline_Style ||
-                           (a.style().isSimpleFill() && pathA.isConvex()));
-        bool bCanChange = !b.style().hasNonDashPathEffect() &&
-                          (strokeRecStyleB == SkStrokeRec::kStroke_Style ||
-                           strokeRecStyleB == SkStrokeRec::kHairline_Style ||
-                           (b.style().isSimpleFill() && pathB.isConvex()));
+        bool aCanChange = can_interchange_winding_and_even_odd_fill(a);
+        bool bCanChange = can_interchange_winding_and_even_odd_fill(b);
         if (aCanChange != bCanChange) {
             ignoreWindingVsEvenOdd = true;
         }
     }
     if (allowSameRRectButDiffStartAndDir) {
         REPORTER_ASSERT(r, rrectA == rrectB);
         REPORTER_ASSERT(r, paths_fill_same(pathA, pathB));
         REPORTER_ASSERT(r, ignoreInversenessDifference || invertedA == invertedB);
     } else {
         SkPath pA = pathA;
@@ skipping 1170 matching lines @@
         REPORTER_ASSERT(reporter, testPath.fIsLine == strokePathCase.baseShape().asLine(nullptr));
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif