Element::recalcStyle() overly reattach()-es InsertionPoints.

Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 817 matching lines @@
 
 inline void Node::setStyleChange(StyleChangeType changeType)
 {
     m_nodeFlags = (m_nodeFlags & ~StyleChangeMask) | changeType;
 }
 
 inline void Node::markAncestorsWithChildNeedsStyleRecalc()
 {
     for (ContainerNode* p = parentOrShadowHostNode(); p && !p->childNeedsStyleRecalc(); p = p->parentOrShadowHostNode())
         p->setChildNeedsStyleRecalc();
+}
+
+inline void Node::markDistributionsWithNeedsStyleRecalc()
+{
+    for (ShadowRoot* root = containingShadowRoot(); root; root = root->host()->containingShadowRoot()) {
+        ScopeContentDistribution* distribution = root->scopeDistribution();
+        if (!distribution || !distribution->hasInsertionPoint(root))

[esprehn, 2013/06/13 02:25:38]

hasInsertionPoint is static, this doesn't make sense.

+            continue;
+        root->host()->setNeedsStyleRecalc();
+        const Vector<RefPtr<InsertionPoint> >& insertionPoints = distribution->ensureInsertionPointList(root);
+        for (unsigned i = 0; i < insertionPoints.size(); ++i)
+            insertionPoints[i]->setNeedsStyleRecalc();

[esprehn, 2013/06/13 02:25:38]

This is much too aggressive. Now if we setNeedsStyleRecalc a <div> in a
ShadowRoot (ex. an animation is running) we're going to cause Force style
recalcs on every ShadowRoot and all their descendants all the way down the tree.

setNeedsStyleRecalc means Force for myself and all descendants. You don't even
need this setNeedsStyleRecalc for the insertionPoints because of how big a
hammer this is.

+    }
+}
+
+inline void Node::propagateStyleRecalcMarking()
+{
+    markAncestorsWithChildNeedsStyleRecalc();
+    markDistributionsWithNeedsStyleRecalc();
 
     if (document()->childNeedsStyleRecalc())
         document()->scheduleStyleRecalc();
 }
 
 void Node::refEventTarget()
 {
     ref();
 }
 
 void Node::derefEventTarget()
 {
     deref();
 }
 
 void Node::setNeedsStyleRecalc(StyleChangeType changeType)
 {
     ASSERT(changeType != NoStyleChange);
     if (!attached()) // changed compared to what?
         return;
 
     StyleChangeType existingChangeType = styleChangeType();
     if (changeType > existingChangeType)
         setStyleChange(changeType);
 
     if (existingChangeType == NoStyleChange)
-        markAncestorsWithChildNeedsStyleRecalc();
+        propagateStyleRecalcMarking();
 }
 
 void Node::lazyAttach()
 {
     // It's safe to synchronously attach here because we're in the middle of style recalc
     // while it's not safe to mark nodes as needing style recalc except in the loop in
     // Element::recalcStyle because we may mark an ancestor as not needing recalc and
     // then the node would never get updated. One place this currently happens is
     // HTMLObjectElement::renderFallbackContent which may call lazyAttach from inside
     // attach which was triggered by a recalcStyle.
     if (document()->inStyleRecalc()) {
         attach();
         return;
     }
     setStyleChange(FullStyleChange);
-    markAncestorsWithChildNeedsStyleRecalc();
+    propagateStyleRecalcMarking();
 }
 
 bool Node::supportsFocus() const
 {
     return false;
 }
     
 bool Node::isFocusable() const
 {
     if (!inDocument() || !supportsFocus())
@@ skipping 1883 matching lines @@
         node->showTreeForThis();
 }
 
 void showNodePath(const WebCore::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif