Make wavy underlines go all the way to the end of the inline.

sky/engine/core/rendering/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 23 matching lines @@
 #include "sky/engine/core/editing/InputMethodController.h"
 #include "sky/engine/core/frame/LocalFrame.h"
 #include "sky/engine/core/frame/Settings.h"
 #include "sky/engine/core/page/Page.h"
 #include "sky/engine/core/rendering/EllipsisBox.h"
 #include "sky/engine/core/rendering/HitTestResult.h"
 #include "sky/engine/core/rendering/PaintInfo.h"
 #include "sky/engine/core/rendering/RenderBlock.h"
 #include "sky/engine/core/rendering/RenderTheme.h"
 #include "sky/engine/core/rendering/style/ShadowList.h"
+#include "sky/engine/platform/animation/UnitBezier.h"
 #include "sky/engine/platform/fonts/FontCache.h"
 #include "sky/engine/platform/fonts/GlyphBuffer.h"
 #include "sky/engine/platform/fonts/WidthIterator.h"
 #include "sky/engine/platform/graphics/GraphicsContextStateSaver.h"
 #include "sky/engine/wtf/Vector.h"
 #include "sky/engine/wtf/text/CString.h"
 #include "sky/engine/wtf/text/StringBuilder.h"
 
 #include <algorithm>
 
@@ skipping 717 matching lines @@
         if (offset > 0)
             return inlineTextBox->logicalHeight() + gap + offset;
         return inlineTextBox->logicalHeight() + gap;
     }
     }
 
     ASSERT_NOT_REACHED();
     return fontMetrics.ascent() + gap;
 }
 
-static void adjustStepToDecorationLength(float& step, float& controlPointDistance, float length)
-{
-    ASSERT(step > 0);
-
-    if (length <= 0)
-        return;
-
-    unsigned stepCount = static_cast<unsigned>(length / step);
-
-    // Each Bezier curve starts at the same pixel that the previous one
-    // ended. We need to subtract (stepCount - 1) pixels when calculating the
-    // length covered to account for that.
-    float uncoveredLength = length - (stepCount * step - (stepCount - 1));
-    float adjustment = uncoveredLength / stepCount;
-    step += adjustment;
-    controlPointDistance += adjustment;
-}
-
 struct CurveAlongX {
   static inline float x(const FloatPoint& p) { return p.x(); }
   static inline float y(const FloatPoint& p) { return p.y(); }
   static inline FloatPoint p(float x, float y) { return FloatPoint(x, y); }
   static inline void setX(FloatPoint& p, double x) { p.setX(x); }
 };
 
 struct CurveAlongY {
   static inline float x(const FloatPoint& p) { return p.y(); }
   static inline float y(const FloatPoint& p) { return p.x(); }
@@ skipping 53 matching lines @@
     float x2;
 
     if (Curve::x(p1) < Curve::x(p2)) {
         x1 = Curve::x(p1);
         x2 = Curve::x(p2);
     } else {
         x1 = Curve::x(p2);
         x2 = Curve::x(p1);
     }
 
-    adjustStepToDecorationLength(step, controlPointDistance, x2 - x1);
-
     FloatPoint controlPoint1 = Curve::p(0, yAxis + controlPointDistance);
     FloatPoint controlPoint2 = Curve::p(0, yAxis - controlPointDistance);
 
-    for (float x = x1; x + 2 * step <= x2;) {
+    float x;
+    for (x = x1; x + 2 * step <= x2;) {
         Curve::setX(controlPoint1, x + step);
         Curve::setX(controlPoint2, x + step);
         x += 2 * step;
         path.addBezierCurveTo(controlPoint1, controlPoint2, Curve::p(x, yAxis));
     }
 
+    if (x < x2) {
+      Curve::setX(controlPoint1, x + step);
+      Curve::setX(controlPoint2, x + step);
+      float xScale = 1.0 / (2 * step);
+      float yScale = 1.0 / (2 * controlPointDistance);
+      OwnPtr<UnitBezier> bezier = adoptPtr(new UnitBezier((Curve::x(controlPoint1) - x) * xScale,

[eseidel, 2015/06/22 22:10:02]

How hot is this?  Do we care that you're mallocing here?

+                                                          (Curve::y(controlPoint1) - yAxis) * yScale,
+                                                          (Curve::x(controlPoint2) - x) * xScale,
+                                                          (Curve::y(controlPoint2) - yAxis) * yScale));
+      float t = bezier->solveCurveX((x2 - x) / (2.0 * step), std::numeric_limits<double>::epsilon());
+      // following math based on http://stackoverflow.com/a/879213
+      float u1 = 1.0 - t;
+      float qxb =  x*u1*u1 + Curve::x(controlPoint1)*2*t*u1 + Curve::x(controlPoint2)*t*t;

[eseidel, 2015/06/22 22:10:02]

Spaces?

+      float qxd = Curve::x(controlPoint1)*u1*u1 + Curve::x(controlPoint2)*2*t*u1 + (x+step)*t*t;
+      float qyb =  yAxis*u1*u1 + Curve::y(controlPoint1)*2*t*u1 + Curve::y(controlPoint2)*t*t;
+      float qyd = Curve::y(controlPoint1)*u1*u1 + Curve::y(controlPoint2)*2*t*u1 + yAxis*t*t;
+      float xb = x*u1 + Curve::x(controlPoint1)*t;
+      float yb = yAxis*u1 + Curve::y(controlPoint1)*t;
+      float xc = qxb;
+      float xd = qxb*u1 + qxd*t;
+      float yc = qyb;
+      float yd = qyb*u1 + qyd*t;
+      path.addBezierCurveTo(Curve::p(xb, yb), Curve::p(xc, yc), Curve::p(xd, yd));
+    }
+
     context->setShouldAntialias(true);
     context->strokePath(path);
 }
 
 static void strokeWavyTextDecoration(GraphicsContext* context, FloatPoint p1, FloatPoint p2, float strokeThickness)
 {
     if (p1.y() == p2.y()) // horizontal line
       strokeWavyTextDecorationInternal<CurveAlongX>(context, p1, p2, strokeThickness);
     else // vertical line
       strokeWavyTextDecorationInternal<CurveAlongY>(context, p1, p2, strokeThickness);
@@ skipping 434 matching lines @@
     printedCharacters = fprintf(stderr, "\t%s %p", obj.renderName(), &obj);
     const int rendererCharacterOffset = 24;
     for (; printedCharacters < rendererCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
 }
 
 #endif
 
 } // namespace blink