Proper support for multiple text decorations.

Source/core/rendering/style/RenderStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 78 matching lines @@
 #define SET_BORDERVALUE_COLOR(group, variable, value) \
     if (!compareEqual(group->variable.color(), value)) \
         group.access()->variable.setColor(value)
 
 namespace WebCore {
 
 using std::max;
 
 class FilterOperations;
 
+class AppliedTextDecoration;
+class AppliedTextDecorationList;
 class BorderData;
 class CounterContent;
 class CursorList;
 class Font;
 class FontMetrics;
 class IntRect;
 class Pair;
 class ShadowList;
 class StyleImage;
 class StyleInheritedData;
@@ skipping 46 matching lines @@
     struct InheritedFlags {
         bool operator==(const InheritedFlags& other) const
         {
             return (_empty_cells == other._empty_cells)
                 && (_caption_side == other._caption_side)
                 && (_list_style_type == other._list_style_type)
                 && (_list_style_position == other._list_style_position)
                 && (_visibility == other._visibility)
                 && (_text_align == other._text_align)
                 && (_text_transform == other._text_transform)
-                && (_text_decorations == other._text_decorations)
+                && (m_textUnderline == other.m_textUnderline)
                 && (_cursor_style == other._cursor_style)
                 && (_direction == other._direction)
                 && (_white_space == other._white_space)
                 && (_border_collapse == other._border_collapse)
                 && (_box_direction == other._box_direction)
                 && (m_rtlOrdering == other.m_rtlOrdering)
                 && (m_printColorAdjust == other.m_printColorAdjust)
                 && (_pointerEvents == other._pointerEvents)
                 && (_insideLink == other._insideLink)
                 && (m_writingMode == other.m_writingMode);
         }
 
         bool operator!=(const InheritedFlags& other) const { return !(*this == other); }
 
         unsigned _empty_cells : 1; // EEmptyCell
         unsigned _caption_side : 2; // ECaptionSide
         unsigned _list_style_type : 7; // EListStyleType
         unsigned _list_style_position : 1; // EListStylePosition
         unsigned _visibility : 2; // EVisibility
         unsigned _text_align : 4; // ETextAlign
         unsigned _text_transform : 2; // ETextTransform
-        unsigned _text_decorations : TextDecorationBits;
+        unsigned m_textUnderline : 1;
         unsigned _cursor_style : 6; // ECursor
         unsigned _direction : 1; // TextDirection
         unsigned _white_space : 3; // EWhiteSpace
-        // 32 bits
         unsigned _border_collapse : 1; // EBorderCollapse
         unsigned _box_direction : 1; // EBoxDirection (CSS3 box_direction property, flexible box layout module)
+        // 32 bits
 
         // non CSS2 inherited
         unsigned m_rtlOrdering : 1; // Order
         unsigned m_printColorAdjust : PrintColorAdjustBits;
         unsigned _pointerEvents : 4; // EPointerEvents
         unsigned _insideLink : 2; // EInsideLink
-        // 43 bits
+        // 40 bits
 
         // CSS Text Layout Module Level 3: Vertical writing support
         unsigned m_writingMode : 2; // WritingMode
-        // 45 bits
+        // 42 bits
     } inherited_flags;
 
 // don't inherit
     struct NonInheritedFlags {
         bool operator==(const NonInheritedFlags& other) const
         {
             return _effectiveDisplay == other._effectiveDisplay
                 && _originalDisplay == other._originalDisplay
                 && _overflowX == other._overflowX
                 && _overflowY == other._overflowY
@@ skipping 79 matching lines @@
 protected:
     void setBitDefaults()
     {
         inherited_flags._empty_cells = initialEmptyCells();
         inherited_flags._caption_side = initialCaptionSide();
         inherited_flags._list_style_type = initialListStyleType();
         inherited_flags._list_style_position = initialListStylePosition();
         inherited_flags._visibility = initialVisibility();
         inherited_flags._text_align = initialTextAlign();
         inherited_flags._text_transform = initialTextTransform();
-        inherited_flags._text_decorations = initialTextDecoration();
+        inherited_flags.m_textUnderline = false;
         inherited_flags._cursor_style = initialCursor();
         inherited_flags._direction = initialDirection();
         inherited_flags._white_space = initialWhiteSpace();
         inherited_flags._border_collapse = initialBorderCollapse();
         inherited_flags.m_rtlOrdering = initialRTLOrdering();
         inherited_flags._box_direction = initialBoxDirection();
         inherited_flags.m_printColorAdjust = initialPrintColorAdjust();
         inherited_flags._pointerEvents = initialPointerEvents();
         inherited_flags._insideLink = NotInsideLink;
         inherited_flags.m_writingMode = initialWritingMode();
@@ skipping 257 matching lines @@
     FontWeight fontWeight() const;
 
     float textAutosizingMultiplier() const { return visual->m_textAutosizingMultiplier; }
 
     const Length& textIndent() const { return rareInheritedData->indent; }
     TextIndentLine textIndentLine() const { return static_cast<TextIndentLine>(rareInheritedData->m_textIndentLine); }
     ETextAlign textAlign() const { return static_cast<ETextAlign>(inherited_flags._text_align); }
     TextAlignLast textAlignLast() const { return static_cast<TextAlignLast>(rareInheritedData->m_textAlignLast); }
     TextJustify textJustify() const { return static_cast<TextJustify>(rareInheritedData->m_textJustify); }
     ETextTransform textTransform() const { return static_cast<ETextTransform>(inherited_flags._text_transform); }
-    TextDecoration textDecorationsInEffect() const { return static_cast<TextDecoration>(inherited_flags._text_decorations); }
+    TextDecoration textDecorationsInEffect() const;
+    TextDecoration appliedTextUnderline() const { return static_cast<TextDecoration>(inherited_flags.m_textUnderline); }

[esprehn, 2014/03/31 17:41:24]

Instead of this you can encapsulate the optimization by returning a static const
Vector<AppliedTextDecoration> that just contains an underline. You can share
that Vector between all RenderStyles.


const AppliedTextDecorationList* appliedTextDecorations()
{
  DECLARE_STATIC_LOCAL(Vector<AppliedTextDecoration>, empty, ());
  DECLARE_STATIC_LOCAL(Vector<AppliedTextDecoration>, underline, (...));
  if (!inherited_flags.m_textUnderline &&
!rareInheritedData->appliedTextDecorations.size())
      return empty;
  if (inherited_flags.m_textUnderline &&
!rareInheritedData->appliedTextDecorations.size())
      return underline;
  return *rareInheritedData->appliedTextDecorations;
}

I would materialize the single underline inside the Vector too as the first
element.

[andersr, 2014/04/01 17:07:54]

Note that I have not fully addressed this issue in Patch Set 3. (I've addressed
all other issues, though).

AppliedTextDecoration objects contain the resolved Color for the decoration,
whereas the color for the simple underline is resolved during painting. If we
are to "migrate" the simple underline into the rare list once rare decorations
appear, then we need to resolve the Color during style adjusting instead. In
other words, we need to implement RenderObject::underlineColor during style
adjustment. Is that possible?

+    const AppliedTextDecorationList* appliedTextDecorations() const { return rareInheritedData->appliedTextDecorations.get(); }

[esprehn, 2014/03/31 17:41:24]

const Vector<AppliedTextDecoration>&, reference not pointer.

+    bool hasAppliedTextDecorations() const { return appliedTextUnderline() || appliedTextDecorations(); }
     TextDecoration textDecoration() const { return static_cast<TextDecoration>(visual->textDecoration); }
     TextUnderlinePosition textUnderlinePosition() const { return static_cast<TextUnderlinePosition>(rareInheritedData->m_textUnderlinePosition); }
     TextDecorationStyle textDecorationStyle() const { return static_cast<TextDecorationStyle>(rareNonInheritedData->m_textDecorationStyle); }
     float wordSpacing() const;
     float letterSpacing() const;
 
     float zoom() const { return visual->m_zoom; }
     float effectiveZoom() const { return rareInheritedData->m_effectiveZoom; }
 
     TextDirection direction() const { return static_cast<TextDirection>(inherited_flags._direction); }
@@ skipping 507 matching lines @@
         setFontSize(fontDescription().specifiedSize());
     }
 
     void setColor(const Color&);
     void setTextIndent(Length v) { SET_VAR(rareInheritedData, indent, v); }
     void setTextIndentLine(TextIndentLine v) { SET_VAR(rareInheritedData, m_textIndentLine, v); }
     void setTextAlign(ETextAlign v) { inherited_flags._text_align = v; }
     void setTextAlignLast(TextAlignLast v) { SET_VAR(rareInheritedData, m_textAlignLast, v); }
     void setTextJustify(TextJustify v) { SET_VAR(rareInheritedData, m_textJustify, v); }
     void setTextTransform(ETextTransform v) { inherited_flags._text_transform = v; }
-    void addToTextDecorationsInEffect(TextDecoration v) { inherited_flags._text_decorations |= v; }
-    void setTextDecorationsInEffect(TextDecoration v) { inherited_flags._text_decorations = v; }
+    void setTextDecorationsInEffect(TextDecoration);
+    void addAppliedTextDecoration(TextDecoration);
+    void addAppliedTextDecoration(const AppliedTextDecoration&);
+    void applyTextDecoration(TextDecoration, TextDecorationStyle, const StyleColor&);
+    void applyTextDecorations();
+    void clearAppliedTextDecorations();
     void setTextDecoration(TextDecoration v) { SET_VAR(visual, textDecoration, v); }
     void setTextUnderlinePosition(TextUnderlinePosition v) { SET_VAR(rareInheritedData, m_textUnderlinePosition, v); }
     void setTextDecorationStyle(TextDecorationStyle v) { SET_VAR(rareNonInheritedData, m_textDecorationStyle, v); }
     void setDirection(TextDirection v) { inherited_flags._direction = v; }
     void setLineHeight(Length specifiedLineHeight);
     bool setZoom(float);
     void setZoomWithoutReturnValue(float f) { setZoom(f); }
     bool setEffectiveZoom(float);
 
     void setImageRendering(EImageRendering v) { SET_VAR(rareInheritedData, m_imageRendering, v); }
@@ skipping 379 matching lines @@
 
     bool isSharable() const;
 
     bool emptyState() const { return noninherited_flags.emptyState; }
     void setEmptyState(bool b) { setUnique(); noninherited_flags.emptyState = b; }
     bool firstChildState() const { return noninherited_flags.firstChildState; }
     void setFirstChildState() { setUnique(); noninherited_flags.firstChildState = true; }
     bool lastChildState() const { return noninherited_flags.lastChildState; }
     void setLastChildState() { setUnique(); noninherited_flags.lastChildState = true; }
 
-    StyleColor visitedDependentDecorationColor() const;
+    StyleColor visitedDependentDecorationStyleColor() const;
+    Color visitedDependentDecorationColor() const;
     Color visitedDependentColor(int colorProperty) const;
 
     void setHasExplicitlyInheritedProperties() { noninherited_flags.explicitInheritance = true; }
     bool hasExplicitlyInheritedProperties() const { return noninherited_flags.explicitInheritance; }
 
     void setHasCurrentColor() { noninherited_flags.currentColor = true; }
     bool hasCurrentColor() const { return noninherited_flags.currentColor; }
 
     // Initial values for all the properties
     static EBorderCollapse initialBorderCollapse() { return BSEPARATE; }
@@ skipping 340 matching lines @@
 inline bool RenderStyle::hasPseudoElementStyle() const
 {
     return noninherited_flags._pseudoBits & PSEUDO_ELEMENT_MASK;
 }
 
 float calcBorderRadiiConstraintScaleFor(const FloatRect&, const FloatRoundedRect::Radii&);
 
 } // namespace WebCore
 
 #endif // RenderStyle_h