Turn on wavy underlines. The waves aren't very pretty yet (they are too short somehow), I'll fix th…

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 778 matching lines @@
 
     // 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 y(FloatPoint p) { return p.y(); }
+  static inline float x(FloatPoint p) { return p.x(); }
+  static inline FloatPoint p(float x, float y) { return FloatPoint(x, y); }
+  static inline void setX(FloatPoint& p, double x) { p.setX(x); }

[abarth-chromium, 2015/06/19 23:00:46]

const FloatPoint& for y, x, and setX.

(Also, I would put x before y.)

+};
+
+struct CurveAlongY {
+  static inline float y(FloatPoint p) { return p.x(); }
+  static inline float x(FloatPoint p) { return p.y(); }
+  static inline FloatPoint p(float x, float y) { return FloatPoint(y, x); }
+  static inline void setX(FloatPoint& p, double x) { p.setY(x); }

[abarth-chromium, 2015/06/19 23:00:45]

ditto

+};
+
 /*
- * Draw one cubic Bezier curve and repeat the same pattern long the the decoration's axis.
- * The start point (p1), controlPoint1, controlPoint2 and end point (p2) of the Bezier curve
- * form a diamond shape:
+ * Draw one cubic Bezier curve and repeat the same pattern along the
+ * the decoration's axis. The start point (p1), controlPoint1,
+ * controlPoint2 and end point (p2) of the Bezier curve form a diamond
+ * shape, as follows (the four points marked +):
  *
  *                              step
  *                         |-----------|
  *
  *                   controlPoint1
  *                         +
  *
  *
  *                  . .
  *                .     .
  *              .         .
  * (x1, y1) p1 +           .            + p2 (x2, y2) - <--- Decoration's axis
  *                          .         .               |
  *                            .     .                 |
  *                              . .                   | controlPointDistance
  *                                                    |
  *                                                    |
  *                         +                          -
  *                   controlPoint2
  *
  *             |-----------|
  *                 step
+ *
+ * strokeWavyTextDecorationInternal() takes two points, p1 and p2.
+ * These must be axis-aligned. If they are horizontally-aligned,
+ * specialize it with CurveAlongX; if they are vertically aligned,
+ * specialize it with CurveAlongY. The function is written as if it
+ * was doing everything along the X axis; CurveAlongY just flips the
+ * coordinates around.
  */
-static void strokeWavyTextDecoration(GraphicsContext* context, FloatPoint p1, FloatPoint p2, float strokeThickness)
+template <class T> static void strokeWavyTextDecorationInternal(GraphicsContext* context, FloatPoint p1, FloatPoint p2, float strokeThickness) 

[abarth-chromium, 2015/06/19 23:00:45]

s/T/Curve/ for readability.

 {
+    ASSERT(T::y(p1) == T::y(p2)); // verify that this is indeed axis-aligned
+
     context->adjustLineToPixelBoundaries(p1, p2, strokeThickness, context->strokeStyle());
 
     Path path;
     path.moveTo(p1);
 
-    // Distance between decoration's axis and Bezier curve's control points.
-    // The height of the curve is based on this distance. Use a minimum of 6 pixels distance since
-    // the actual curve passes approximately at half of that distance, that is 3 pixels.
-    // The minimum height of the curve is also approximately 3 pixels. Increases the curve's height
-    // as strockThickness increases to make the curve looks better.
-    float controlPointDistance = 3 * std::max<float>(2, strokeThickness);
+    float controlPointDistance = 2 * strokeThickness;
+    float step = controlPointDistance;
 
-    // Increment used to form the diamond shape between start point (p1), control
-    // points and end point (p2) along the axis of the decoration. Makes the
-    // curve wider as strockThickness increases to make the curve looks better.
-    float step = 2 * std::max<float>(2, strokeThickness);
+    float yAxis = T::y(p1);
+    float x1;
+    float x2;
 
-    bool isVerticalLine = (p1.x() == p2.x());
+    if (T::x(p1) < T::x(p2)) {
+        x1 = T::x(p1);
+        x2 = T::x(p2);

[abarth-chromium, 2015/06/19 23:00:45]

Should we give these more semantic names, like |main| and |cross| ?

+    } else {
+        x1 = T::x(p2);
+        x2 = T::x(p1);
+    }
 
-    if (isVerticalLine) {
-        ASSERT(p1.x() == p2.x());
+    adjustStepToDecorationLength(step, controlPointDistance, x2 - x1);
 
-        float xAxis = p1.x();
-        float y1;
-        float y2;
+    FloatPoint controlPoint1 = T::p(0, yAxis + controlPointDistance);
+    FloatPoint controlPoint2 = T::p(0, yAxis - controlPointDistance);
 
-        if (p1.y() < p2.y()) {
-            y1 = p1.y();
-            y2 = p2.y();
-        } else {
-            y1 = p2.y();
-            y2 = p1.y();
-        }
-
-        adjustStepToDecorationLength(step, controlPointDistance, y2 - y1);
-        FloatPoint controlPoint1(xAxis + controlPointDistance, 0);
-        FloatPoint controlPoint2(xAxis - controlPointDistance, 0);
-
-        for (float y = y1; y + 2 * step <= y2;) {
-            controlPoint1.setY(y + step);
-            controlPoint2.setY(y + step);
-            y += 2 * step;
-            path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(xAxis, y));
-        }
-    } else {
-        ASSERT(p1.y() == p2.y());
-
-        float yAxis = p1.y();
-        float x1;
-        float x2;
-
-        if (p1.x() < p2.x()) {
-            x1 = p1.x();
-            x2 = p2.x();
-        } else {
-            x1 = p2.x();
-            x2 = p1.x();
-        }
-
-        adjustStepToDecorationLength(step, controlPointDistance, x2 - x1);
-        FloatPoint controlPoint1(0, yAxis + controlPointDistance);
-        FloatPoint controlPoint2(0, yAxis - controlPointDistance);
-
-        for (float x = x1; x + 2 * step <= x2;) {
-            controlPoint1.setX(x + step);
-            controlPoint2.setX(x + step);
-            x += 2 * step;
-            path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
-        }
+    for (float x = x1; x + 2 * step <= x2;) {
+        T::setX(controlPoint1, x + step);
+        T::setX(controlPoint2, x + step);
+        x += 2 * step;
+        path.addBezierCurveTo(controlPoint1, controlPoint2, T::p(x, yAxis));
     }
 
     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);
+}
+
 static bool shouldSetDecorationAntialias(TextDecorationStyle decorationStyle)
 {
     return decorationStyle == TextDecorationStyleDotted || decorationStyle == TextDecorationStyleDashed;
 }
 
 static bool shouldSetDecorationAntialias(TextDecorationStyle underline, TextDecorationStyle overline, TextDecorationStyle linethrough)
 {
     return shouldSetDecorationAntialias(underline) || shouldSetDecorationAntialias(overline) || shouldSetDecorationAntialias(linethrough);
 }
 
@@ skipping 42 matching lines @@
         renderer().getTextDecorations(deco, underline, overline, linethrough, true, true);
 
     // Use a special function for underlines to get the positioning exactly right.
 
     RenderStyle* styleToUse = renderer().style(isFirstLineStyle());
     int baseline = styleToUse->fontMetrics().ascent();
 
     // Set the thick of the line to be 10% (or something else ?)of the computed font size and not less than 1px.
 
     // Update Underline thickness, in case we have Faulty Font Metrics calculating underline thickness by old method.
-    float textDecorationThickness = styleToUse->fontMetrics().underlineThickness();
+    float textDecorationThickness = styleToUse->fontMetrics().underlineThickness(); // TODO(ianh): Make this author-controllable
     int fontHeightInt  = (int)(styleToUse->fontMetrics().floatHeight() + 0.5);
     if ((textDecorationThickness == 0.f) || (textDecorationThickness >= (fontHeightInt >> 1)))
         textDecorationThickness = std::max(1.f, styleToUse->computedFontSize() / 10.f);
 
     context->setStrokeThickness(textDecorationThickness);
 
     bool antialiasDecoration = shouldSetDecorationAntialias(overline.style, underline.style, linethrough.style)
         && RenderBoxModelObject::shouldAntialiasLines(context);
 
     // Offset between lines - always non-zero, so lines never cross each other.
@@ skipping 359 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