Changeset 138909 in webkit

Timestamp:

Jan 5, 2013 3:07:05 PM (11 years ago)

Author:

esprehn@chromium.org

Message:

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):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSComputedStyleDeclaration.cpp (modified) (1 diff)
• dom/Element.cpp (modified) (1 diff)
• dom/Element.h (modified) (1 diff)
• dom/NodeRenderingTraversal.cpp (modified) (2 diffs)
• rendering/RenderCounter.cpp (modified) (7 diffs)
• rendering/RenderObject.h (modified) (1 diff)
• rendering/RenderObjectChildList.cpp (modified) (1 diff)
• rendering/RenderObjectChildList.h (modified) (1 diff)
• rendering/RenderTreeAsText.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+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>
 

trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp

@@ -1516 +1516 @@
         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());

trunk/Source/WebCore/dom/Element.cpp

@@ -2172 +2172 @@
 }
 
+RenderObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
+{
+    if (PseudoElement* element = pseudoElement(pseudoId))
+        return element->renderer();
+    return 0;
+}
 
 // ElementTraversal API

trunk/Source/WebCore/dom/Element.h

@@ -369 +369 @@
     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();

trunk/Source/WebCore/dom/NodeRenderingTraversal.cpp

@@ -69 +69 @@
     Node* parent = walker.traverseParent(node);
     if (parent && parent->isElementNode())
-        return toElement(parent)->afterPseudoElement();
+        return toElement(parent)->pseudoElement(AFTER);
 
     return 0;
@@ -88 +88 @@
     Node* parent = walker.traverseParent(node);
     if (parent && parent->isElementNode())
-        return toElement(parent)->beforePseudoElement();
+        return toElement(parent)->pseudoElement(BEFORE);
 
     return 0;

trunk/Source/WebCore/rendering/RenderCounter.cpp

@@ -54 +54 @@
 }
 
-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)
 {
@@ -88 +79 @@
     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;
@@ -102 +93 @@
     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)
 {
@@ -137 +126 @@
         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();
 }
 
@@ -168 +155 @@
 // 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)
@@ -180 +165 @@
     case NOPSEUDO:
         ASSERT(!object->isAnonymous());
-        result = object->beforePseudoElementRenderer();
-        if (result)
-            return result;
+        if (RenderObject* before = self->pseudoElementRenderer(BEFORE))
+            return before;
         break;
     case BEFORE:
@@ -195 +179 @@
     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)

trunk/Source/WebCore/rendering/RenderObject.h

@@ -184 +184 @@
         if (const RenderObjectChildList* children = virtualChildren())
             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;
     }

trunk/Source/WebCore/rendering/RenderObjectChildList.cpp

@@ -186 +186 @@
 }
 
-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

trunk/Source/WebCore/rendering/RenderObjectChildList.h

@@ -56 +56 @@
     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;

trunk/Source/WebCore/rendering/RenderTreeAsText.cpp

@@ -902 +902 @@
     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();
 }