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

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

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/dom/PseudoElement.h"
 
 #include "core/dom/FirstLetterPseudoElement.h"
+#include "core/dom/NodeComputedStyle.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutQuote.h"
 #include "core/style/ContentData.h"
 
 namespace blink {
 
 PseudoElement* PseudoElement::create(Element* parent, PseudoId pseudoId) {
   return new PseudoElement(parent, pseudoId);
@@ skipping 50 matching lines @@
   parent->treeScope().adoptIfNeeded(*this);
   setParentOrShadowHostNode(parent);
   setHasCustomStyleCallbacks();
   if ((pseudoId == PseudoIdBefore || pseudoId == PseudoIdAfter) &&
       parent->hasTagName(HTMLNames::inputTag))
     UseCounter::count(parent->document(),
                       UseCounter::PseudoBeforeAfterForInputElement);
 }
 
 PassRefPtr<ComputedStyle> PseudoElement::customStyleForLayoutObject() {
-  return parentOrShadowHostElement()->layoutObject()->getCachedPseudoStyle(
-      m_pseudoId);
+  return parentOrShadowHostElement()->pseudoStyle(m_pseudoId);
 }
 
 void PseudoElement::dispose() {
   DCHECK(parentOrShadowHostElement());
 
   probe::pseudoElementDestroyed(this);
 
   DCHECK(!nextSibling());
   DCHECK(!previousSibling());
 
   detachLayoutTree();
   Element* parent = parentOrShadowHostElement();
   document().adoptIfNeeded(*this);
   setParentOrShadowHostNode(0);
   removedFrom(parent);
 }
 
 void PseudoElement::attachLayoutTree(const AttachContext& context) {
   DCHECK(!layoutObject());
 
   Element::attachLayoutTree(context);
 
-  LayoutObject* layoutObject = this->layoutObject();
-  if (!layoutObject)
+  ComputedStyle* style = mutableComputedStyle();
+  if (!style || (style->styleType() != PseudoIdBefore &&
+                 style->styleType() != PseudoIdAfter))
     return;
 
-  ComputedStyle& style = layoutObject->mutableStyleRef();
-  if (style.styleType() != PseudoIdBefore && style.styleType() != PseudoIdAfter)
-    return;
-  DCHECK(style.contentData());
+  DCHECK(style->contentData());
 
-  for (const ContentData* content = style.contentData(); content;
+  LayoutObject* parentLayoutObject = layoutObject();
+  if (!parentLayoutObject)
+    parentLayoutObject = LayoutTreeBuilderTraversal::parentLayoutObject(*this);
+
+  for (const ContentData* content = style->contentData(); content;
        content = content->next()) {
-    LayoutObject* child = content->createLayoutObject(document(), style);
-    if (layoutObject->isChildAllowed(child, style)) {
-      layoutObject->addChild(child);
+    LayoutObject* child = content->createLayoutObject(*this, *style);
+    if (parentLayoutObject->isChildAllowed(child, *style)) {
+      parentLayoutObject->addChild(child);
+      DCHECK(child->isPseudoElementGeneratedContentFor(*this));
       if (child->isQuote())
         toLayoutQuote(child)->attachQuote();
     } else {
       child->destroy();
     }
   }
 }
 
+void PseudoElement::detachLayoutTree(const AttachContext& context) {
+  Element::detachLayoutTree(context);
+}
+
 bool PseudoElement::layoutObjectIsNeeded(const ComputedStyle& style) {
   return pseudoElementLayoutObjectIsNeeded(&style);
 }
 
+static bool isGeneratedContentLike(LayoutObject* layoutObject) {
+  if (!layoutObject->isAnonymous())
+    return false;
+  return layoutObject->isText() || layoutObject->isQuote() ||
+         layoutObject->isImage();
+}
+
+static void updateGeneratedContentStyleIn(LayoutObject* root,
+                                          ComputedStyle* style) {
+  for (LayoutObject* child = root; child; child = child->nextInPreOrder(root)) {
+    if (isGeneratedContentLike(child))
+      child->setPseudoStyle(style);
+  }
+}
+
 void PseudoElement::didRecalcStyle() {
-  if (!layoutObject())
-    return;
-
   // The layoutObjects inside pseudo elements are anonymous so they don't get
   // notified of recalcStyle and must have the style propagated downward
   // manually similar to LayoutObject::propagateStyleToAnonymousChildren.
-  LayoutObject* layoutObject = this->layoutObject();
-  for (LayoutObject* child = layoutObject->nextInPreOrder(layoutObject); child;
-       child = child->nextInPreOrder(layoutObject)) {
-    // We only manage the style for the generated content items.
-    if (!child->isText() && !child->isQuote() && !child->isImage())
-      continue;
+  if (LayoutObject* layoutObject = this->layoutObject()) {
+    updateGeneratedContentStyleIn(layoutObject, layoutObject->mutableStyle());
+  } else if (hasDisplayContentsStyle()) {
+    DCHECK(m_pseudoId == PseudoIdBefore || m_pseudoId == PseudoIdAfter);
 
-    child->setPseudoStyle(layoutObject->mutableStyle());
+    LayoutObject* layoutParent =
+        LayoutTreeBuilderTraversal::parentLayoutObject(*this);
+    if (!layoutParent)
+      return;
+
+    const bool isBefore = m_pseudoId == PseudoIdBefore;
+    ComputedStyle* style = mutableComputedStyle();
+    LayoutObject* child = isBefore ? layoutParent->slowFirstChild()
+                                   : layoutParent->slowLastChild();
+
+    bool foundGeneratedContent = false;
+    while (child) {
+      bool isThisPseudoContent =
+          child->isPseudoElementGeneratedContentFor(*this);
+      if (isThisPseudoContent)
+        foundGeneratedContent = true;
+      else if (foundGeneratedContent)
+        break;
+
+      if (isThisPseudoContent) {
+        updateGeneratedContentStyleIn(child, style);
+        child = isBefore ? child->nextSibling() : child->previousSibling();
+      } else {
+        child = isBefore ? child->nextInPreOrder(layoutParent)
+                         : child->previousInPreOrder(layoutParent);
+      }
+    }
+
+    DCHECK(foundGeneratedContent);
   }
 }
 
 // With PseudoElements the DOM tree and Layout tree can differ. When you attach
 // a, first-letter for example, into the DOM we walk down the Layout
 // tree to find the correct insertion point for the LayoutObject. But, this
 // means if we ask for the parentOrShadowHost Node from the first-letter
 // pseudo element we will get some arbitrary ancestor of the LayoutObject.
 //
 // For hit testing, we need the parent Node of the LayoutObject for the
@@ skipping 14 matching lines @@
   LayoutObject* ancestor = layoutObject()->parent();
   while (ancestor->isAnonymous() ||
          (ancestor->node() && ancestor->node()->isPseudoElement())) {
     DCHECK(ancestor->parent());
     ancestor = ancestor->parent();
   }
   return ancestor->node();
 }
 
 }  // namespace blink