Recalc sibling styles for forward positional rules on mutations only.

Source/core/dom/SiblingRuleHelper.cpp

 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/dom/SiblingRuleHelper.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/StyleEngine.h"
@@ skipping 10 matching lines @@
 }
 
 void SiblingRuleHelper::setChildrenAffectedByDirectAdjacentRules()
 {
     if (m_node->isElementNode())
         toElement(m_node)->setChildrenAffectedByDirectAdjacentRules();
     else
         toShadowRoot(m_node)->setChildrenAffectedByDirectAdjacentRules();
 }
 
+void SiblingRuleHelper::setChildrenAffectedByIndirectAdjacentRules()
+{
+    if (m_node->isElementNode())
+        toElement(m_node)->setChildrenAffectedByIndirectAdjacentRules();
+    else
+        toShadowRoot(m_node)->setChildrenAffectedByIndirectAdjacentRules();
+}
+
 void SiblingRuleHelper::setChildrenAffectedByForwardPositionalRules()
 {
     if (m_node->isElementNode())
         toElement(m_node)->setChildrenAffectedByForwardPositionalRules();
     else
         toShadowRoot(m_node)->setChildrenAffectedByForwardPositionalRules();
 }
 
 void SiblingRuleHelper::setChildrenAffectedByBackwardPositionalRules()
 {
@@ skipping 32 matching lines @@
 bool SiblingRuleHelper::childrenAffectedByLastChildRules() const
 {
     return m_node->isElementNode() ? toElement(m_node)->childrenAffectedByLastChildRules() : toShadowRoot(m_node)->childrenAffectedByLastChildRules();
 }
 
 bool SiblingRuleHelper::childrenAffectedByDirectAdjacentRules() const
 {
     return m_node->isElementNode() ? toElement(m_node)->childrenAffectedByDirectAdjacentRules() : toShadowRoot(m_node)->childrenAffectedByDirectAdjacentRules();
 }
 
+bool SiblingRuleHelper::childrenAffectedByIndirectAdjacentRules() const
+{
+    return m_node->isElementNode() ? toElement(m_node)->childrenAffectedByIndirectAdjacentRules() : toShadowRoot(m_node)->childrenAffectedByIndirectAdjacentRules();
+}
+
 bool SiblingRuleHelper::childrenAffectedByForwardPositionalRules() const
 {
     return m_node->isElementNode() ? toElement(m_node)->childrenAffectedByForwardPositionalRules() : toShadowRoot(m_node)->childrenAffectedByForwardPositionalRules();
 }
 
 bool SiblingRuleHelper::childrenAffectedByBackwardPositionalRules() const
 {
     return m_node->isElementNode() ? toElement(m_node)->childrenAffectedByBackwardPositionalRules() : toShadowRoot(m_node)->childrenAffectedByBackwardPositionalRules();
 }
 
 void SiblingRuleHelper::checkForChildrenAdjacentRuleChanges()
 {
     bool hasDirectAdjacentRules = childrenAffectedByDirectAdjacentRules();
-    bool hasIndirectAdjacentRules = childrenAffectedByForwardPositionalRules();
+    bool hasIndirectAdjacentRules = childrenAffectedByIndirectAdjacentRules();
 
     if (!hasDirectAdjacentRules && !hasIndirectAdjacentRules)
         return;
 
     unsigned forceCheckOfNextElementCount = 0;
     bool forceCheckOfAnyElementSibling = false;
     Document& document = m_node->document();
 
     for (Node* child = m_node->firstChild(); child; child = child->nextSibling()) {
         if (!child->isElementNode())
@@ skipping 14 matching lines @@
     }
 }
 
 bool SiblingRuleHelper::childrenSupportStyleSharing()
 {
     return m_node->isElementNode() ? toElement(m_node)->childrenSupportStyleSharing() : toShadowRoot(m_node)->childrenSupportStyleSharing();
 }
 
 } // namespace WebCore