zero-length cap fix

src/core/SkStroke.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPathPriv.h"
@@ skipping 103 matching lines @@
         return true;
    }
 };
 
 class SkPathStroker {
 public:
     SkPathStroker(const SkPath& src,
                   SkScalar radius, SkScalar miterLimit, SkPaint::Cap,
                   SkPaint::Join, SkScalar resScale);
 
+    bool hasOnlyMoveTo() const { return 0 == fSegmentCount; }
+    SkPoint moveToPt() const { return fFirstPt; }
+
     void moveTo(const SkPoint&);
     void lineTo(const SkPoint&);
     void quadTo(const SkPoint&, const SkPoint&);
     void conicTo(const SkPoint&, const SkPoint&, SkScalar weight);
     void cubicTo(const SkPoint&, const SkPoint&, const SkPoint&);
     void close(bool isLine) { this->finishContour(true, isLine); }
 
     void done(SkPath* dst, bool isLine) {
         this->finishContour(false, isLine);
         fOuter.addPath(fExtra);
@@ skipping 101 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkPathStroker::preJoinTo(const SkPoint& currPt, SkVector* normal,
                               SkVector* unitNormal, bool currIsLine) {
     SkASSERT(fSegmentCount >= 0);
 
     SkScalar    prevX = fPrevPt.fX;
     SkScalar    prevY = fPrevPt.fY;
 
     if (!set_normal_unitnormal(fPrevPt, currPt, fRadius, normal, unitNormal)) {
-        return false;
+        if (SkStrokerPriv::CapFactory(SkPaint::kButt_Cap) == fCapper) {
+            return false;
+        }
+        /* Square caps and round caps draw even if the segment length is zero.
+           Since the zero length segment has no direction, set the orientation
+           to upright as the default orientation */
+        normal->set(fRadius, 0);
+        unitNormal->set(1, 0);
     }
 
     if (fSegmentCount == 0) {
         fFirstNormal = *normal;
         fFirstUnitNormal = *unitNormal;
         fFirstOuterPt.set(prevX + normal->fX, prevY + normal->fY);
 
         fOuter.moveTo(fFirstOuterPt.fX, fFirstOuterPt.fY);
         fInner.moveTo(prevX - normal->fX, prevY - normal->fY);
     } else {    // we have a previous segment
@@ skipping 93 matching lines @@
     fSegmentCount = 0;
     fFirstPt = fPrevPt = pt;
 }
 
 void SkPathStroker::line_to(const SkPoint& currPt, const SkVector& normal) {
     fOuter.lineTo(currPt.fX + normal.fX, currPt.fY + normal.fY);
     fInner.lineTo(currPt.fX - normal.fX, currPt.fY - normal.fY);
 }
 
 void SkPathStroker::lineTo(const SkPoint& currPt) {
-    if (SkPath::IsLineDegenerate(fPrevPt, currPt, false)) {
+    if (SkStrokerPriv::CapFactory(SkPaint::kButt_Cap) == fCapper
+            && SkPath::IsLineDegenerate(fPrevPt, currPt, false)) {
         return;
     }
     SkVector    normal, unitNormal;
 
     if (!this->preJoinTo(currPt, &normal, &unitNormal, true)) {
         return;
     }
     this->line_to(currPt, normal);
     this->postJoinTo(currPt, normal, unitNormal);
 }
@@ skipping 957 matching lines @@
             case SkPath::kConic_Verb: {
                 stroker.conicTo(pts[1], pts[2], iter.conicWeight());
                 lastSegment = SkPath::kConic_Verb;
                 break;
             } break;
             case SkPath::kCubic_Verb:
                 stroker.cubicTo(pts[1], pts[2], pts[3]);
                 lastSegment = SkPath::kCubic_Verb;
                 break;
             case SkPath::kClose_Verb:
+                if (stroker.hasOnlyMoveTo() && SkPaint::kButt_Cap != this->getCap()) {
+                    /* If the stroke consists of a moveTo followed by a close, treat it
+                       as if it were followed by a zero-length line. Lines without length
+                       can have square and round end caps. */
+                    stroker.lineTo(stroker.moveToPt());
+                    lastSegment = SkPath::kLine_Verb;
+                    break;
+                }
                 stroker.close(lastSegment == SkPath::kLine_Verb);
                 break;
             case SkPath::kDone_Verb:
                 goto DONE;
         }
     }
 DONE:
     stroker.done(dst, lastSegment == SkPath::kLine_Verb);
 
     if (fDoFill) {
@@ skipping 103 matching lines @@
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
     }
 }