Add control over whether lines are special cased in SkDashPath. Disable when called from GrShape.

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 307 matching lines @@
             REPORTER_ASSERT(r, rrectA == rrectB);
             REPORTER_ASSERT(r, dirA == dirB);
             REPORTER_ASSERT(r, startA == startB);
             REPORTER_ASSERT(r, ignoreInversenessDifference || invertedA == invertedB);
         }
     }
     REPORTER_ASSERT(r, a.isEmpty() == b.isEmpty());
     REPORTER_ASSERT(r, a.knownToBeClosed() == b.knownToBeClosed());
     REPORTER_ASSERT(r, a.bounds() == b.bounds());
     REPORTER_ASSERT(r, a.segmentMask() == b.segmentMask());
+    SkPoint pts[4];
+    REPORTER_ASSERT(r, a.asLine(pts) == b.asLine(pts + 2));
+    if (a.asLine(pts)) {
+        REPORTER_ASSERT(r, pts[2] == pts[0] && pts[3] == pts[1]);
+    }
 }
 
 void TestCase::compare(skiatest::Reporter* r, const TestCase& that,
                        ComparisonExpecation expectation) const {
     SkPath a, b;
     switch (expectation) {
         case kAllDifferent_ComparisonExpecation:
             REPORTER_ASSERT(r, fBaseKey != that.fBaseKey);
             REPORTER_ASSERT(r, fAppliedPEKey != that.fAppliedPEKey);
             REPORTER_ASSERT(r, fAppliedFullKey != that.fAppliedFullKey);
@@ skipping 924 matching lines @@
                 reporter, r,
                 [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
                 SkPaint::kMiter_Join, SkPaint::kRound_Join);
         test_stroke_cap(reporter, r);
         test_miter_limit(reporter, r);
         test_path_effect_makes_rrect(reporter, r);
         test_unknown_path_effect(reporter, r);
         test_path_effect_makes_empty_shape(reporter, r);
         test_path_effect_fails(reporter, r);
         test_make_hairline_path_effect(reporter, r, true);
+        GrShape shape(r);
+        REPORTER_ASSERT(reporter, !shape.asLine(nullptr));
     }
 
     for (auto rr : { SkRRect::MakeRect(SkRect::MakeWH(10, 10)),
                      SkRRect::MakeRectXY(SkRect::MakeWH(10, 10), 3, 4),
                      SkRRect::MakeOval(SkRect::MakeWH(20, 20))}) {
         test_basic(reporter, rr);
         test_rrect(reporter, rr);
         test_scale(reporter, rr);
         test_dash_fill(reporter, rr);
         test_null_dash(reporter, rr);
         // Test modifying various stroke params.
         test_stroke_param<SkRRect, SkScalar>(
                           reporter, rr,
                           [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);},
                           SkIntToScalar(2), SkIntToScalar(4));
         test_stroke_param<SkRRect, SkPaint::Join>(
                           reporter, rr,
                           [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
                           SkPaint::kMiter_Join, SkPaint::kRound_Join);
         test_stroke_cap(reporter, rr);
         test_miter_limit(reporter, rr);
         test_path_effect_makes_rrect(reporter, rr);
         test_unknown_path_effect(reporter, rr);
         test_path_effect_makes_empty_shape(reporter, rr);
         test_path_effect_fails(reporter, rr);
         test_make_hairline_path_effect(reporter, rr, true);
+        GrShape shape(rr);
+        REPORTER_ASSERT(reporter, !shape.asLine(nullptr));
     }
 
     struct TestPath {
-        TestPath(const SkPath& path, bool isRRectFill, bool isRRectStroke, const SkRRect& rrect)
+        TestPath(const SkPath& path, bool isRRectFill, bool isRRectStroke, bool isLine, const SkRRect& rrect)
             : fPath(path)
             , fIsRRectForFill(isRRectFill)
             , fIsRRectForStroke(isRRectStroke)
+            , fIsLine(isLine)
             , fRRect(rrect) {}
         SkPath  fPath;
         bool    fIsRRectForFill;
         bool    fIsRRectForStroke;
+        bool    fIsLine;
         SkRRect fRRect;
     };
     SkTArray<TestPath> paths;
 
     SkPath circlePath;
     circlePath.addCircle(10, 10, 10);
-    paths.emplace_back(circlePath, true, true, SkRRect::MakeOval(SkRect::MakeWH(20,20)));
+    paths.emplace_back(circlePath, true, true, false, SkRRect::MakeOval(SkRect::MakeWH(20,20)));
 
     SkPath rectPath;
     rectPath.addRect(SkRect::MakeWH(10, 10));
-    paths.emplace_back(rectPath, true, true, SkRRect::MakeRect(SkRect::MakeWH(10, 10)));
+    paths.emplace_back(rectPath, true, true, false, SkRRect::MakeRect(SkRect::MakeWH(10, 10)));
 
     SkPath openRectPath;
     openRectPath.moveTo(0, 0);
     openRectPath.lineTo(10, 0);
     openRectPath.lineTo(10, 10);
     openRectPath.lineTo(0, 10);
-    paths.emplace_back(openRectPath, true, false, SkRRect::MakeRect(SkRect::MakeWH(10, 10)));
+    paths.emplace_back(openRectPath, true, false, false, SkRRect::MakeRect(SkRect::MakeWH(10, 10)));
 
     SkPath quadPath;
     quadPath.quadTo(10, 10, 5, 8);
-    paths.emplace_back(quadPath, false, false, SkRRect());
+    paths.emplace_back(quadPath, false, false, false, SkRRect());
+
+    SkPath linePath;
+    linePath.lineTo(10, 10);
+    paths.emplace_back(linePath, false, false, true, SkRRect());
 
     for (auto testPath : paths) {
         for (bool inverseFill : {false, true}) {
             if (inverseFill) {
                 if (testPath.fPath.getFillType() == SkPath::kEvenOdd_FillType) {
                     testPath.fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
                 } else {
                     SkASSERT(testPath.fPath.getFillType() == SkPath::kWinding_FillType);
                     testPath.fPath.setFillType(SkPath::kInverseWinding_FillType);
                 }
@@ skipping 51 matching lines @@
         TestCase strokePathCase(path, strokePaint, reporter);
         REPORTER_ASSERT(reporter, testPath.fIsRRectForStroke ==
                                   strokePathCase.baseShape().asRRect(&rrect, nullptr, nullptr,
                                                                      nullptr));
         if (testPath.fIsRRectForStroke) {
             REPORTER_ASSERT(reporter, rrect == testPath.fRRect);
             TestCase strokeRRectCase(rrect, strokePaint, reporter);
             strokePathCase.compare(reporter, strokeRRectCase,
                                    TestCase::kAllSame_ComparisonExpecation);
         }
+        REPORTER_ASSERT(reporter, testPath.fIsLine == fillPathCase.baseShape().asLine(nullptr));
+        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