[css-display] Support pseudo-elements on display: contents elements.

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc.
  * All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
@@ skipping 1998 matching lines @@
     if (localChange != NoChange) {
       layoutObject->setStyle(newStyle.get());
     } else {
       // Although no change occurred, we use the new style so that the cousin
       // style sharing code won't get fooled into believing this style is the
       // same.
       // FIXME: We may be able to remove this hack, see discussion in
       // https://codereview.chromium.org/30453002/
       layoutObject->setStyleInternal(newStyle.get());
     }
-  } else if (localChange != NoChange &&
-             shouldStoreNonLayoutObjectComputedStyle(*newStyle)) {
-    storeNonLayoutObjectComputedStyle(newStyle);
+  } else {
+    if (localChange != NoChange) {
+      if (shouldStoreNonLayoutObjectComputedStyle(*newStyle))
+        storeNonLayoutObjectComputedStyle(newStyle);
+      else if (hasRareData())
+        elementRareData()->clearComputedStyle();

[rune, 2017/04/04 20:32:40]

I think I've commented on this before ...

Was the missing clearComputedStyle() observable as a bug? For instance, if you
went from display:contents to display:none, did that mean you'd get out-of-date
style for getComputedStyle() on the display:none? If so, it would be good to
have a test for that.

+    }
   }
 
   if (getStyleChangeType() >= SubtreeStyleChange)
     return Force;
 
   if (change > Inherit || localChange > Inherit)
     return max(localChange, change);
 
   if (localChange < IndependentInherit) {
     if (oldStyle->hasChildDependentFlags()) {
@@ skipping 1153 matching lines @@
     elementStyle = rareData.computedStyle();
   }
 
   if (!pseudoElementSpecifier)
     return elementStyle;
 
   if (ComputedStyle* pseudoElementStyle =
           elementStyle->getCachedPseudoStyle(pseudoElementSpecifier))
     return pseudoElementStyle;
 
-  // TODO(ecobos): Passing two times elementStyle may be wrong, though we don't
-  // support display: contents elements' pseudo-elements yet, so this is not a
-  // problem for now.
+  const ComputedStyle* layoutParentStyle = elementStyle;
+  if (hasDisplayContentsStyle()) {
+    LayoutObject* parentLayoutObject =
+        LayoutTreeBuilderTraversal::parentLayoutObject(*this);
+    if (parentLayoutObject)
+      layoutParentStyle = parentLayoutObject->style();
+  }
+
   RefPtr<ComputedStyle> result =
       document().ensureStyleResolver().pseudoStyleForElement(
-          this, PseudoStyleRequest(pseudoElementSpecifier,
-                                   PseudoStyleRequest::ForComputedStyle),
-          elementStyle, elementStyle);
+          this,
+          PseudoStyleRequest(pseudoElementSpecifier,
+                             PseudoStyleRequest::ForComputedStyle),
+          elementStyle, layoutParentStyle);
   DCHECK(result);
   return elementStyle->addCachedPseudoStyle(result.release());
 }
 
 const ComputedStyle* Element::nonLayoutObjectComputedStyle() const {
   if (layoutObject() || !hasRareData())
     return nullptr;
 
   return elementRareData()->computedStyle();
 }
@@ skipping 75 matching lines @@
     // PseudoElement styles hang off their parent element's style so if we
     // needed a style recalc we should Force one on the pseudo.  FIXME: We
     // should figure out the right text sibling to pass.
     element->recalcStyle(change == UpdatePseudoElements ? Force : change);
 
     // Wait until our parent is not displayed or
     // pseudoElementLayoutObjectIsNeeded is false, otherwise we could
     // continuously create and destroy PseudoElements when
     // LayoutObject::isChildAllowed on our parent returns false for the
     // PseudoElement's layoutObject for each style recalc.
-    if (!layoutObject() || !pseudoElementLayoutObjectIsNeeded(
-                               pseudoStyle(PseudoStyleRequest(pseudoId))))
+    if (!canGeneratePseudoElement(pseudoId) ||
+        !pseudoElementLayoutObjectIsNeeded(
+            pseudoStyle(PseudoStyleRequest(pseudoId))))
       elementRareData()->setPseudoElement(pseudoId, nullptr);
   } else if (pseudoId == PseudoIdFirstLetter && element &&
              change >= UpdatePseudoElements &&
              !FirstLetterPseudoElement::firstLetterTextLayoutObject(*element)) {
     // This can happen if we change to a float, for example. We need to cleanup
     // the first-letter pseudoElement and then fix the text of the original
     // remaining text layoutObject.  This can be seen in Test 7 of
     // fast/css/first-letter-removed-added.html
     elementRareData()->setPseudoElement(pseudoId, nullptr);
   } else if (change >= UpdatePseudoElements) {
@@ skipping 105 matching lines @@
     RefPtr<ComputedStyle> result =
         document().ensureStyleResolver().styleForElement(
             this, parentStyle, parentStyle, DisallowStyleSharing);
     result->setStyleType(PseudoIdFirstLineInherited);
     return result.release();
   }
 
   return document().ensureStyleResolver().pseudoStyleForElement(
       this, request, parentStyle, parentStyle);
 }
+// For display: contents elements, we still need to generate ::before and
+// ::after, but the rest of the pseudo-elements should only be used for elements
+// with an actual layout object.
+bool Element::canGeneratePseudoElement(PseudoId pseudoId) const {
+  if (hasDisplayContentsStyle())
+    return pseudoId == PseudoIdBefore || pseudoId == PseudoIdAfter;
+  return !!layoutObject();
+}
 
 bool Element::matches(const AtomicString& selectors,
                       ExceptionState& exceptionState) {
   SelectorQuery* selectorQuery = document().selectorQueryCache().add(
       selectors, document(), exceptionState);
   if (!selectorQuery)
     return false;
   return selectorQuery->matches(*this);
 }
 
@@ skipping 835 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink