Improve dashed line drawing

third_party/WebKit/Source/platform/graphics/StrokeData.cpp

 // Copyright (C) 2013 Google Inc. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //    * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //    * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
@@ skipping 16 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "platform/graphics/StrokeData.h"
 #include "platform/graphics/paint/PaintFlags.h"
 #include "third_party/skia/include/effects/SkDashPathEffect.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
-static const int dashRatio = 3;  // Ratio of the length of a dash to its width.
-
 void StrokeData::setLineDash(const DashArray& dashes, float dashOffset) {
   // FIXME: This is lifted directly off SkiaSupport, lines 49-74
   // so it is not guaranteed to work correctly.
   size_t dashLength = dashes.size();
   if (!dashLength) {
     // If no dash is set, revert to solid stroke
     // FIXME: do we need to set NoStroke in some cases?
     m_style = SolidStroke;
     m_dash.reset();
     return;
@@ skipping 12 matching lines @@
   flags->setStyle(PaintFlags::kStroke_Style);
   flags->setStrokeWidth(SkFloatToScalar(m_thickness));
   flags->setStrokeCap(m_lineCap);
   flags->setStrokeJoin(m_lineJoin);
   flags->setStrokeMiter(SkFloatToScalar(m_miterLimit));
 
   setupPaintDashPathEffect(flags, length);
 }
 
 void StrokeData::setupPaintDashPathEffect(PaintFlags* flags, int length) const {
+  static float epsilon = 1.0e-2f;

[f(malita), 2017/03/08 16:51:56]

nit: can we leave this close to its only user, and make constexpr?

[Stephen Chennney, 2017/03/08 17:33:26]

Yes, I should revert that back to where it was before and make it constexpr.

   if (m_dash) {
     flags->setPathEffect(m_dash);
   } else if (strokeIsDashed(m_thickness, m_style)) {
-    float width =
-        m_style == DashedStroke ? dashRatio * m_thickness : m_thickness;
-
-    // Truncate the width, since we don't want fuzzy dots or dashes.
-    int dashLength = static_cast<int>(width);
-    // Subtract off the endcaps, since they're rendered separately.
-    int distance = length - 2 * static_cast<int>(m_thickness);
-    int phase = 1;
-    if (dashLength > 1) {
-      // Determine how many dashes or dots we should have.
-      int numDashes = distance / dashLength;
-      int remainder = distance % dashLength;
-      // Adjust the phase to center the dashes within the line.
-      if (numDashes % 2) {
-        // Odd: shift right a full dash, minus half the remainder.
-        phase = dashLength - remainder / 2;
-      } else {
-        // Even: shift right half a dash, minus half the remainder.
-        phase = (dashLength - remainder) / 2;
+    float dashLength = m_thickness;
+    float gapLength = dashLength;
+    if (m_style == DashedStroke) {
+      dashLength *= StrokeData::dashLengthRatio(m_thickness);
+      gapLength *= StrokeData::dashGapRatio(m_thickness);
+    }
+    float perDashLength = dashLength + gapLength;
+    // Account for modification to effective length in
+    // GraphicsContext::adjustLineToPixelBoundaries
+    length -= 2 * m_thickness;
+    if (length <= dashLength) {
+      // No space for dashes
+      flags->setPathEffect(0);
+    } else if (length <= 2 * dashLength + gapLength) {
+      // Exactly 2 dashes proportionally sized
+      float multiplier = length / (2 * dashLength + gapLength);
+      SkScalar intervals[2] = {dashLength * multiplier, gapLength * multiplier};
+      flags->setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
+    } else {
+      float gap = gapLength;
+      if (m_style == DashedStroke) {
+        // Determine what number of dashes gives the minimum deviation from
+        // idealGap between dashes. Set the gap to that width.
+        float minNumDashes = floorf((length + gapLength) / perDashLength);
+        float maxNumDashes = minNumDashes + 1;
+        float minGap =
+            (length - minNumDashes * dashLength) / (minNumDashes - 1);
+        float maxGap =
+            (length - maxNumDashes * dashLength) / (maxNumDashes - 1);
+        gap = fabs(minGap - gapLength) < fabs(maxGap - gapLength) ? minGap
+                                                                  : maxGap;
       }
+      SkScalar intervals[2] = {dashLength, gap};
+      flags->setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
     }
-    SkScalar dashLengthSk = SkIntToScalar(dashLength);
-    SkScalar intervals[2] = {dashLengthSk, dashLengthSk};
-    flags->setPathEffect(
-        SkDashPathEffect::Make(intervals, 2, SkIntToScalar(phase)));
   } else if (m_style == DottedStroke) {
     flags->setStrokeCap((PaintFlags::Cap)RoundCap);
     // Adjust the width to get equal dot spacing as much as possible.
     float perDotLength = m_thickness * 2;
-    static float epsilon = 1.0e-2f;
     if (length < perDotLength + m_thickness) {
       // Exactly 2 dots with whatever space we can get
       SkScalar intervals[2] = {0, length - m_thickness - epsilon};
       flags->setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
       return;
     }
 
     // Determine what number of dots gives the minimum deviation from
     // idealGap between dots. Set the gap to that width.
     float minNumDots = floorf((length + m_thickness) / perDotLength);
@@ skipping 11 matching lines @@
     // TODO(schenney): WavyStroke https://crbug.com/229574
     flags->setPathEffect(0);
   }
 }
 
 bool StrokeData::strokeIsDashed(float width, StrokeStyle style) {
   return style == DashedStroke || (style == DottedStroke && width <= 3);
 }
 
 }  // namespace blink