Move Layout Tree Construction code into Element::rebuildLayoutTree()

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 1842 matching lines @@
         data->clearComputedStyle();
 
       if (change >= IndependentInherit) {
         if (ElementAnimations* elementAnimations = data->elementAnimations())
           elementAnimations->setAnimationStyleChange(false);
       }
     }
     if (parentComputedStyle())
       change = recalcOwnStyle(change);
     clearNeedsStyleRecalc();
+    clearNeedsReattachLayoutTree();
   }
 
   // If we reattached we don't need to recalc the style of our descendants
   // anymore.
   if ((change >= UpdatePseudoElements && change < Reattach) ||
       childNeedsStyleRecalc()) {
     SelectorFilterParentScope filterScope(*this);
     StyleSharingDepthScope sharingScope(*this);
 
     updatePseudoElement(PseudoIdBefore, change);
@@ skipping 11 matching lines @@
     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(change);
-
-  if (change == Reattach)
-    reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
 }
 
 PassRefPtr<ComputedStyle> Element::propagateInheritedProperties(
     StyleRecalcChange change) {
   if (change != IndependentInherit)
     return nullptr;
   if (needsStyleRecalc())
     return nullptr;
   if (hasAnimations())
     return nullptr;
@@ skipping 28 matching lines @@
   StyleRecalcChange localChange =
       ComputedStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
   if (localChange == NoChange) {
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesUnchanged, 1);
   } else {
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesChanged, 1);
   }
 
   if (localChange == Reattach) {
     document().addNonAttachedStyle(*this, std::move(newStyle));
+    setNeedsReattachLayoutTree();
     return rebuildLayoutTree();
   }
 
   DCHECK(oldStyle);
 
   if (localChange != NoChange)
     updateCallbackSelectors(oldStyle.get(), newStyle.get());
 
   if (LayoutObject* layoutObject = this->layoutObject()) {
     if (localChange != NoChange ||
@@ skipping 26 matching lines @@
       return UpdatePseudoElements;
   }
 
   return localChange;
 }
 
 StyleRecalcChange Element::rebuildLayoutTree() {
   AttachContext reattachContext;
   reattachContext.resolvedStyle = document().getNonAttachedStyle(*this);
   bool layoutObjectWillChange = needsAttach() || layoutObject();
-  reattachLayoutTree(reattachContext);
-  if (layoutObjectWillChange || layoutObject())
+
+  if (needsReattachLayoutTree()) {
+    reattachLayoutTree(reattachContext);
+  } else if (childNeedsReattachLayoutTree()) {
+    reattachPseudoElementLayoutTree(PseudoIdBefore);
+
+    for (Node* child = firstChild(); child && child->isElementNode();

[esprehn, 2016/10/10 21:50:42]

this breaks at the first non element, ex. text or comment.

you need:

if (node->isElementNode())
  
inside the loop.

Also you don't handle Shadow DOM here, you need to iterate the ShadowRoots
first, see how ::recalcStyle does this:

      for (ShadowRoot* root = youngestShadowRoot(); root;
           root = root->olderShadowRoot()) {

Actually I think this entire side of the branch is unreachable because you only
call this inside recalcOwnStyle right now right after calling
setNeedsReattachLayoutTree() we always take the needsReattachLayoutTree().

Maybe we remove this side of the if statement and make it NOTREACHED() for this
patch. The next patch that move rebuildLayoutTree to be it's own step in
updateStyle() will fill it in.

[nainar, 2016/10/10 22:56:34]

Added NOTREACHED() here and noted the changes needed for a future patch. 

+         child = child->nextSibling())
+      toElement(child)->rebuildLayoutTree();
+
+    reattachPseudoElementLayoutTree(PseudoIdAfter);
+    reattachPseudoElementLayoutTree(PseudoIdBackdrop);
+  }
+
+  if (layoutObjectWillChange || layoutObject()) {
+    // nextTextSibling is passed on to recalcStyle from recalcDescendantStyles
+    // we can either traverse the parent's tree to get this node or store it
+    // (like WebKit does).
+    // The choice is between increased time and increased memory complexity
+    Text* nextTextSibling = nullptr;
+    for (Node* child = parentNode()->lastChild(); child;

[esprehn, 2016/10/10 21:50:42]

This is n^2, if you appendChild 500 elements, this always iterates from the end
to yourself.

I think we want to just start at |this| and iterate until we find the next
whitespace sibling.

[nainar, 2016/10/10 22:56:34]

Done. Starting iteration from this->nextSibling. 

Can change this to checking in the if condition that the node in consideration
is not this itself. 

+         child = child->previousSibling()) {
+      if (child->isTextNode()) {
+        nextTextSibling = toText(child);
+      } else if (child->isElementNode()) {
+        if (toElement(child) == this) {
+          reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
+          break;
+        }
+        if (toElement(child)->layoutObject()) {
+          nextTextSibling = nullptr;
+        }
+      }
+    }
     return Reattach;
+  }
   return ReattachNoLayoutObject;
 }
 
+void Element::reattachPseudoElementLayoutTree(PseudoId pseudoId) {
+  if (PseudoElement* element = pseudoElement(pseudoId)) {
+    if (element->needsReattachLayoutTree())
+      element->rebuildLayoutTree();
+  }
+}
+
 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())
     return;
   if (oldCallbackSelectors != newCallbackSelectors)
@@ skipping 2071 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink