Recalc sibling styles for forward positional rules on mutations only.

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 1811 matching lines @@
         return;
 
     RenderStyle* style = renderStyle();
 
     // :empty selector.
     checkForEmptyStyleChange(style);
 
     if (!style || (needsStyleRecalc() && childrenAffectedByPositionalRules()))
         return;
 
-    // Forward positional selectors include the ~ selector, nth-child, nth-of-type, first-of-type and only-of-type.
+    // Forward positional selectors include nth-child, nth-of-type, first-of-type and only-of-type.
+    // The indirect adjacent selector is the ~ selector.
     // Backward positional selectors include nth-last-child, nth-last-of-type, last-of-type and only-of-type.
-    // We have to invalidate everything following the insertion point in the forward case, and everything before the insertion point in the
-    // backward case.
+    // We have to invalidate everything following the insertion point in the forward and indirect adjacent case,
+    // and everything before the insertion point in the backward case.
     // |afterChange| is 0 in the parser callback case, so we won't do any work for the forward case if we don't have to.
     // For performance reasons we just mark the parent node as changed, since we don't want to make childrenChanged O(n^2) by crawling all our kids
     // here. recalcStyle will then force a walk of the children when it sees that this has happened.
-    if ((childrenAffectedByForwardPositionalRules() && afterChange) || (childrenAffectedByBackwardPositionalRules() && beforeChange)) {
+    if (((childrenAffectedByForwardPositionalRules() || childrenAffectedByIndirectAdjacentRules()) && afterChange)
+        || (childrenAffectedByBackwardPositionalRules() && beforeChange)) {
         setNeedsStyleRecalc(SubtreeStyleChange);
         return;
     }
 
     // :first-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
     // In the DOM case, we only need to do something if |afterChange| is not 0.
     // |afterChange| is 0 in the parser case, so it works out that we'll skip this block.
     if (childrenAffectedByFirstChildRules() && afterChange) {
         // Find our new first child.
         Element* newFirstChild = ElementTraversal::firstWithin(*this);
@@ skipping 685 matching lines @@
 void Element::setChildrenAffectedByLastChildRules()
 {
     ensureElementRareData().setChildrenAffectedByLastChildRules(true);
 }
 
 void Element::setChildrenAffectedByDirectAdjacentRules()
 {
     ensureElementRareData().setChildrenAffectedByDirectAdjacentRules(true);
 }
 
+void Element::setChildrenAffectedByIndirectAdjacentRules()
+{
+    ensureElementRareData().setChildrenAffectedByIndirectAdjacentRules(true);
+}
+
 void Element::setChildrenAffectedByForwardPositionalRules()
 {
     ensureElementRareData().setChildrenAffectedByForwardPositionalRules(true);
 }
 
 void Element::setChildrenAffectedByBackwardPositionalRules()
 {
     ensureElementRareData().setChildrenAffectedByBackwardPositionalRules(true);
 }
 
 void Element::setChildIndex(unsigned index)
 {
     ElementRareData& rareData = ensureElementRareData();
     if (RenderStyle* style = renderStyle())
         style->setUnique();
     rareData.setChildIndex(index);
 }
 
 bool Element::childrenSupportStyleSharing() const
 {
     if (!hasRareData())
         return true;
     return !rareDataChildrenAffectedByFocus()
         && !rareDataChildrenAffectedByHover()
         && !rareDataChildrenAffectedByActive()
         && !rareDataChildrenAffectedByDrag()
         && !rareDataChildrenAffectedByFirstChildRules()
         && !rareDataChildrenAffectedByLastChildRules()
         && !rareDataChildrenAffectedByDirectAdjacentRules()
+        && !rareDataChildrenAffectedByIndirectAdjacentRules()
         && !rareDataChildrenAffectedByForwardPositionalRules()
         && !rareDataChildrenAffectedByBackwardPositionalRules();
 }
 
 bool Element::rareDataStyleAffectedByEmpty() const
 {
     ASSERT(hasRareData());
     return elementRareData()->styleAffectedByEmpty();
 }
 
@@ skipping 32 matching lines @@
     ASSERT(hasRareData());
     return elementRareData()->childrenAffectedByLastChildRules();
 }
 
 bool Element::rareDataChildrenAffectedByDirectAdjacentRules() const
 {
     ASSERT(hasRareData());
     return elementRareData()->childrenAffectedByDirectAdjacentRules();
 }
 
+bool Element::rareDataChildrenAffectedByIndirectAdjacentRules() const
+{
+    ASSERT(hasRareData());
+    return elementRareData()->childrenAffectedByIndirectAdjacentRules();
+}
+
 bool Element::rareDataChildrenAffectedByForwardPositionalRules() const
 {
     ASSERT(hasRareData());
     return elementRareData()->childrenAffectedByForwardPositionalRules();
 }
 
 bool Element::rareDataChildrenAffectedByBackwardPositionalRules() const
 {
     ASSERT(hasRareData());
     return elementRareData()->childrenAffectedByBackwardPositionalRules();
@@ skipping 904 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 (isHTMLOptionElement(*this) || isHTMLOptGroupElement(*this))
         return false;
     if (FullscreenElementStack::isActiveFullScreenElement(this))
         return false;
     return true;
 }
 
 } // namespace WebCore