Changeset 223748 in webkit

Timestamp:

Oct 20, 2017 1:29:03 AM (7 years ago)

Author:

Antti Koivisto

Message:

Support ::before/::after pseudo elements on elements with display:contents
​https://bugs.webkit.org/show_bug.cgi?id=178513

Reviewed by Ryosuke Niwa.

LayoutTests/imported/w3c:

• web-platform-tests/cssom/getComputedStyle-pseudo-expected.txt:

Source/WebCore:

Add support for

div { display:contents }
div::after { content:'foo' }

That is support non-box generating elements with generated content.

• style/RenderTreePosition.cpp:

(WebCore::RenderTreePosition::nextSiblingRenderer const):

Implement full pseudo-inclusive traversal starting from any element (including pseudo)
to locate the next rendering sibling. In case of display:content this may need to look
into descendants.

• style/RenderTreeUpdater.cpp:

(WebCore::textRendererIsNeeded):

RenderTreePosition::nextSiblingRenderer can no longer be called with a node that already has a renderer.
Maintain the existing behavior.

• style/RenderTreeUpdaterGeneratedContent.cpp:

(WebCore::RenderTreeUpdater::GeneratedContent::updatePseudoElement):
(WebCore::RenderTreeUpdater::GeneratedContent::needsPseudoElement):

Don't require for host to have a renderer.

• style/RenderTreeUpdaterGeneratedContent.h:
• style/StyleTreeResolver.cpp:

(WebCore::Style::TreeResolver::resolvePseudoStyle):

LayoutTests:

• TestExpectations: Enable imported/w3c/web-platform-tests/css/css-display-3/display-contents-before-after-001.html

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/TestExpectations (modified) (1 diff)
• LayoutTests/imported/w3c/ChangeLog (modified) (1 diff)
• LayoutTests/imported/w3c/web-platform-tests/cssom/getComputedStyle-pseudo-expected.txt (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/style/RenderTreePosition.cpp (modified) (1 diff)
• Source/WebCore/style/RenderTreeUpdater.cpp (modified) (1 diff)
• Source/WebCore/style/RenderTreeUpdaterGeneratedContent.cpp (modified) (2 diffs)
• Source/WebCore/style/RenderTreeUpdaterGeneratedContent.h (modified) (1 diff)
• Source/WebCore/style/StyleTreeResolver.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2017-10-19  Antti Koivisto  <antti@apple.com>
+
+        Support ::before/::after pseudo elements on elements with display:contents
+        https://bugs.webkit.org/show_bug.cgi?id=178513
+
+        Reviewed by Ryosuke Niwa.
+
+        * TestExpectations: Enable imported/w3c/web-platform-tests/css/css-display-3/display-contents-before-after-001.html
+
 2017-10-20  Yusuke Suzuki  <utatane.tea@gmail.com>
 

trunk/LayoutTests/TestExpectations

@@ -1274 +1274 @@
 webkit.org/b/157477 imported/w3c/web-platform-tests/css/css-display-3/display-contents-dynamic-flex-002-none.html [ ImageOnlyFailure ]
 webkit.org/b/157477 imported/w3c/web-platform-tests/css/css-display-3/display-contents-flex-002.html [ ImageOnlyFailure ]
-webkit.org/b/157477 imported/w3c/web-platform-tests/css/css-display-3/display-contents-before-after-001.html [ ImageOnlyFailure ]
 webkit.org/b/157477 imported/w3c/web-platform-tests/css/css-display-3/display-flow-root-001.html [ ImageOnlyFailure ]
 webkit.org/b/157477 imported/w3c/web-platform-tests/css/css-display-3/display-contents-dynamic-flex-003-none.html [ ImageOnlyFailure ]

trunk/LayoutTests/imported/w3c/ChangeLog

@@ +1 @@
+2017-10-19  Antti Koivisto  <antti@apple.com>
+
+        Support ::before/::after pseudo elements on elements with display:contents
+        https://bugs.webkit.org/show_bug.cgi?id=178513
+
+        Reviewed by Ryosuke Niwa.
+
+        * web-platform-tests/cssom/getComputedStyle-pseudo-expected.txt:
+
 2017-10-19  Andy Estes  <aestes@apple.com>
 

trunk/LayoutTests/imported/w3c/web-platform-tests/cssom/getComputedStyle-pseudo-expected.txt

@@ -1 +1 @@
 
 PASS Resolution of width is correct for ::before and ::after pseudo-elements 
-FAIL Resolution of width is correct for ::before and ::after pseudo-elements of display: contents elements assert_equals: expected "50px" but got "50%"
+PASS Resolution of width is correct for ::before and ::after pseudo-elements of display: contents elements 
 PASS Resolution of nonexistent pseudo-element styles 
 FAIL Resolution of pseudo-element styles in display: none elements assert_equals: Pseudo-styles of display: none elements should be correct expected "\"Foo\"" but got "Foo"

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-10-19  Antti Koivisto  <antti@apple.com>
+
+        Support ::before/::after pseudo elements on elements with display:contents
+        https://bugs.webkit.org/show_bug.cgi?id=178513
+
+        Reviewed by Ryosuke Niwa.
+
+        Add support for
+
+            div { display:contents }
+            div::after { content:'foo' }
+
+        That is support non-box generating elements with generated content.
+
+        * style/RenderTreePosition.cpp:
+        (WebCore::RenderTreePosition::nextSiblingRenderer const):
+
+            Implement full pseudo-inclusive traversal starting from any element (including pseudo)
+            to locate the next rendering sibling. In case of display:content this may need to look
+            into descendants.
+
+        * style/RenderTreeUpdater.cpp:
+        (WebCore::textRendererIsNeeded):
+
+            RenderTreePosition::nextSiblingRenderer can no longer be called with a node that already has a renderer.
+            Maintain the existing behavior.
+
+        * style/RenderTreeUpdaterGeneratedContent.cpp:
+        (WebCore::RenderTreeUpdater::GeneratedContent::updatePseudoElement):
+        (WebCore::RenderTreeUpdater::GeneratedContent::needsPseudoElement):
+
+            Don't require for host to have a renderer.
+
+        * style/RenderTreeUpdaterGeneratedContent.h:
+        * style/StyleTreeResolver.cpp:
+        (WebCore::Style::TreeResolver::resolvePseudoStyle):
+
 2017-10-20  Keith Miller  <keith_miller@apple.com>
 

trunk/Source/WebCore/style/RenderTreePosition.cpp

@@ -76 +76 @@
 RenderObject* RenderTreePosition::nextSiblingRenderer(const Node& node) const
 {
+    ASSERT(!node.renderer());
+
     auto* parentElement = m_parent.element();
     if (!parentElement)
         return nullptr;
-    if (node.isAfterPseudoElement())
+    // FIXME: PlugingReplacement shadow trees are very wrong.
+    if (parentElement == &node)
         return nullptr;
 
+    Vector<Element*, 30> elementStack;
+
+    // In the common case ancestor == parentElement immediately and this just pushes parentElement into stack.
+    auto* ancestor = is<PseudoElement>(node) ? downcast<PseudoElement>(node).hostElement() : node.parentElementInComposedTree();
+    while (true) {
+        elementStack.append(ancestor);
+        if (ancestor == parentElement)
+            break;
+        ancestor = ancestor->parentElementInComposedTree();
+        ASSERT(ancestor);
+    }
+    elementStack.reverse();
+
     auto composedDescendants = composedTreeDescendants(*parentElement);
-    auto it = node.isBeforePseudoElement() ? composedDescendants.begin() : composedDescendants.at(node);
+
+    auto initializeIteratorConsideringPseudoElements = [&] {
+        if (is<PseudoElement>(node)) {
+            auto* host = downcast<PseudoElement>(node).hostElement();
+            if (node.isBeforePseudoElement()) {
+                if (host != parentElement)
+                    return composedDescendants.at(*host).traverseNext();
+                return composedDescendants.begin();
+            }
+            ASSERT(node.isAfterPseudoElement());
+            elementStack.removeLast();
+            if (host != parentElement)
+                return composedDescendants.at(*host).traverseNextSkippingChildren();
+            return composedDescendants.end();
+        }
+        return composedDescendants.at(node).traverseNextSkippingChildren();
+    };
+
+    auto pushCheckingForAfterPseudoElementRenderer = [&] (Element& element) -> RenderElement* {
+        ASSERT(!element.isPseudoElement());
+        if (auto* before = element.beforePseudoElement()) {
+            if (auto* renderer = before->renderer())
+                return renderer;
+        }
+        elementStack.append(&element);
+        return nullptr;
+    };
+
+    auto popCheckingForAfterPseudoElementRenderers = [&] (unsigned iteratorDepthToMatch) -> RenderElement* {
+        while (elementStack.size() > iteratorDepthToMatch) {
+            auto& element = *elementStack.takeLast();
+            if (auto* after = element.afterPseudoElement()) {
+                if (auto* renderer = after->renderer())
+                    return renderer;
+            }
+        }
+        return nullptr;
+    };
+
+    auto it = initializeIteratorConsideringPseudoElements();
     auto end = composedDescendants.end();
 
     while (it != end) {
-        auto& node = *it;
-        bool hasDisplayContents = is<Element>(node) && downcast<Element>(node).hasDisplayContents();
-        if (hasDisplayContents) {
-            it.traverseNext();
-            continue;
-        }
+        if (auto* renderer = popCheckingForAfterPseudoElementRenderers(it.depth()))
+            return renderer;
+
         if (auto* renderer = it->renderer())
             return renderer;
-        
+
+        if (is<Element>(*it)) {
+            auto& element = downcast<Element>(*it);
+            if (element.hasDisplayContents()) {
+                if (auto* renderer = pushCheckingForAfterPseudoElementRenderer(element))
+                    return renderer;
+                it.traverseNext();
+                continue;
+            }
+        }
+
         it.traverseNextSkippingChildren();
     }
-    if (PseudoElement* after = parentElement->afterPseudoElement())
-        return after->renderer();
-    return nullptr;
+
+    return popCheckingForAfterPseudoElementRenderers(0);
 }
 

trunk/Source/WebCore/style/RenderTreeUpdater.cpp

@@ -419 +419 @@
         while (first && first->isFloatingOrOutOfFlowPositioned())
             first = first->nextSibling();
-        RenderObject* nextRenderer = renderTreePosition.nextSiblingRenderer(textNode);
+        RenderObject* nextRenderer = textNode.renderer() ? textNode.renderer() : renderTreePosition.nextSiblingRenderer(textNode);
         if (!first || nextRenderer == first) {
             // Whitespace at the start of a block just goes away. Don't even make a render object for this text.

trunk/Source/WebCore/style/RenderTreeUpdaterGeneratedContent.cpp

@@ -100 +100 @@
         m_updater.renderTreePosition().invalidateNextSibling(*renderer);
 
-    if (!needsPseudoElement(current, update)) {
+    if (!needsPseudoElement(update)) {
         if (pseudoElement) {
             if (pseudoId == BEFORE)
@@ -145 +145 @@
 }
 
-bool RenderTreeUpdater::GeneratedContent::needsPseudoElement(Element& current, const std::optional<Style::ElementUpdate>& update)
+bool RenderTreeUpdater::GeneratedContent::needsPseudoElement(const std::optional<Style::ElementUpdate>& update)
 {
-    ASSERT(!current.isPseudoElement());
     if (!update)
         return false;
-    if (!current.renderer() || !current.renderer()->canHaveGeneratedChildren())
+    if (!m_updater.renderTreePosition().parent().canHaveGeneratedChildren())
         return false;
     if (!pseudoElementRendererIsNeeded(update->style.get()))

trunk/Source/WebCore/style/RenderTreeUpdaterGeneratedContent.h

@@ -44 +44 @@
     void updateQuotesUpTo(RenderQuote*);
     
-    static bool needsPseudoElement(Element&, const std::optional<Style::ElementUpdate>&);
+    bool needsPseudoElement(const std::optional<Style::ElementUpdate>&);
 
     RenderTreeUpdater& m_updater;

trunk/Source/WebCore/style/StyleTreeResolver.cpp

@@ -228 +228 @@
 ElementUpdate TreeResolver::resolvePseudoStyle(Element& element, const ElementUpdate& elementUpdate, PseudoId pseudoId)
 {
+    if (elementUpdate.style->display() == NONE)
+        return { };
     if (!elementUpdate.style->hasPseudoStyle(pseudoId))
         return { };