List marker pseudo elements.

Source/core/layout/LayoutListItem.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/layout/LayoutListItem.h"
 
 #include "core/HTMLNames.h"
+#include "core/dom/MarkerPseudoElement.h"
 #include "core/dom/shadow/ComposedTreeTraversal.h"
 #include "core/html/HTMLOListElement.h"
 #include "core/layout/LayoutListMarker.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/TextAutosizer.h"
 #include "wtf/StdLibExtras.h"
+#include "wtf/TemporaryChange.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 LayoutListItem::LayoutListItem(Element* element)
     : LayoutBlockFlow(element)
     , m_marker(nullptr)
     , m_hasExplicitValue(false)
     , m_isValueUpToDate(false)
     , m_notInList(false)
 {
     setInline(false);
 }
 
 void LayoutListItem::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBlockFlow::styleDidChange(diff, oldStyle);
 
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled())
+        return;
+
     if (style()->listStyleType() != NoneListStyle
         || (style()->listStyleImage() && !style()->listStyleImage()->errorOccurred())) {
         if (!m_marker)
             m_marker = LayoutListMarker::createAnonymous(this);
         m_marker->listItemStyleDidChange();
     } else if (m_marker) {
         m_marker->destroy();
         m_marker = nullptr;
     }
 }
 
 void LayoutListItem::willBeDestroyed()
 {
     if (m_marker) {
         m_marker->destroy();
         m_marker = nullptr;
     }
     LayoutBlockFlow::willBeDestroyed();
 }
 
 void LayoutListItem::insertedIntoTree()
 {
     LayoutBlockFlow::insertedIntoTree();
-
     updateListMarkerNumbers();
 }
 
 void LayoutListItem::willBeRemovedFromTree()
 {
     LayoutBlockFlow::willBeRemovedFromTree();
+    updateListMarkerNumbers();
+}
 
-    updateListMarkerNumbers();
+// FIXME: This causes subtree modifications, which will set the flags and we'll
+// end up doing the check a second time next frame ....
+void LayoutListItem::handleSubtreeModifications()
+{
+    if (documentBeingDestroyed())
+        return;
+
+    if (!notifyAncestorsOfSubtreeChange())

[esprehn, 2015/04/22 07:45:46]

The tree walk should handle this for you, not the impls.

[dsinclair, 2015/04/22 20:00:39]

Done.

+        return;
+
+    if (PseudoElement* element = toElement(node())->pseudoElement(MARKER))

[esprehn, 2015/04/22 07:45:46]

Having the layout tree reach back into the DOM like this seems unfortunate.

[dsinclair, 2015/04/22 20:00:39]

I'm not sure how to fix this one? The PseudoElement knows where to insert the
layoutObject and we know that descendants have changed, so we have to ask it to
do the work.

+        toMarkerPseudoElement(element)->attachListMarkerLayoutObject();
+
+    LayoutBlockFlow::handleSubtreeModifications();

[esprehn, 2015/04/22 07:45:46]

tree walk should be external to the notification callbacks.

[dsinclair, 2015/04/22 20:00:39]

Done.

 }
 
 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 LayoutListItem* listItem)
 {
@@ skipping 26 matching lines @@
     ASSERT(!current->document().childNeedsDistributionRecalc());
     current = LayoutTreeBuilderTraversal::next(*current, listNode);
 
     while (current) {
         if (isList(*current)) {
             // We've found a nested, independent list: nothing to do here.
             current = LayoutTreeBuilderTraversal::nextSkippingChildren(*current, listNode);
             continue;
         }
 
-        LayoutObject* renderer = current->layoutObject();
-        if (renderer && renderer->isListItem())
-            return toLayoutListItem(renderer);
+        LayoutObject* layoutObject = current->layoutObject();
+        if (layoutObject && layoutObject->isListItem())
+            return toLayoutListItem(layoutObject);
 
-        // FIXME: Can this be optimized to skip the children of the elements without a renderer?
+        // FIXME: Can this be optimized to skip the children of the elements without a layoutObject?
         current = LayoutTreeBuilderTraversal::next(*current, listNode);
     }
 
     return 0;
 }
 
 // Returns the previous list item with respect to the DOM order.
 static LayoutListItem* previousListItem(const Node* listNode, const LayoutListItem* item)
 {
     Node* current = item->node();
     ASSERT(current);
     ASSERT(!current->document().childNeedsDistributionRecalc());
-    for (current = LayoutTreeBuilderTraversal::previous(*current, listNode); current && current != listNode; current = LayoutTreeBuilderTraversal::previous(*current, listNode)) {
-        LayoutObject* renderer = current->layoutObject();
-        if (!renderer || (renderer && !renderer->isListItem()))
+    for (current = LayoutTreeBuilderTraversal::previous(*current, listNode);
+        current && current != listNode;
+        current = LayoutTreeBuilderTraversal::previous(*current, listNode)) {
+
+        LayoutObject* layoutObject = current->layoutObject();
+        if (!layoutObject || (layoutObject && !layoutObject->isListItem()))
             continue;
-        Node* otherList = enclosingList(toLayoutListItem(renderer));
+        Node* otherList = enclosingList(toLayoutListItem(layoutObject));

[esprehn, 2015/04/22 07:45:46]

I'm really not sure all this is a code improvement, it just makes it all more
verbose. Maybe layouter? or just object?

[dsinclair, 2015/04/22 20:00:39]

Ack.

         // This item is part of our current list, so it's what we're looking for.
         if (listNode == otherList)
-            return toLayoutListItem(renderer);
+            return toLayoutListItem(layoutObject);
         // We found ourself inside another list; lets skip the rest of it.
         // Use nextIncludingPseudo() here because the other list itself may actually
         // be a list item itself. We need to examine it, so we do this to counteract
         // the previousIncludingPseudo() that will be done by the loop.
         if (otherList)
             current = LayoutTreeBuilderTraversal::next(*otherList, listNode);
     }
     return 0;
 }
 
@@ skipping 39 matching lines @@
 }
 
 void LayoutListItem::updateValueNow() const
 {
     m_value = calcValue();
     m_isValueUpToDate = true;
 }
 
 bool LayoutListItem::isEmpty() const
 {
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        PseudoElement* element = toElement(node())->pseudoElement(MARKER);
+        return !(element && lastChild() != element->layoutObject());

[esprehn, 2015/04/22 07:45:46]

Run demorgans.

[dsinclair, 2015/04/22 20:00:39]

Done.

+    }
     return lastChild() == m_marker;
 }
 
-static LayoutObject* getParentOfFirstLineBox(LayoutBlockFlow* curr, LayoutObject* marker)
-{
-    LayoutObject* firstChild = curr->firstChild();
-    if (!firstChild)
-        return 0;
-
-    bool inQuirksMode = curr->document().inQuirksMode();
-    for (LayoutObject* currChild = firstChild; currChild; currChild = currChild->nextSibling()) {
-        if (currChild == marker)
-            continue;
-
-        if (currChild->isInline() && (!currChild->isLayoutInline() || curr->generatesLineBoxesForInlineChild(currChild)))
-            return curr;
-
-        if (currChild->isFloating() || currChild->isOutOfFlowPositioned())
-            continue;
-
-        if (!currChild->isLayoutBlockFlow() || (currChild->isBox() && toLayoutBox(currChild)->isWritingModeRoot()))
-            break;
-
-        if (curr->isListItem() && inQuirksMode && currChild->node()
-            && (isHTMLUListElement(*currChild->node()) || isHTMLOListElement(*currChild->node())))
-            break;
-
-        LayoutObject* lineBox = getParentOfFirstLineBox(toLayoutBlockFlow(currChild), marker);
-        if (lineBox)
-            return lineBox;
-    }
-
-    return 0;
-}
-
 void LayoutListItem::updateValue()
 {
-    if (!m_hasExplicitValue) {
-        m_isValueUpToDate = false;
-        if (m_marker)
-            m_marker->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::ListValueChange);
+    if (m_hasExplicitValue)
+        return;
+
+    m_isValueUpToDate = false;
+
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        if (PseudoElement* element = toElement(node())->pseudoElement(MARKER))
+            element->layoutObject()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::ListValueChange);
+    } else if (m_marker) {
+        m_marker->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::ListValueChange);
     }
 }
 
-static LayoutObject* firstNonMarkerChild(LayoutObject* parent)
-{
-    LayoutObject* result = parent->slowFirstChild();
-    while (result && result->isListMarker())
-        result = result->nextSibling();
-    return result;
-}
-
 void LayoutListItem::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;
     LayoutState* layoutState = view()->layoutState();
     LayoutFlowThread* currentFlowThread = nullptr;
     if (layoutState) {
         // We're about to modify the layout tree structure (during layout!), and any code using
         // LayoutState might get utterly confused by that. There's no evidence that anything other
         // than the flow thread code will suffer, though, so just reset the current flow thread
         // temporarily.
         // FIXME: get rid of this hack, including the flow thread setter in LayoutState, as part of
         // fixing crbug.com/370461
         currentFlowThread = layoutState->flowThread();
         layoutState->setFlowThread(nullptr);
     }
     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();
     }
     if (layoutState)
         layoutState->setFlowThread(currentFlowThread);
 }
 
 bool LayoutListItem::updateMarkerLocation()
 {
+    ASSERT(!RuntimeEnabledFeatures::listMarkerPseudoElementEnabled());
     ASSERT(m_marker);
+
     LayoutObject* markerParent = m_marker->parent();
-    LayoutObject* lineBoxParent = getParentOfFirstLineBox(this, m_marker);
+    LayoutObject* lineBoxParent = MarkerPseudoElement::parentOfFirstLineBox(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() && !toLayoutBlock(markerParent)->firstChild() && !toLayoutBlock(markerParent)->continuation())
+        if (markerParent && markerParent->isAnonymousBlock() && !toLayoutBlock(markerParent)->firstChild()
+            && !toLayoutBlock(markerParent)->continuation())
             markerParent->destroy();
         return true;
     }
 
     return false;
 }
 
 void LayoutListItem::layout()
 {
     ASSERT(needsLayout());
 
-    if (m_marker) {
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        PseudoElement* element = toElement(node())->pseudoElement(MARKER);

[esprehn, 2015/04/22 07:45:46]

I think you just want to keep m_marker, going out through the DOM to get back to
one of your descendants is kind of silly.

[dsinclair, 2015/04/22 20:00:39]

Done.

+        if (element && element->layoutObject()) {

[esprehn, 2015/04/22 07:45:46]

How does the element exist but not have a layoutObject? Earlier in updateValue()
you don't null check layoutObject.

[dsinclair, 2015/04/22 20:00:39]

Done.

+            ASSERT(element->layoutObject()->isListMarker());
+            LayoutListMarker* marker = toLayoutListMarker(element->layoutObject());
+
+            marker->updateMarginsAndContent();
+        }
+
+    } 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();
     }
 
     LayoutBlockFlow::layout();
 }
 
 void LayoutListItem::addOverflowFromChildren()
 {
     LayoutBlockFlow::addOverflowFromChildren();
-    positionListMarker();
+
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        MarkerPseudoElement* markerElement = toMarkerPseudoElement(toElement(node())->pseudoElement(MARKER));

[esprehn, 2015/04/22 07:45:46]

I really think you want to keep m_marker and not do this. Going out through the
DOM all the time in layout is bad. We want to go the other direction with the
layout code and make it talk the DOM less (especially if we ever want this
system to be thread safe).

[dsinclair, 2015/04/22 20:00:39]

Done.

+        if (markerElement && markerElement->layoutObject()) {
+            ASSERT(markerElement->layoutObject()->isListMarker());
+            positionListMarker(toLayoutListMarker(markerElement->layoutObject()));
+        }
+    } else {
+        positionListMarker(m_marker);
+    }
 }
 
-void LayoutListItem::positionListMarker()
+void LayoutListItem::positionListMarker(LayoutListMarker* 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 (LayoutBox* o = m_marker->parentBox(); o != this; o = o->parentBox()) {
+        for (LayoutBox* 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();
-            LayoutBox* o = m_marker;
+            LayoutBox* o = marker;
             bool propagateVisualOverflow = true;
             bool propagateLayoutOverflow = true;
             do {
                 o = o->parentBox();
                 if (o->isLayoutBlock()) {
                     if (propagateVisualOverflow)
                         toLayoutBlock(o)->addContentsVisualOverflow(markerRect);
                     if (propagateLayoutOverflow)
                         toLayoutBlock(o)->addLayoutOverflow(markerRect);
                 }
@@ skipping 12 matching lines @@
 void LayoutListItem::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     if (!logicalHeight() && hasOverflowClip())
         return;
 
     LayoutBlockFlow::paint(paintInfo, paintOffset);
 }
 
 const String& LayoutListItem::markerText() const
 {
-    if (m_marker)
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        if (PseudoElement* element = toElement(node())->pseudoElement(MARKER)) {
+            if (element->layoutObject()) {
+                ASSERT(element->layoutObject()->isListMarker());
+                return toLayoutListMarker(element->layoutObject())->text();

[esprehn, 2015/04/22 07:45:45]

ditto.

[dsinclair, 2015/04/22 20:00:39]

Done.

+            }
+        }
+    } else if (m_marker) {
         return m_marker->text();
+    }
     return nullAtom.string();
 }
 
 void LayoutListItem::explicitValueChanged()
 {
-    if (m_marker)
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        if (PseudoElement* element = toElement(node())->pseudoElement(MARKER))
+            element->layoutObject()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::ListValueChange);

[esprehn, 2015/04/22 07:45:46]

same.

[dsinclair, 2015/04/22 20:00:39]

Done.

+    } else if (m_marker) {
         m_marker->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::ListValueChange);
+    }
+
     Node* listNode = enclosingList(this);
     for (LayoutListItem* item = this; item; item = nextListItem(listNode, item))
         item->updateValue();
 }
 
 void LayoutListItem::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 LayoutListItem::setNotInList(bool notInList)
 {
     m_notInList = notInList;
-    if (m_marker)
+    if (RuntimeEnabledFeatures::listMarkerPseudoElementEnabled()) {
+        if (PseudoElement* element = toElement(node())->pseudoElement(MARKER)) {
+            ASSERT(element->layoutObject());
+            ASSERT(element->layoutObject()->isListMarker());
+            toLayoutListMarker(element->layoutObject())->updateMarginsAndContent();

[esprehn, 2015/04/22 07:45:46]

ditto

[dsinclair, 2015/04/22 20:00:39]

Done.

+        }
+    } else if (m_marker) {
         updateMarkerLocation();
+    }
 }
 
 static LayoutListItem* previousOrNextItem(bool isListReversed, Node* list, LayoutListItem* item)
 {
     return isListReversed ? previousListItem(list, item) : nextListItem(list, item);
 }
 
 void LayoutListItem::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