List marker pseudo elements.

Source/core/dom/MarkerPseudoElement.cpp

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "core/dom/MarkerPseudoElement.h"
+
+#include "core/rendering/RenderBlockFlow.h"
+#include "core/rendering/RenderListItem.h"
+#include "core/rendering/RenderListMarker.h"
+
+namespace blink {
+
+MarkerPseudoElement::MarkerPseudoElement(Element* parent)
+    : PseudoElement(parent, MARKER)
+{
+}
+
+MarkerPseudoElement::~MarkerPseudoElement()
+{
+}
+
+RenderObject* MarkerPseudoElement::getParentOfFirstLineBox(RenderBlockFlow* curr, const RenderObject* marker)
+{
+    RenderObject* firstChild = curr->firstChild();
+    if (!firstChild)
+        return nullptr;
+
+    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;
+
+        if (RenderObject* lineBox = getParentOfFirstLineBox(toRenderBlockFlow(currChild), marker))
+            return lineBox;
+    }
+
+    return nullptr;
+}
+
+PassRefPtr<RenderStyle> MarkerPseudoElement::customStyleForRenderer()

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

Is this function ever called?

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

Yes. This is an override of a method on Element. It's called from
Element::styleForRenderer.

+{
+    if (!renderer())
+        return nullptr;
+
+    RenderObject* parent = renderer()->parent();
+    if (!parent)
+        return nullptr;
+
+    return styleForListMarkerRenderer(*parent, renderer()->style());
+}
+
+PassRefPtr<RenderStyle> MarkerPseudoElement::styleForListMarkerRenderer(RenderObject& parent, RenderStyle* style)
+{
+    RefPtr<RenderStyle> newStyle = RenderStyle::create();
+
+    // The marker always inherits from the list item, regardless of where it might end
+    // up (e.g., in some deeply nested line box). See CSS3 spec.
+    newStyle->inheritFrom(parent.style());
+    if (style) {
+        // Reuse the current margins. Otherwise resetting the margins to initial values
+        // would trigger unnecessary layout.
+        newStyle->setMarginStart(style->marginStart());
+        newStyle->setMarginEnd(style->marginRight());
+    }

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

Couldn't we just have a CSS rule to handle that?

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

A CSS rule to handle what, the resetting of the margins?

+    return newStyle;
+}
+
+RenderObject* MarkerPseudoElement::firstNonMarkerChild(RenderObject* parent)
+{
+    RenderObject* result = parent->slowFirstChild();
+    while (result && result->isListMarker())
+        result = result->nextSibling();
+    return result;
+}
+
+void MarkerPseudoElement::removeListMarker()
+{
+    setRenderer(nullptr);
+}
+
+
+RenderObject* MarkerPseudoElement::createRenderer(RenderStyle* style)
+{
+    ASSERT(parentElement()->renderer());
+    RenderListMarker* marker = new RenderListMarker(this, toRenderListItem(parentElement()->renderer()));
+    marker->setStyle(style);
+    return marker;
+}
+
+void MarkerPseudoElement::attachListMarkerRenderer()
+{
+    RenderListItem* parentRenderer = toRenderListItem(parentElement()->renderer());
+    ASSERT(parentRenderer);
+    ASSERT(renderer());
+
+    RenderListMarker* marker = toRenderListMarker(renderer());
+    RenderObject* markerParent = marker->parent();
+
+    RenderObject* insertionRenderer = MarkerPseudoElement::getParentOfFirstLineBox(parentRenderer, marker);
+
+    // We didn't find any line boxes so make the insertion point the LI renderer.
+    if (!insertionRenderer)
+        insertionRenderer = parentRenderer;
+    ASSERT(insertionRenderer);
+
+    // Check if we're already inserted into the right parent as the first child.
+    if (markerParent && marker == markerParent->slowFirstChild()
+        && (markerParent == insertionRenderer || markerParent == insertionRenderer->slowFirstChild()))
+        return;
+
+    marker->remove();
+    insertionRenderer->addChild(marker, MarkerPseudoElement::firstNonMarkerChild(insertionRenderer));
+    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();
+
+    if (marker->isInside())
+        parentRenderer->containingBlock()->updateLogicalWidth();
+}
+
+void MarkerPseudoElement::attach(const AttachContext& context)
+{
+    PseudoElement::attach(context);
+    ASSERT(renderer());
+    toRenderListMarker(renderer())->listItemStyleDidChange();
+}
+
+void MarkerPseudoElement::didRecalcStyle(StyleRecalcChange)
+{
+    attachListMarkerRenderer();
+}
+
+} // namespace blink