Support display: contents for elements, first-line and first-letter pseudos.

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 1511 matching lines @@
     return parent->locateNamespacePrefix(namespaceToLocate);
 
   return nullAtom;
 }
 
 const AtomicString Element::imageSourceURL() const {
   return getAttribute(srcAttr);
 }
 
 bool Element::layoutObjectIsNeeded(const ComputedStyle& style) {
-  return style.display() != EDisplay::None;
+  return style.display() != EDisplay::None &&
+         style.display() != EDisplay::Contents;
 }
 
 LayoutObject* Element::createLayoutObject(const ComputedStyle& style) {
   return LayoutObject::createObject(this, style);
 }
 
 Node::InsertionNotificationRequest Element::insertedInto(
     ContainerNode* insertionPoint) {
   // need to do superclass processing first so isConnected() is true
   // by the time we reach updateId
@@ skipping 117 matching lines @@
 void Element::attachLayoutTree(const AttachContext& context) {
   DCHECK(document().inStyleRecalc());
 
   // We've already been through detach when doing an attach, but we might
   // need to clear any state that's been added since then.
   if (hasRareData() && getStyleChangeType() == NeedsReattachStyleChange) {
     ElementRareData* data = elementRareData();
     data->clearComputedStyle();
   }
 
-  if (!isActiveSlotOrActiveInsertionPoint())
-    LayoutTreeBuilderForElement(*this, context.resolvedStyle)
-        .createLayoutObjectIfNeeded();
+  if (!isActiveSlotOrActiveInsertionPoint()) {
+    LayoutTreeBuilderForElement builder(*this, context.resolvedStyle);
+    builder.createLayoutObjectIfNeeded();
+
+    if (ComputedStyle* style = builder.resolvedStyle()) {
+      if (!layoutObject() && shouldStoreNonLayoutObjectComputedStyle(*style))
+        storeNonLayoutObjectComputedStyle(style);
+    }
+  }
 
   addCallbackSelectors();
 
   if (hasRareData() && !layoutObject()) {
     if (ElementAnimations* elementAnimations =
             elementRareData()->elementAnimations()) {
       elementAnimations->cssAnimations().cancel();
       elementAnimations->setAnimationStyleChange(false);
     }
   }
 
   SelectorFilterParentScope filterScope(*this);
   StyleSharingDepthScope sharingScope(*this);
 
   createPseudoElementIfNeeded(PseudoIdBefore);
 
   // When a shadow root exists, it does the work of attaching the children.
   if (ElementShadow* shadow = this->shadow())
     shadow->attach(context);
 
   ContainerNode::attachLayoutTree(context);
 
+  // Quite unfortunately, if we're a display: contents node reattaching our
+  // subtree we need to reattach the parent's *after* attaching all our
+  // children. We might be able to be more granular here, but otherwise we don't
+  // always properly rebuild the layout tree due to anonymous boxes, for
+  // example. See css-display-3/display-contents-reattachment.html, which fails
+  // without this, for example, due to misplaced flex anonymous blocks.
+  //
+  // Also, don't do it if we're a pseudo-element, because it's pointless and
+  // causes infinite recursion if the parent doesn't have display: contents.
+  if (hasDisplayContentsStyle() && !isPseudoElement() && parentNode() &&
+      !parentNode()->needsAttach()) {
+    parentNode()->reattachLayoutTree();
+    DCHECK(!needsAttach());
+    return;
+  }
+
   createPseudoElementIfNeeded(PseudoIdAfter);
   createPseudoElementIfNeeded(PseudoIdBackdrop);
 
   // We create the first-letter element after the :before, :after and
   // children are attached because the first letter text could come
   // from any of them.
   createPseudoElementIfNeeded(PseudoIdFirstLetter);
 }
 
 void Element::detachLayoutTree(const AttachContext& context) {
@@ skipping 254 matching lines @@
         svgFilterNeedsLayerUpdate()) {
       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);
   }
 
   if (getStyleChangeType() >= SubtreeStyleChange)
     return Force;
 
   if (change > Inherit || localChange > Inherit)
     return max(localChange, change);
 
   if (localChange < IndependentInherit) {
     if (oldStyle->hasChildDependentFlags()) {
@@ skipping 1142 matching lines @@
 
   RefPtr<ComputedStyle> result =
       document().ensureStyleResolver().pseudoStyleForElement(
           this, PseudoStyleRequest(pseudoElementSpecifier,
                                    PseudoStyleRequest::ForComputedStyle),
           elementStyle);
   DCHECK(result);
   return elementStyle->addCachedPseudoStyle(result.release());
 }
 
+const ComputedStyle* Element::nonLayoutObjectComputedStyle() const {
+  if (layoutObject() || !hasRareData())
+    return nullptr;
+
+  return elementRareData()->computedStyle();
+}
+
+bool Element::hasDisplayContentsStyle() const {
+  if (const ComputedStyle* style = nonLayoutObjectComputedStyle())
+    return style->display() == EDisplay::Contents;
+  return false;
+}
+
+bool Element::shouldStoreNonLayoutObjectComputedStyle(
+    const ComputedStyle& style) const {
+#if DCHECK_IS_ON()
+  if (style.display() == EDisplay::Contents)
+    DCHECK(!layoutObject());
+#endif
+
+  return style.display() == EDisplay::Contents ||
+         isHTMLOptGroupElement(*this) || isHTMLOptionElement(*this);
+}
+
+void Element::storeNonLayoutObjectComputedStyle(
+    PassRefPtr<ComputedStyle> style) {
+  DCHECK(style);
+  DCHECK(shouldStoreNonLayoutObjectComputedStyle(*style));
+  ensureElementRareData().setComputedStyle(std::move(style));
+}
+
+void Element::clearNonLayoutObjectComputedStyle() {
+  DCHECK(nonLayoutObjectComputedStyle());
+  elementRareData()->clearComputedStyle();
+}
+
 AtomicString Element::computeInheritedLanguage() const {
   const Node* n = this;
   AtomicString value;
   // The language property is inherited, so we iterate over the parents to find
   // the first language.
   do {
     if (n->isElementNode()) {
       if (const ElementData* elementData = toElement(n)->elementData()) {
         AttributeCollection attributes = elementData->attributes();
         // Spec: xml:lang takes precedence -- http://www.w3.org/TR/xhtml1/#C_7
@@ skipping 715 matching lines @@
       StyleChangeReasonForTracing::create(StyleChangeReason::StyleSheetChange));
   InspectorInstrumentation::didInvalidateStyleAttr(this);
 }
 
 void Element::inlineStyleChanged() {
   DCHECK(isStyledElement());
   setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(
                                             StyleChangeReason::Inline));
   DCHECK(elementData());
   elementData()->m_styleAttributeIsDirty = true;
+
   InspectorInstrumentation::didInvalidateStyleAttr(this);
 
   if (MutationObserverInterestGroup* recipients =
           MutationObserverInterestGroup::createForAttributesMutation(
               *this, styleAttr)) {
     // We don't use getAttribute() here to get a style attribute value
     // before the change.
     AtomicString oldValue;
     if (const Attribute* attribute =
             elementData()->attributes().find(styleAttr))
@@ skipping 212 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink