Update styleRecalc so that it traverses shadow insertion points in 2 pass algorithms

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)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1489 matching lines @@
 
     return originalStyleForRenderer();
 }
 
 PassRefPtr<RenderStyle> Element::originalStyleForRenderer()
 {
     ASSERT(document().inStyleRecalc());
     return document().ensureStyleResolver().styleForElement(this);
 }
 
-void Element::recalcStyle(StyleRecalcChange change, Text* nextTextSibling)
+void Element::recalcStyle(StyleRecalcChange change, Text* nextTextSibling, InsertionPoint* shadowInsertionPoint)
 {
     ASSERT(document().inStyleRecalc());
     ASSERT(!parentOrShadowHostNode()->needsStyleRecalc());
 
     if (hasCustomStyleCallbacks())
         willRecalcStyle(change);
 
     if (change >= Inherit || needsStyleRecalc()) {
         if (hasRareData()) {
             ElementRareData* data = elementRareData();
             data->resetStyleState();
             data->clearComputedStyle();
         }
         if (parentRenderStyle())
             change = recalcOwnStyle(change);
         clearNeedsStyleRecalc();
     }
 
-    // If we reattached we don't need to recalc the style of our descendants anymore.
-    if ((change >= Inherit && change < Reattach) || childNeedsStyleRecalc())
-        recalcChildStyle(change);
-    clearChildNeedsStyleRecalc();
+    if (this != shadowInsertionPoint) {
+        // If we reattached we don't need to recalc the style of our descendants anymore.
+        if ((change >= Inherit && change < Reattach) || childNeedsStyleRecalc())
+            recalcChildStyle(change, shadowInsertionPoint);
+        clearChildNeedsStyleRecalc();
+    }
 
     if (hasCustomStyleCallbacks())
         didRecalcStyle(change);
 
     if (change == Reattach)
         reattachWhitespaceSiblings(nextTextSibling);
 }
 
 StyleRecalcChange Element::recalcOwnStyle(StyleRecalcChange change)
 {
@@ skipping 45 matching lines @@
         document().ensureStyleResolver().invalidateMatchedPropertiesCache();
         return Force;
     }
 
     if (styleChangeType() >= SubtreeStyleChange)
         return Force;
 
     return max(localChange, change);
 }
 
-void Element::recalcChildStyle(StyleRecalcChange change)
+void Element::recalcChildStyle(StyleRecalcChange change, InsertionPoint* shadowInsertionPoint)
 {
     ASSERT(document().inStyleRecalc());
     ASSERT(change >= Inherit || childNeedsStyleRecalc());
     ASSERT(!needsStyleRecalc());
 
     StyleResolverParentPusher parentPusher(*this);
 
     for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
         if (shouldRecalcStyle(change, root)) {
             parentPusher.push();
             root->recalcStyle(change);
         }
     }
 
+    for (ShadowRoot* root = oldestShadowRoot(); root; root = root->youngerShadowRoot()) {
+        if (InsertionPoint* insertionPoint = root->shadowInsertionPoint()) {
+            if ((change >= Inherit && change < Reattach) || insertionPoint->childNeedsStyleRecalc())

[esprehn, 2013/12/11 09:53:27]

if (shouldRecalcStyle(change, insertionPoint))

We cannot even get in here with a Reattach change, see the check in
Element::recalcStyle.

+                insertionPoint->recalcChildStyle(change, 0);

[esprehn, 2013/12/11 09:53:27]

This doesn't work, the bloom filter is wrong at this point so some selectors
will not match. The only way to make this work is to do
markAncestorsWithChildNeedsStyleRecalc() on the insertionPoint and then call
recalcStyle() on the ShadowRoot again.

+            insertionPoint->clearChildNeedsStyleRecalc();

[esprehn, 2013/12/11 09:53:27]

If you make the above change this goes away.

+        }
+    }
+
     if (shouldRecalcStyle(change, this))
         updatePseudoElement(BEFORE, change);
 
     if (change < Force && hasRareData() && childNeedsStyleRecalc())
         checkForChildrenAdjacentRuleChanges();
 
     // This loop is deliberately backwards because we use insertBefore in the rendering tree, and want to avoid
     // a potentially n^2 loop to find the insertion point while resolving style. Having us start from the last
     // child and work our way back means in the common case, we'll find the insertion point in O(1) time.
     // See crbug.com/288225
     StyleResolver& styleResolver = document().ensureStyleResolver();
     Text* lastTextNode = 0;
     for (Node* child = lastChild(); child; child = child->previousSibling()) {
         if (child->isTextNode()) {
             toText(child)->recalcTextStyle(change, lastTextNode);
             lastTextNode = toText(child);
         } else if (child->isElementNode()) {
             Element* element = toElement(child);
             if (shouldRecalcStyle(change, element)) {
                 parentPusher.push();
-                element->recalcStyle(change, lastTextNode);
+                element->recalcStyle(change, lastTextNode, shadowInsertionPoint);
             } else if (element->supportsStyleSharing()) {
                 styleResolver.addToStyleSharingList(*element);
             }
             if (element->renderer())
                 lastTextNode = 0;
         }
     }
 
     if (shouldRecalcStyle(change, this)) {
         updatePseudoElement(AFTER, change);
@@ skipping 1892 matching lines @@
     // Before doing so, we need to resolve issues in HTMLSelectElement::recalcListItems
     // and RenderMenuList::setText. See also https://bugs.webkit.org/show_bug.cgi?id=88405
     if (hasTagName(optionTag) || hasTagName(optgroupTag))
         return false;
     if (FullscreenElementStack::isActiveFullScreenElement(this))
         return false;
     return true;
 }
 
 } // namespace WebCore