Call Element::rebuildLayoutTree from Document::updateStyle directly

third_party/WebKit/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)
  *
@@ skipping 1885 matching lines @@
       if (change != IndependentInherit)
         data->clearComputedStyle();
 
       if (change >= IndependentInherit) {
         if (ElementAnimations* elementAnimations = data->elementAnimations())
           elementAnimations->setAnimationStyleChange(false);
       }
     }
     if (parentComputedStyle())
       change = recalcOwnStyle(change, nextTextSibling);
-    clearNeedsStyleRecalc();
-    clearNeedsReattachLayoutTree();
+    if (change != Reattach)

[nainar, 2017/02/16 08:05:57]

This was initially if (!needsReattachLayoutTree) - which is incorrect.

We need to retain this information in case we are about to reattach. Which is
change == Reattach 

[esprehn, 2017/02/16 21:24:33]

If we're going to reattach, then we did setNeedsReattachLayoutTree(), so change
== Reattach should imply needsReattachLayoutTree() ? Curious where we need this
bit still, needsAttach() already checks both.

[nainar, 2017/02/16 22:26:09]

change == Reattach does imply needsReattachLayoutTree() but not the other way
round. 
When we enter reattachLayoutTree() there is a check to prevent us doing useless
detach. If we clear the needsStyleRecalc bit that condition will always be true.
And we will be unable to skip detachLayoutTree() in cases like we have already
been through attachLayoutTree()

+      clearNeedsStyleRecalc();
   }
 
-  // If we reattached we don't need to recalc the style of our descendants
-  // anymore.
-  if ((change >= UpdatePseudoElements && change < Reattach) ||
-      childNeedsStyleRecalc()) {
+  // If we are going to reattach we don't need to recalc the style of
+  // our descendants anymore.
+  if (change < Reattach &&
+      (change >= UpdatePseudoElements || childNeedsStyleRecalc())) {
     SelectorFilterParentScope filterScope(*this);
     StyleSharingDepthScope sharingScope(*this);
 
     updatePseudoElement(PseudoIdBefore, change);
 
     if (change > UpdatePseudoElements || childNeedsStyleRecalc()) {
       for (ShadowRoot* root = youngestShadowRoot(); root;
            root = root->olderShadowRoot()) {
         if (root->shouldCallRecalcStyle(change))
           root->recalcStyle(change);
       }
       recalcDescendantStyles(change);
     }
 
     updatePseudoElement(PseudoIdAfter, change);
     updatePseudoElement(PseudoIdBackdrop, change);
 
     // If our children have changed then we need to force the first-letter
     // checks as we don't know if they effected the first letter or not.
     // This can be seen when a child transitions from floating to
     // non-floating we have to take it into account for the first letter.
     updatePseudoElement(PseudoIdFirstLetter,
                         childNeedsStyleRecalc() ? Force : change);
 
     clearChildNeedsStyleRecalc();
-    clearChildNeedsReattachLayoutTree();
   }
 
   if (hasCustomStyleCallbacks())
     didRecalcStyle();
 }
 
 PassRefPtr<ComputedStyle> Element::propagateInheritedProperties(
     StyleRecalcChange change) {
   if (change != IndependentInherit)
     return nullptr;
@@ skipping 39 matching lines @@
   } else {
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesChanged, 1);
   }
 
   if (localChange == Reattach) {
     StyleReattachData styleReattachData;
     styleReattachData.computedStyle = std::move(newStyle);
     styleReattachData.nextTextSibling = nextTextSibling;
     document().addStyleReattachData(*this, styleReattachData);
     setNeedsReattachLayoutTree();
-    return rebuildLayoutTree();
+    return Reattach;
   }
 
   DCHECK(oldStyle);
 
   if (localChange != NoChange)
     updateCallbackSelectors(oldStyle.get(), newStyle.get());
 
   if (LayoutObject* layoutObject = this->layoutObject()) {
     if (localChange != NoChange ||
         pseudoStyleCacheIsInvalid(oldStyle.get(), newStyle.get())) {
@@ skipping 20 matching lines @@
         return Inherit;
       newStyle->copyChildDependentFlagsFrom(*oldStyle);
     }
     if (oldStyle->hasPseudoElementStyle() || newStyle->hasPseudoElementStyle())
       return UpdatePseudoElements;
   }
 
   return localChange;
 }
 
-StyleRecalcChange Element::rebuildLayoutTree() {
+void Element::rebuildLayoutTree() {
   DCHECK(inActiveDocument());
+  DCHECK(parentNode());
+
   StyleReattachData styleReattachData = document().getStyleReattachData(*this);
   AttachContext reattachContext;
   reattachContext.resolvedStyle = styleReattachData.computedStyle.get();
   bool layoutObjectWillChange = needsAttach() || layoutObject();
 
-  // We are calling Element::rebuildLayoutTree() from inside
-  // Element::recalcOwnStyle where we set the NeedsReattachLayoutTree
-  // flag - so needsReattachLayoutTree() should always be true.
-  DCHECK(parentNode());
-  DCHECK(parentNode()->childNeedsReattachLayoutTree());
-  DCHECK(needsReattachLayoutTree());
-  reattachLayoutTree(reattachContext);
-  // Since needsReattachLayoutTree() is always true we go into
-  // reattachLayoutTree() which reattaches all the descendant
-  // sub-trees. At this point no child should need reattaching.
+  if (needsReattachLayoutTree()) {
+    reattachLayoutTree(reattachContext);
+  } else if (childNeedsReattachLayoutTree()) {
+    DCHECK(!needsReattachLayoutTree());
+    SelectorFilterParentScope filterScope(*this);
+    StyleSharingDepthScope sharingScope(*this);
+    reattachPseudoElementLayoutTree(PseudoIdBefore);
+    rebuildShadowRootLayoutTree();
+    rebuildChildrenLayoutTrees();
+    reattachPseudoElementLayoutTree(PseudoIdAfter);
+    reattachPseudoElementLayoutTree(PseudoIdBackdrop);
+    reattachPseudoElementLayoutTree(PseudoIdFirstLetter);
+  }
+  DCHECK(!needsStyleRecalc());
+  DCHECK(!childNeedsStyleRecalc());
+  DCHECK(!needsReattachLayoutTree());
   DCHECK(!childNeedsReattachLayoutTree());
 
   if (layoutObjectWillChange || layoutObject()) {
     // nextTextSibling is passed on to recalcStyle from recalcDescendantStyles
     // we can either traverse the current subtree from this node onwards
     // or store it.
     // The choice is between increased time and increased memory complexity.
     reattachWhitespaceSiblingsIfNeeded(styleReattachData.nextTextSibling);
-    return Reattach;
   }
-  return ReattachNoLayoutObject;
+}
+
+void Element::rebuildShadowRootLayoutTree() {
+  for (ShadowRoot* root = youngestShadowRoot(); root;
+       root = root->olderShadowRoot()) {
+    if (root->needsReattachLayoutTree() || root->childNeedsReattachLayoutTree())
+      root->rebuildLayoutTree();
+  }
+}
+
+void Element::reattachPseudoElementLayoutTree(PseudoId pseudoId) {
+  if (PseudoElement* element = pseudoElement(pseudoId)) {
+    if (element->needsReattachLayoutTree() ||
+        element->childNeedsReattachLayoutTree())
+      element->rebuildLayoutTree();
+  } else {
+    createPseudoElementIfNeeded(pseudoId);
+  }
 }
 
 void Element::updateCallbackSelectors(const ComputedStyle* oldStyle,
                                       const ComputedStyle* newStyle) {
   Vector<String> emptyVector;
   const Vector<String>& oldCallbackSelectors =
       oldStyle ? oldStyle->callbackSelectors() : emptyVector;
   const Vector<String>& newCallbackSelectors =
       newStyle ? newStyle->callbackSelectors() : emptyVector;
   if (oldCallbackSelectors.isEmpty() && newCallbackSelectors.isEmpty())
@@ skipping 2056 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink