Remove RenderObjectChildList::beforePseudoElementRenderer and afterPs…

…eudoElementRenderer

https://bugs.webkit.org/show_bug.cgi?id=106132

Reviewed by Abhishek Arya.

We no longer need the complicated traversals in beforePseudoElementRenderer
and afterPseudoElementRenderer since we can get the renderers of pseudo
elements through the node. This removes all that code and swaps it for
Element::pseudoElementRenderer.

This is possible now that r138850 removed all the now incorrect manual
management of pseudo element renderers from the render tree that was
left over from before the switch to DOM based pseudo elements.

No new tests, just refactoring.

* css/CSSComputedStyleDeclaration.cpp:
(WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
* dom/Element.cpp:
(WebCore::Element::pseudoElementRenderer):
    Added, gets the renderer of the pseudo element by PseudoId if it
    exists.
* dom/Element.h:
(Element):
* dom/NodeRenderingTraversal.cpp:
(WebCore::NodeRenderingTraversal::nextSiblingSlow):
(WebCore::NodeRenderingTraversal::previousSiblingSlow):
* rendering/RenderCounter.cpp:
(WebCore::previousInPreOrder):
(WebCore::previousSiblingOrParent):
(WebCore::nextInPreOrder):
* rendering/RenderObject.h:
(WebCore::RenderObject::lastChild):
* rendering/RenderObjectChildList.cpp:
* rendering/RenderObjectChildList.h:
(RenderObjectChildList):
* rendering/RenderTreeAsText.cpp:
(WebCore::counterValueForElement):


Canonical link: https://commits.webkit.org/124379@main
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@138909 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog

@@ -1,3 +1,44 @@
+2013-01-05  Elliott Sprehn  <esprehn@chromium.org>
+
+        Remove RenderObjectChildList::beforePseudoElementRenderer and afterPseudoElementRenderer
+        https://bugs.webkit.org/show_bug.cgi?id=106132
+
+        Reviewed by Abhishek Arya.
+
+        We no longer need the complicated traversals in beforePseudoElementRenderer
+        and afterPseudoElementRenderer since we can get the renderers of pseudo
+        elements through the node. This removes all that code and swaps it for
+        Element::pseudoElementRenderer.
+
+        This is possible now that r138850 removed all the now incorrect manual
+        management of pseudo element renderers from the render tree that was
+        left over from before the switch to DOM based pseudo elements.
+
+        No new tests, just refactoring.
+
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
+        * dom/Element.cpp:
+        (WebCore::Element::pseudoElementRenderer):
+            Added, gets the renderer of the pseudo element by PseudoId if it
+            exists.
+        * dom/Element.h:
+        (Element):
+        * dom/NodeRenderingTraversal.cpp:
+        (WebCore::NodeRenderingTraversal::nextSiblingSlow):
+        (WebCore::NodeRenderingTraversal::previousSiblingSlow):
+        * rendering/RenderCounter.cpp:
+        (WebCore::previousInPreOrder):
+        (WebCore::previousSiblingOrParent):
+        (WebCore::nextInPreOrder):
+        * rendering/RenderObject.h:
+        (WebCore::RenderObject::lastChild):
+        * rendering/RenderObjectChildList.cpp:
+        * rendering/RenderObjectChildList.h:
+        (RenderObjectChildList):
+        * rendering/RenderTreeAsText.cpp:
+        (WebCore::counterValueForElement):
+
 2013-01-05  Robert Hogan  <robert@webkit.org>
 
         Heap-use-after-free in WebCore::RenderBlock::insertIntoTrackedRendererMaps

Source/WebCore/css/CSSComputedStyleDeclaration.cpp

@@ -1515,12 +1515,8 @@ PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(CSSPropert
     if (!style)
         return 0;
 
-    if (renderer) {
-        if (m_pseudoElementSpecifier == AFTER)
-            renderer = renderer->afterPseudoElementRenderer();
-        else if (m_pseudoElementSpecifier == BEFORE)
-            renderer = renderer->beforePseudoElementRenderer();
-    }
+    if (node->isElementNode() && (m_pseudoElementSpecifier == BEFORE || m_pseudoElementSpecifier == AFTER))
+        renderer = toElement(node)->pseudoElementRenderer(m_pseudoElementSpecifier);
 
     propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style->direction(), style->writingMode());
 

Source/WebCore/dom/Element.cpp

@@ -2171,6 +2171,12 @@ void Element::setPseudoElement(PseudoId pseudoId, PassRefPtr<PseudoElement> elem
     resetNeedsShadowTreeWalker();
 }
 
+RenderObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
+{
+    if (PseudoElement* element = pseudoElement(pseudoId))
+        return element->renderer();
+    return 0;
+}
 
 // ElementTraversal API
 Element* Element::firstElementChild() const

Source/WebCore/dom/Element.h

@@ -368,8 +368,7 @@ class Element : public ContainerNode {
 
     bool hasPseudoElements() const;
     PseudoElement* pseudoElement(PseudoId) const;
-    PseudoElement* beforePseudoElement() const { return pseudoElement(BEFORE); }
-    PseudoElement* afterPseudoElement() const { return pseudoElement(AFTER); }
+    RenderObject* pseudoElementRenderer(PseudoId) const;
     bool childNeedsShadowWalker() const;
     void didShadowTreeAwareChildrenChange();
 

Source/WebCore/dom/NodeRenderingTraversal.cpp

@@ -68,7 +68,7 @@ Node* nextSiblingSlow(const Node* node)
 
     Node* parent = walker.traverseParent(node);
     if (parent && parent->isElementNode())
-        return toElement(parent)->afterPseudoElement();
+        return toElement(parent)->pseudoElement(AFTER);
 
     return 0;
 }
@@ -87,7 +87,7 @@ Node* previousSiblingSlow(const Node* node)
 
     Node* parent = walker.traverseParent(node);
     if (parent && parent->isElementNode())
-        return toElement(parent)->beforePseudoElement();
+        return toElement(parent)->pseudoElement(BEFORE);
 
     return 0;
 }

Source/WebCore/rendering/RenderCounter.cpp

@@ -53,17 +53,8 @@ static CounterMaps& counterMaps()
     return staticCounterMaps;
 }
 
-static RenderObject* rendererOfAfterPseudoElement(RenderObject* renderer)
-{
-    RenderObject* lastContinuation = renderer;
-    while (RenderObject* continuation = lastContinuation->virtualContinuation())
-        lastContinuation = continuation;
-    return lastContinuation->afterPseudoElementRenderer();
-}
-
 // This function processes the renderer tree in the order of the DOM tree
 // including pseudo elements as defined in CSS 2.1.
-// Anonymous renderers are skipped except for those representing pseudo elements.
 static RenderObject* previousInPreOrder(const RenderObject* object)
 {
     Element* parent;
@@ -87,12 +78,12 @@ static RenderObject* previousInPreOrder(const RenderObject* object)
     }
     while (sibling) {
         if (RenderObject* renderer = sibling->renderer()) {
-            if (RenderObject* after = rendererOfAfterPseudoElement(renderer))
+            if (RenderObject* after = sibling->pseudoElementRenderer(AFTER))
                 return after;
             parent = sibling;
             sibling = sibling->lastElementChild();
             if (!sibling) {
-                if (RenderObject* before = renderer->beforePseudoElementRenderer())
+                if (RenderObject* before = toElement(renderer->node())->pseudoElementRenderer(BEFORE))
                     return before;
                 return renderer;
             }
@@ -101,15 +92,13 @@ static RenderObject* previousInPreOrder(const RenderObject* object)
     }
     if (!parent)
         return 0;
-    RenderObject* renderer = parent->renderer(); // Should never be null
-    if (RenderObject* before = renderer->beforePseudoElementRenderer())
+    if (RenderObject* before = parent->pseudoElementRenderer(BEFORE))
         return before;
-    return renderer;
+    return parent->renderer();
 }
 
 // This function processes the renderer tree in the order of the DOM tree
 // including pseudo elements as defined in CSS 2.1.
-// Anonymous renderers are skipped except for those representing pseudo elements.
 static RenderObject* previousSiblingOrParent(const RenderObject* object)
 {
     Element* parent;
@@ -136,13 +125,11 @@ static RenderObject* previousSiblingOrParent(const RenderObject* object)
             return renderer;
         sibling = sibling->previousElementSibling();
     }
-    if (parent) {
-        RenderObject* renderer = parent->renderer();
-        if (RenderObject* before = renderer->virtualChildren()->beforePseudoElementRenderer(renderer))
-            return before;
-        return renderer;
-    }
-    return 0;
+    if (!parent)
+        return 0;
+    if (RenderObject* before = parent->pseudoElementRenderer(BEFORE))
+        return before;
+    return parent->renderer();
 }
 
 static Element* parentElement(RenderObject* object)
@@ -167,21 +154,18 @@ static inline bool areRenderersElementsSiblings(RenderObject* first, RenderObjec
 
 // This function processes the renderer tree in the order of the DOM tree
 // including pseudo elements as defined in CSS 2.1.
-// Anonymous renderers are skipped except for those representing pseudo elements.
 static RenderObject* nextInPreOrder(const RenderObject* object, const Element* stayWithin, bool skipDescendants = false)
 {
     Element* self;
     Element* child;
-    RenderObject* result;
     self = toElement(object->generatingNode());
     if (skipDescendants)
         goto nextsibling;
     switch (object->style()->styleType()) {
     case NOPSEUDO:
         ASSERT(!object->isAnonymous());
-        result = object->beforePseudoElementRenderer();
-        if (result)
-            return result;
+        if (RenderObject* before = self->pseudoElementRenderer(BEFORE))
+            return before;
         break;
     case BEFORE:
         break;
@@ -194,14 +178,12 @@ static RenderObject* nextInPreOrder(const RenderObject* object, const Element* s
     child = ElementTraversal::firstWithin(self);
     while (true) {
         while (child) {
-            result = child->renderer();
-            if (result)
-                return result;
+            if (RenderObject* renderer = child->renderer())
+                return renderer;
             child = ElementTraversal::nextSkippingChildren(child, self);
         }
-        result = rendererOfAfterPseudoElement(self->renderer());
-        if (result)
-            return result;
+        if (RenderObject* after = self->pseudoElementRenderer(AFTER))
+            return after;
 nextsibling:
         if (self == stayWithin)
             return 0;

Source/WebCore/rendering/RenderObject.h

@@ -185,22 +185,6 @@ class RenderObject : public CachedImageClient {
             return children->lastChild();
         return 0;
     }
-    RenderObject* beforePseudoElementRenderer() const
-    {
-        if (const RenderObjectChildList* children = virtualChildren())
-            return children->beforePseudoElementRenderer(this);
-        return 0;
-    }
-
-    // This function only returns the renderer of the "after" pseudoElement if it is a child of
-    // this renderer. If "continuations" exist, the function returns 0 even if the element that
-    // generated this renderer has an "after" pseudo-element.
-    RenderObject* afterPseudoElementRenderer() const
-    {
-        if (const RenderObjectChildList* children = virtualChildren())
-            return children->afterPseudoElementRenderer(this);
-        return 0;
-    }
 
     virtual RenderObjectChildList* virtualChildren() { return 0; }
     virtual const RenderObjectChildList* virtualChildren() const { return 0; }

Source/WebCore/rendering/RenderObjectChildList.cpp

@@ -185,50 +185,4 @@ void RenderObjectChildList::insertChildNode(RenderObject* owner, RenderObject* c
         owner->document()->axObjectCache()->childrenChanged(owner);
 }
 
-RenderObject* RenderObjectChildList::beforePseudoElementRenderer(const RenderObject* owner) const
-{
-    // An anonymous (generated) inline run-in that has PseudoId BEFORE must come from a grandparent.
-    // Therefore we should skip these generated run-ins when checking our immediate children.
-    // If we don't find our :before child immediately, then we should check if we own a
-    // generated inline run-in in the next level of children.
-    RenderObject* first = const_cast<RenderObject*>(owner);
-    do {
-        first = first->firstChild();
-        // Skip list markers and generated run-ins.
-        while (first && (first->isListMarker() || (first->isRenderInline() && first->isRunIn())))
-            first = first->nextInPreOrderAfterChildren(owner);
-    } while (first && first->isAnonymous() && first->style()->styleType() == NOPSEUDO);
-
-    if (!first)
-        return 0;
-
-    if (first->isBeforeContent())
-        return first;
-
-    // Check for a possible generated run-in, using run-in positioning rules.
-    first = owner->firstChild();
-    if (!first->isRenderBlock())
-        return 0;
-
-    first = first->firstChild();
-    // We still need to skip any list markers that could exist before the run-in.
-    while (first && first->isListMarker())
-        first = first->nextSibling();
-    if (first && first->isBeforeContent() && first->isRenderInline() && first->isRunIn())
-        return first;
-
-    return 0;
-}
-
-RenderObject* RenderObjectChildList::afterPseudoElementRenderer(const RenderObject* owner) const
-{
-    RenderObject* last = const_cast<RenderObject*>(owner);
-    do {
-        last = last->lastChild();
-    } while (last && last->isAnonymous() && last->style()->styleType() == NOPSEUDO && !last->isListMarker());
-    if (last && !last->isAfterContent())
-        return 0;
-    return last;
-}
-
 } // namespace WebCore

Source/WebCore/rendering/RenderObjectChildList.h

@@ -55,9 +55,6 @@ class RenderObjectChildList {
     void appendChildNode(RenderObject* owner, RenderObject*, bool notifyRenderer = true);
     void insertChildNode(RenderObject* owner, RenderObject* child, RenderObject* before, bool notifyRenderer = true);
 
-    RenderObject* beforePseudoElementRenderer(const RenderObject* owner) const;
-    RenderObject* afterPseudoElementRenderer(const RenderObject* owner) const;
-
 private:
     RenderObject* m_firstChild;
     RenderObject* m_lastChild;

Source/WebCore/rendering/RenderTreeAsText.cpp

@@ -901,12 +901,10 @@ String counterValueForElement(Element* element)
     TextStream stream;
     bool isFirstCounter = true;
     // The counter renderers should be children of :before or :after pseudo-elements.
-    if (RenderObject* renderer = element->renderer()) {
-        if (RenderObject* pseudoElement = renderer->beforePseudoElementRenderer())
-            writeCounterValuesFromChildren(stream, pseudoElement, isFirstCounter);
-        if (RenderObject* pseudoElement = renderer->afterPseudoElementRenderer())
-            writeCounterValuesFromChildren(stream, pseudoElement, isFirstCounter);
-    }
+    if (RenderObject* before = element->pseudoElementRenderer(BEFORE))
+        writeCounterValuesFromChildren(stream, before, isFirstCounter);
+    if (RenderObject* after = element->pseudoElementRenderer(AFTER))
+        writeCounterValuesFromChildren(stream, after, isFirstCounter);
     return stream.release();
 }