List marker pseudo elements.

Source/core/rendering/RenderListItem.cpp

 /**
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 #include "core/rendering/RenderListItem.h"
 
 #include "core/HTMLNames.h"
+#include "core/dom/MarkerPseudoElement.h"
 #include "core/dom/NodeRenderingTraversal.h"
 #include "core/html/HTMLOListElement.h"
 #include "core/rendering/RenderListMarker.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/TextAutosizer.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
@@ skipping 12 matching lines @@
 void RenderListItem::trace(Visitor* visitor)
 {
     visitor->trace(m_marker);
     RenderBlockFlow::trace(visitor);
 }
 
 void RenderListItem::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     RenderBlockFlow::styleDidChange(diff, oldStyle);
 
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled())
+        return;
+
     if (style()->listStyleType() != NoneListStyle
         || (style()->listStyleImage() && !style()->listStyleImage()->errorOccurred())) {
         if (!m_marker)
             m_marker = RenderListMarker::createAnonymous(this);
         m_marker->listItemStyleDidChange();
     } else if (m_marker) {
         m_marker->destroy();
         m_marker = nullptr;
     }
 }
 
 void RenderListItem::willBeDestroyed()
 {
     if (m_marker) {
         m_marker->destroy();
         m_marker = nullptr;
     }
     RenderBlockFlow::willBeDestroyed();
 }
 
 void RenderListItem::insertedIntoTree()
 {
     RenderBlockFlow::insertedIntoTree();
-
     updateListMarkerNumbers();
 }
 
 void RenderListItem::willBeRemovedFromTree()
 {
     RenderBlockFlow::willBeRemovedFromTree();
-
     updateListMarkerNumbers();
 }
 
 static bool isList(const Node& node)
 {
     return isHTMLUListElement(node) || isHTMLOListElement(node);
 }
 
 // Returns the enclosing list with respect to the DOM order.
 static Node* enclosingList(const RenderListItem* listItem)
@@ skipping 111 matching lines @@
 }
 
 void RenderListItem::updateValueNow() const
 {
     m_value = calcValue();
     m_isValueUpToDate = true;
 }
 
 bool RenderListItem::isEmpty() const
 {
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        PseudoElement* element = toElement(node())->pseudoElement(MARKER);
+        return !(element && lastChild() != element->renderer());
+    }
     return lastChild() == m_marker;
 }
 
-static RenderObject* getParentOfFirstLineBox(RenderBlockFlow* curr, RenderObject* marker)
-{
-    RenderObject* firstChild = curr->firstChild();
-    if (!firstChild)
-        return 0;
-
-    bool inQuirksMode = curr->document().inQuirksMode();
-    for (RenderObject* currChild = firstChild; currChild; currChild = currChild->nextSibling()) {
-        if (currChild == marker)
-            continue;
-
-        if (currChild->isInline() && (!currChild->isRenderInline() || curr->generatesLineBoxesForInlineChild(currChild)))
-            return curr;
-
-        if (currChild->isFloating() || currChild->isOutOfFlowPositioned())
-            continue;
-
-        if (!currChild->isRenderBlockFlow() || (currChild->isBox() && toRenderBox(currChild)->isWritingModeRoot()))
-            break;
-
-        if (curr->isListItem() && inQuirksMode && currChild->node() &&
-            (isHTMLUListElement(*currChild->node()) || isHTMLOListElement(*currChild->node())))
-            break;
-
-        RenderObject* lineBox = getParentOfFirstLineBox(toRenderBlockFlow(currChild), marker);
-        if (lineBox)
-            return lineBox;
-    }
-
-    return 0;
-}
-
 void RenderListItem::updateValue()
 {
     if (!m_hasExplicitValue) {
         m_isValueUpToDate = false;
-        if (m_marker)
+        if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+            if (PseudoElement* element = toElement(node())->pseudoElement(MARKER))
+                element->renderer()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
+        } else if (m_marker) {
             m_marker->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
+        }
     }
 }
 
-static RenderObject* firstNonMarkerChild(RenderObject* parent)
-{
-    RenderObject* result = parent->slowFirstChild();
-    while (result && result->isListMarker())
-        result = result->nextSibling();
-    return result;
-}
-
 void RenderListItem::updateMarkerLocationAndInvalidateWidth()
 {
+    ASSERT(!RuntimeEnabledFeatures::listMarkerPseudoElementEnabled());
     ASSERT(m_marker);
 
     // FIXME: We should not modify the structure of the render tree
     // during layout. crbug.com/370461
     DeprecatedDisableModifyRenderTreeStructureAsserts disabler;
     if (updateMarkerLocation()) {
         // If the marker is inside we need to redo the preferred width calculations
         // as the size of the item now includes the size of the list marker.
         if (m_marker->isInside())
             containingBlock()->updateLogicalWidth();
     }
 }
 
 bool RenderListItem::updateMarkerLocation()
 {
+    ASSERT(!RuntimeEnabledFeatures::listMarkerPseudoElementEnabled());
     ASSERT(m_marker);
+
     RenderObject* markerParent = m_marker->parent();
-    RenderObject* lineBoxParent = getParentOfFirstLineBox(this, m_marker);
+    RenderObject* lineBoxParent = MarkerPseudoElement::getParentOfFirstLineBox(this, m_marker);
     if (!lineBoxParent) {
         // If the marker is currently contained inside an anonymous box, then we
         // are the only item in that anonymous box (since no line box parent was
         // found). It's ok to just leave the marker where it is in this case.
         if (markerParent && markerParent->isAnonymousBlock())
             lineBoxParent = markerParent;
         else
             lineBoxParent = this;
     }
 
     if (markerParent != lineBoxParent) {
         m_marker->remove();
-        lineBoxParent->addChild(m_marker, firstNonMarkerChild(lineBoxParent));
+        lineBoxParent->addChild(m_marker, MarkerPseudoElement::firstNonMarkerChild(lineBoxParent));
         m_marker->updateMarginsAndContent();
         // If markerParent is an anonymous block with no children, destroy it.
         if (markerParent && markerParent->isAnonymousBlock() && !toRenderBlock(markerParent)->firstChild() && !toRenderBlock(markerParent)->continuation())
             markerParent->destroy();
         return true;
     }
 
     return false;
 }
 
 void RenderListItem::layout()
 {
     ASSERT(needsLayout());
 
-    if (m_marker) {
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        PseudoElement* element = toElement(node())->pseudoElement(MARKER);
+        if (element && element->renderer()) {
+            ASSERT(element->renderer()->isListMarker());
+            RenderListMarker* marker = toRenderListMarker(element->renderer());
+
+            marker->updateMarginsAndContent();
+
+            // FIXME: Is this needed?
+            if (marker->isInside())
+                containingBlock()->updateLogicalWidth();
+        }
+
+    } else if (m_marker) {
         // The marker must be autosized before calling
         // updateMarkerLocationAndInvalidateWidth. It cannot be done in the
         // parent's beginLayout because it is not yet in the render tree.
         if (TextAutosizer* textAutosizer = document().textAutosizer())
             textAutosizer->inflateListItem(this, m_marker);
 
         updateMarkerLocationAndInvalidateWidth();
     }
 
     RenderBlockFlow::layout();
 }
 
 void RenderListItem::addOverflowFromChildren()
 {
     RenderBlockFlow::addOverflowFromChildren();
-    positionListMarker();
+
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        MarkerPseudoElement* markerElement = toMarkerPseudoElement(toElement(node())->pseudoElement(MARKER));
+        if (markerElement && markerElement->renderer()) {
+            ASSERT(markerElement->renderer()->isListMarker());
+            positionListMarker(toRenderListMarker(markerElement->renderer()));
+        }
+    } else {
+        positionListMarker(m_marker);
+    }
 }
 
-void RenderListItem::positionListMarker()
+void RenderListItem::positionListMarker(RenderListMarker* marker)
 {
-    if (m_marker && m_marker->parent()->isBox() && !m_marker->isInside() && m_marker->inlineBoxWrapper()) {
-        LayoutUnit markerOldLogicalLeft = m_marker->logicalLeft();
+    if (!marker)
+        return;
+
+    ASSERT(marker->parent());
+    if (marker->parent()->isBox() && !marker->isInside() && marker->inlineBoxWrapper()) {
+        LayoutUnit markerOldLogicalLeft = marker->logicalLeft();
         LayoutUnit blockOffset = 0;
         LayoutUnit lineOffset = 0;
-        for (RenderBox* o = m_marker->parentBox(); o != this; o = o->parentBox()) {
+        for (RenderBox* o = marker->parentBox(); o != this; o = o->parentBox()) {
             blockOffset += o->logicalTop();
             lineOffset += o->logicalLeft();
         }
 
         bool adjustOverflow = false;
         LayoutUnit markerLogicalLeft;
-        RootInlineBox& root = m_marker->inlineBoxWrapper()->root();
+        RootInlineBox& root = marker->inlineBoxWrapper()->root();
         bool hitSelfPaintingLayer = false;
 
         LayoutUnit lineTop = root.lineTop();
         LayoutUnit lineBottom = root.lineBottom();
 
         // FIXME: Need to account for relative positioning in the layout overflow.
         if (style()->isLeftToRightDirection()) {
             LayoutUnit leftLineOffset = logicalLeftOffsetForLine(blockOffset, logicalLeftOffsetForLine(blockOffset, false), false);
-            markerLogicalLeft = leftLineOffset - lineOffset - paddingStart() - borderStart() + m_marker->marginStart();
-            m_marker->inlineBoxWrapper()->adjustLineDirectionPosition((markerLogicalLeft - markerOldLogicalLeft).toFloat());
-            for (InlineFlowBox* box = m_marker->inlineBoxWrapper()->parent(); box; box = box->parent()) {
+            markerLogicalLeft = leftLineOffset - lineOffset - paddingStart() - borderStart() + marker->marginStart();
+            marker->inlineBoxWrapper()->adjustLineDirectionPosition((markerLogicalLeft - markerOldLogicalLeft).toFloat());
+            for (InlineFlowBox* box = marker->inlineBoxWrapper()->parent(); box; box = box->parent()) {
                 LayoutRect newLogicalVisualOverflowRect = box->logicalVisualOverflowRect(lineTop, lineBottom);
                 LayoutRect newLogicalLayoutOverflowRect = box->logicalLayoutOverflowRect(lineTop, lineBottom);
                 if (markerLogicalLeft < newLogicalVisualOverflowRect.x() && !hitSelfPaintingLayer) {
                     newLogicalVisualOverflowRect.setWidth(newLogicalVisualOverflowRect.maxX() - markerLogicalLeft);
                     newLogicalVisualOverflowRect.setX(markerLogicalLeft);
                     if (box == root)
                         adjustOverflow = true;
                 }
                 if (markerLogicalLeft < newLogicalLayoutOverflowRect.x()) {
                     newLogicalLayoutOverflowRect.setWidth(newLogicalLayoutOverflowRect.maxX() - markerLogicalLeft);
                     newLogicalLayoutOverflowRect.setX(markerLogicalLeft);
                     if (box == root)
                         adjustOverflow = true;
                 }
                 box->setOverflowFromLogicalRects(newLogicalLayoutOverflowRect, newLogicalVisualOverflowRect, lineTop, lineBottom);
                 if (box->boxModelObject()->hasSelfPaintingLayer())
                     hitSelfPaintingLayer = true;
             }
         } else {
             LayoutUnit rightLineOffset = logicalRightOffsetForLine(blockOffset, logicalRightOffsetForLine(blockOffset, false), false);
-            markerLogicalLeft = rightLineOffset - lineOffset + paddingStart() + borderStart() + m_marker->marginEnd();
-            m_marker->inlineBoxWrapper()->adjustLineDirectionPosition((markerLogicalLeft - markerOldLogicalLeft).toFloat());
-            for (InlineFlowBox* box = m_marker->inlineBoxWrapper()->parent(); box; box = box->parent()) {
+            markerLogicalLeft = rightLineOffset - lineOffset + paddingStart() + borderStart() + marker->marginEnd();
+            marker->inlineBoxWrapper()->adjustLineDirectionPosition((markerLogicalLeft - markerOldLogicalLeft).toFloat());
+            for (InlineFlowBox* box = marker->inlineBoxWrapper()->parent(); box; box = box->parent()) {
                 LayoutRect newLogicalVisualOverflowRect = box->logicalVisualOverflowRect(lineTop, lineBottom);
                 LayoutRect newLogicalLayoutOverflowRect = box->logicalLayoutOverflowRect(lineTop, lineBottom);
-                if (markerLogicalLeft + m_marker->logicalWidth() > newLogicalVisualOverflowRect.maxX() && !hitSelfPaintingLayer) {
-                    newLogicalVisualOverflowRect.setWidth(markerLogicalLeft + m_marker->logicalWidth() - newLogicalVisualOverflowRect.x());
+                if (markerLogicalLeft + marker->logicalWidth() > newLogicalVisualOverflowRect.maxX() && !hitSelfPaintingLayer) {
+                    newLogicalVisualOverflowRect.setWidth(markerLogicalLeft + marker->logicalWidth() - newLogicalVisualOverflowRect.x());
                     if (box == root)
                         adjustOverflow = true;
                 }
-                if (markerLogicalLeft + m_marker->logicalWidth() > newLogicalLayoutOverflowRect.maxX()) {
-                    newLogicalLayoutOverflowRect.setWidth(markerLogicalLeft + m_marker->logicalWidth() - newLogicalLayoutOverflowRect.x());
+                if (markerLogicalLeft + marker->logicalWidth() > newLogicalLayoutOverflowRect.maxX()) {
+                    newLogicalLayoutOverflowRect.setWidth(markerLogicalLeft + marker->logicalWidth() - newLogicalLayoutOverflowRect.x());
                     if (box == root)
                         adjustOverflow = true;
                 }
                 box->setOverflowFromLogicalRects(newLogicalLayoutOverflowRect, newLogicalVisualOverflowRect, lineTop, lineBottom);
 
                 if (box->boxModelObject()->hasSelfPaintingLayer())
                     hitSelfPaintingLayer = true;
             }
         }
 
         if (adjustOverflow) {
-            LayoutRect markerRect(LayoutPoint(markerLogicalLeft + lineOffset, blockOffset), m_marker->size());
+            LayoutRect markerRect(LayoutPoint(markerLogicalLeft + lineOffset, blockOffset), marker->size());
             if (!style()->isHorizontalWritingMode())
                 markerRect = markerRect.transposedRect();
-            RenderBox* o = m_marker;
+            RenderBox* o = marker;
             bool propagateVisualOverflow = true;
             bool propagateLayoutOverflow = true;
             do {
                 o = o->parentBox();
                 if (o->isRenderBlock()) {
                     if (propagateVisualOverflow)
                         toRenderBlock(o)->addContentsVisualOverflow(markerRect);
                     if (propagateLayoutOverflow)
                         toRenderBlock(o)->addLayoutOverflow(markerRect);
                 }
@@ skipping 12 matching lines @@
 void RenderListItem::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     if (!logicalHeight() && hasOverflowClip())
         return;
 
     RenderBlockFlow::paint(paintInfo, paintOffset);
 }
 
 const String& RenderListItem::markerText() const
 {
-    if (m_marker)
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        if (PseudoElement* element = toElement(node())->pseudoElement(MARKER)) {
+            if (element->renderer()) {
+                ASSERT(element->renderer()->isListMarker());
+                return toRenderListMarker(element->renderer())->text();
+            }
+        }
+    } else if (m_marker) {
         return m_marker->text();
+    }
     return nullAtom.string();
 }
 
 void RenderListItem::explicitValueChanged()
 {
-    if (m_marker)
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        if (PseudoElement* element = toElement(node())->pseudoElement(MARKER))
+            element->renderer()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
+    } else if (m_marker) {
         m_marker->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
+    }
+
     Node* listNode = enclosingList(this);
     for (RenderListItem* item = this; item; item = nextListItem(listNode, item))
         item->updateValue();
 }
 
 void RenderListItem::setExplicitValue(int value)
 {
     ASSERT(node());
 
     if (m_hasExplicitValue && m_explicitValue == value)
@@ skipping 11 matching lines @@
     if (!m_hasExplicitValue)
         return;
     m_hasExplicitValue = false;
     m_isValueUpToDate = false;
     explicitValueChanged();
 }
 
 void RenderListItem::setNotInList(bool notInList)
 {
     m_notInList = notInList;
-    if (m_marker)
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        if (PseudoElement* element = toElement(node())->pseudoElement(MARKER)) {
+            ASSERT(element->renderer());
+            ASSERT(element->renderer()->isListMarker());
+            toRenderListMarker(element->renderer())->updateMarginsAndContent();

[Julien - ping for review, 2015/02/04 01:56:34]

This will need some explanations.

[dsinclair, 2015/02/04 04:41:33]

This is the one bit that was needed from the old updateMarkerLocation() code.
The renderer() for the MARKER element is the RenderListMarker, so when the list
item changes we update the marker.

+        }
+    } else if (m_marker) {
         updateMarkerLocation();
+    }
 }
 
 static RenderListItem* previousOrNextItem(bool isListReversed, Node* list, RenderListItem* item)
 {
     return isListReversed ? previousListItem(list, item) : nextListItem(list, item);
 }
 
 void RenderListItem::updateListMarkerNumbers()
 {
     // If distribution recalc is needed, updateListMarkerNumber will be re-invoked
@@ skipping 24 matching lines @@
             // assume that all the following ones have too.
             // This gives us the opportunity to stop here and avoid
             // marking the same nodes again.
             break;
         }
         item->updateValue();
     }
 }
 
 } // namespace blink