Call Element::rebuildLayoutTree from Document::updateStyle directly

third_party/WebKit/Source/core/dom/ContainerNode.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, 2013 Apple Inc. All rights
  * reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 73 matching lines @@
 void ContainerNode::parserTakeAllChildrenFrom(ContainerNode& oldParent) {
   while (Node* child = oldParent.firstChild()) {
     // Explicitly remove since appending can fail, but this loop shouldn't be
     // infinite.
     oldParent.parserRemoveChild(*child);
     parserAppendChild(child);
   }
 }
 
 ContainerNode::~ContainerNode() {
-  DCHECK(needsAttach());

[nainar, 2016/11/29 06:13:39]

This is unnecessary - maybe replace this with a check that ensures that
needsReattachLayoutTree() is false?

[rune, 2016/12/05 10:05:16]

Wouldn't this correspond with needsReattachLayoutTree() being true? That is,
detachLayoutTree() has been called before the node is deleted?

[esprehn, 2016/12/05 22:31:33]

Leave this ASSERT alone, it's making sure by the time the node is destroyed that
it has already been detached.

 }
 
 DISABLE_CFI_PERF
 bool ContainerNode::isChildTypeAllowed(const Node& child) const {
   if (!child.isDocumentFragment())
     return childTypeAllowed(child.getNodeType());
 
   for (Node* node = toDocumentFragment(child).firstChild(); node;
        node = node->nextSibling()) {
     if (!childTypeAllowed(node->getNodeType()))
@@ skipping 437 matching lines @@
 
 void ContainerNode::removeBetween(Node* previousChild,
                                   Node* nextChild,
                                   Node& oldChild) {
   EventDispatchForbiddenScope assertNoEventDispatch;
 
   DCHECK_EQ(oldChild.parentNode(), this);
 
   AttachContext context;
   context.clearInvalidation = true;
-  if (!oldChild.needsAttach())

[nainar, 2016/11/29 06:13:39]

This statemement is no longer true since we are not setting the
NeedsReattachStyleChange flag anymore in Node::detachLayoutTree() however we are
setting the NeedsReattachLayotuTree flag which we should check here.

[rune, 2016/12/05 10:05:16]

Shouldn't this be !needsReattachLayoutTree()?

[esprehn, 2016/12/05 22:31:33]

Leave this alone.

+  if (oldChild.needsReattachLayoutTree())
     oldChild.detachLayoutTree(context);
 
   if (nextChild)
     nextChild->setPreviousSibling(previousChild);
   if (previousChild)
     previousChild->setNextSibling(nextChild);
   if (m_firstChild == &oldChild)
     setFirstChild(nextChild);
   if (m_lastChild == &oldChild)
     setLastChild(previousChild);
@@ skipping 189 matching lines @@
   }
 }
 
 DISABLE_CFI_PERF
 void ContainerNode::attachLayoutTree(const AttachContext& context) {
   AttachContext childrenContext(context);
   childrenContext.resolvedStyle = nullptr;
 
   for (Node* child = firstChild(); child; child = child->nextSibling()) {
 #if DCHECK_IS_ON()
-    DCHECK(child->needsAttach() ||
+    DCHECK(child->needsReattachLayoutTree() ||
            childAttachedAllowedWhenAttachingChildren(this));
 #endif
-    if (child->needsAttach())
+    if (child->needsReattachLayoutTree())
       child->attachLayoutTree(childrenContext);
   }
 
   clearChildNeedsStyleRecalc();
   clearChildNeedsReattachLayoutTree();
   Node::attachLayoutTree(context);
 }
 
 void ContainerNode::detachLayoutTree(const AttachContext& context) {
   AttachContext childrenContext(context);
   childrenContext.resolvedStyle = nullptr;
   childrenContext.clearInvalidation = true;
 
   for (Node* child = firstChild(); child; child = child->nextSibling())
     child->detachLayoutTree(childrenContext);
-
-  setChildNeedsStyleRecalc();
   Node::detachLayoutTree(context);
 }
 
 void ContainerNode::childrenChanged(const ChildrenChange& change) {
   document().incDOMTreeVersion();
   invalidateNodeListCachesInAncestors();
   if (change.isChildInsertion() && !childNeedsStyleRecalc()) {
     setChildNeedsStyleRecalc();
     markAncestorsWithChildNeedsStyleRecalc();
   }
@@ skipping 494 matching lines @@
     } else if (child->isElementNode()) {
       Element* element = toElement(child);
       if (element->shouldCallRecalcStyle(change))
         element->recalcStyle(change, lastTextNode);
       else if (element->supportsStyleSharing())
         styleResolver.addToStyleSharingList(*element);
       if (element->layoutObject())
         lastTextNode = nullptr;
     }
   }
+  clearChildNeedsStyleRecalc();
+}
+
+void ContainerNode::rebuildDescendantLayoutTree() {
+  DCHECK(!needsStyleRecalc());
+  DCHECK(!childNeedsStyleRecalc());
+  DCHECK(!needsReattachLayoutTree());
+
+  for (Node* child = firstChild(); child; child = child->nextSibling()) {
+    if (child->needsReattachLayoutTree() ||
+        child->childNeedsReattachLayoutTree()) {
+      if (child->isTextNode())
+        toText(child)->rebuildTextLayoutTree();
+      else if (child->isElementNode())
+        toElement(child)->rebuildLayoutTree();
+    }
+  }
+  clearChildNeedsStyleRecalc();
+  clearChildNeedsReattachLayoutTree();
 }
 
 void ContainerNode::checkForSiblingStyleChanges(SiblingCheckType changeType,
                                                 Element* changedElement,
                                                 Node* nodeBeforeChange,
                                                 Node* nodeAfterChange) {
   if (!inActiveDocument() || document().hasPendingForcedStyleRecalc() ||
       getStyleChangeType() >= SubtreeStyleChange)
     return;
 
@@ skipping 161 matching lines @@
     return true;
 
   if (node->isElementNode() && toElement(node)->shadow())
     return true;
 
   return false;
 }
 #endif
 
 }  // namespace blink