Merge r228593 - [RenderTreeBuilder] Move RenderBoxModelObject::moveCh…

…ild*() to RenderTreeBuilder

https://bugs.webkit.org/show_bug.cgi?id=182896
<rdar://problem/37623051>

Reviewed by Antti Koivisto.

No change in functionality.

* rendering/RenderBlock.h:
(WebCore::RenderBlock::moveAllChildrenIncludingFloatsTo): Deleted.
* rendering/RenderBlockFlow.cpp:
(WebCore::RenderBlockFlow::styleDidChange):
(WebCore::RenderBlockFlow::moveAllChildrenIncludingFloatsTo): Deleted.
* rendering/RenderBlockFlow.h:
* rendering/RenderBoxModelObject.cpp:
(WebCore::RenderBoxModelObject::moveChildTo): Deleted.
(WebCore::RenderBoxModelObject::moveChildrenTo): Deleted.
(WebCore::RenderBoxModelObject::moveAllChildrenToInternal): Deleted.
* rendering/RenderBoxModelObject.h:
(WebCore::RenderBoxModelObject::moveChildTo): Deleted.
(WebCore::RenderBoxModelObject::moveAllChildrenTo): Deleted.
(WebCore::RenderBoxModelObject::moveChildrenTo): Deleted.
* rendering/updating/RenderTreeBuilder.cpp:
(WebCore::RenderTreeBuilder::moveChildTo):
(WebCore::RenderTreeBuilder::moveAllChildrenTo):
(WebCore::RenderTreeBuilder::moveChildrenTo):
(WebCore::RenderTreeBuilder::moveAllChildrenIncludingFloatsTo):
(WebCore::RenderTreeBuilder::makeChildrenNonInline):
(WebCore::RenderTreeBuilder::splitAnonymousBoxesAroundChild):
* rendering/updating/RenderTreeBuilder.h:
* rendering/updating/RenderTreeBuilderBlock.cpp:
(WebCore::moveAllChildrenToInternal):
(WebCore::RenderTreeBuilder::Block::removeLeftoverAnonymousBlock):
(WebCore::RenderTreeBuilder::Block::takeChild):
(WebCore::RenderTreeBuilder::Block::dropAnonymousBoxChild):
* rendering/updating/RenderTreeBuilderBlockFlow.cpp:
(WebCore::RenderTreeBuilder::BlockFlow::moveAllChildrenIncludingFloatsTo):
* rendering/updating/RenderTreeBuilderBlockFlow.h:
* rendering/updating/RenderTreeBuilderMultiColumn.cpp:
(WebCore::RenderTreeBuilder::MultiColumn::createFragmentedFlow):
(WebCore::RenderTreeBuilder::MultiColumn::destroyFragmentedFlow):
* rendering/updating/RenderTreeBuilderRuby.cpp:
(WebCore::RenderTreeBuilder::Ruby::moveInlineChildren):
(WebCore::RenderTreeBuilder::Ruby::moveBlockChildren):
(WebCore::RenderTreeBuilder::Ruby::takeChild):
* rendering/updating/RenderTreeBuilderTable.cpp:
(WebCore::RenderTreeBuilder::Table::collapseAndDestroyAnonymousSiblingRows):

Source/WebCore/ChangeLog

@@ -1,3 +1,53 @@
+2018-02-16  Zalan Bujtas  <zalan@apple.com>
+
+        [RenderTreeBuilder] Move RenderBoxModelObject::moveChild*() to RenderTreeBuilder
+        https://bugs.webkit.org/show_bug.cgi?id=182896
+        <rdar://problem/37623051>
+
+        Reviewed by Antti Koivisto.
+
+        No change in functionality.
+
+        * rendering/RenderBlock.h:
+        (WebCore::RenderBlock::moveAllChildrenIncludingFloatsTo): Deleted.
+        * rendering/RenderBlockFlow.cpp:
+        (WebCore::RenderBlockFlow::styleDidChange):
+        (WebCore::RenderBlockFlow::moveAllChildrenIncludingFloatsTo): Deleted.
+        * rendering/RenderBlockFlow.h:
+        * rendering/RenderBoxModelObject.cpp:
+        (WebCore::RenderBoxModelObject::moveChildTo): Deleted.
+        (WebCore::RenderBoxModelObject::moveChildrenTo): Deleted.
+        (WebCore::RenderBoxModelObject::moveAllChildrenToInternal): Deleted.
+        * rendering/RenderBoxModelObject.h:
+        (WebCore::RenderBoxModelObject::moveChildTo): Deleted.
+        (WebCore::RenderBoxModelObject::moveAllChildrenTo): Deleted.
+        (WebCore::RenderBoxModelObject::moveChildrenTo): Deleted.
+        * rendering/updating/RenderTreeBuilder.cpp:
+        (WebCore::RenderTreeBuilder::moveChildTo):
+        (WebCore::RenderTreeBuilder::moveAllChildrenTo):
+        (WebCore::RenderTreeBuilder::moveChildrenTo):
+        (WebCore::RenderTreeBuilder::moveAllChildrenIncludingFloatsTo):
+        (WebCore::RenderTreeBuilder::makeChildrenNonInline):
+        (WebCore::RenderTreeBuilder::splitAnonymousBoxesAroundChild):
+        * rendering/updating/RenderTreeBuilder.h:
+        * rendering/updating/RenderTreeBuilderBlock.cpp:
+        (WebCore::moveAllChildrenToInternal):
+        (WebCore::RenderTreeBuilder::Block::removeLeftoverAnonymousBlock):
+        (WebCore::RenderTreeBuilder::Block::takeChild):
+        (WebCore::RenderTreeBuilder::Block::dropAnonymousBoxChild):
+        * rendering/updating/RenderTreeBuilderBlockFlow.cpp:
+        (WebCore::RenderTreeBuilder::BlockFlow::moveAllChildrenIncludingFloatsTo):
+        * rendering/updating/RenderTreeBuilderBlockFlow.h:
+        * rendering/updating/RenderTreeBuilderMultiColumn.cpp:
+        (WebCore::RenderTreeBuilder::MultiColumn::createFragmentedFlow):
+        (WebCore::RenderTreeBuilder::MultiColumn::destroyFragmentedFlow):
+        * rendering/updating/RenderTreeBuilderRuby.cpp:
+        (WebCore::RenderTreeBuilder::Ruby::moveInlineChildren):
+        (WebCore::RenderTreeBuilder::Ruby::moveBlockChildren):
+        (WebCore::RenderTreeBuilder::Ruby::takeChild):
+        * rendering/updating/RenderTreeBuilderTable.cpp:
+        (WebCore::RenderTreeBuilder::Table::collapseAndDestroyAnonymousSiblingRows):
+
 2018-02-16  Zalan Bujtas  <zalan@apple.com>
 
         [RenderTreeBuilder] Move RenderElement::insertChildInternal() to RenderTreeBuilder

Source/WebCore/rendering/RenderBlock.h

@@ -392,8 +392,6 @@ class RenderBlock : public RenderBox {
     void adjustBorderBoxRectForPainting(LayoutRect&) override;
     LayoutRect paintRectToClipOutFromBorder(const LayoutRect&) override;
     bool isInlineBlockOrInlineTable() const final { return isInline() && isReplaced(); }
-    // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
-    virtual void moveAllChildrenIncludingFloatsTo(RenderTreeBuilder& builder, RenderBlock& toBlock, RenderBoxModelObject::NormalizeAfterInsertion normalizeAfterInsertion) { moveAllChildrenTo(builder, &toBlock, normalizeAfterInsertion); }
 
 protected:
     virtual void addOverflowFromChildren();

Source/WebCore/rendering/RenderBlockFlow.cpp

@@ -2023,7 +2023,7 @@ void RenderBlockFlow::styleDidChange(StyleDifference diff, const RenderStyle* ol
     // Fresh floats need to be reparented if they actually belong to the previous anonymous block.
     // It copies the logic of RenderBlock::addChildIgnoringContinuation
     if (noLongerAffectsParentBlock() && style().isFloating() && previousSibling() && previousSibling()->isAnonymousBlock())
-        downcast<RenderBoxModelObject>(*parent()).moveChildTo(*RenderTreeBuilder::current(), &downcast<RenderBoxModelObject>(*previousSibling()), this, RenderBoxModelObject::NormalizeAfterInsertion::No);
+        RenderTreeBuilder::current()->moveChildTo(downcast<RenderBoxModelObject>(*parent()), &downcast<RenderBoxModelObject>(*previousSibling()), this, RenderTreeBuilder::NormalizeAfterInsertion::No);
 
     if (diff >= StyleDifferenceRepaint) {
         // FIXME: This could use a cheaper style-only test instead of SimpleLineLayout::canUseFor.
@@ -2105,13 +2105,6 @@ void RenderBlockFlow::addFloatsToNewParent(RenderBlockFlow& toBlockFlow) const
     }
 }
 
-void RenderBlockFlow::moveAllChildrenIncludingFloatsTo(RenderTreeBuilder& builder, RenderBlock& toBlock, RenderBoxModelObject::NormalizeAfterInsertion normalizeAfterInsertion)
-{
-    auto& toBlockFlow = downcast<RenderBlockFlow>(toBlock);
-    moveAllChildrenTo(builder, &toBlockFlow, normalizeAfterInsertion);
-    addFloatsToNewParent(toBlockFlow);
-}
-
 void RenderBlockFlow::addOverflowFromFloats()
 {
     if (!m_floatingObjects)

Source/WebCore/rendering/RenderBlockFlow.h

@@ -461,7 +461,7 @@ class RenderBlockFlow : public RenderBlock {
     // Called to lay out the legend for a fieldset or the ruby text of a ruby run. Also used by multi-column layout to handle
     // the flow thread child.
     void layoutExcludedChildren(bool relayoutChildren) override;
-    void moveAllChildrenIncludingFloatsTo(RenderTreeBuilder&, RenderBlock& toBlock, RenderBoxModelObject::NormalizeAfterInsertion) override;
+    void addOverflowFromFloats();
 
 private:
     bool recomputeLogicalWidthAndColumnWidth();
@@ -508,7 +508,6 @@ class RenderBlockFlow : public RenderBlock {
     bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset) override;
     bool hitTestInlineChildren(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
 
-    void addOverflowFromFloats();
     void addOverflowFromInlineChildren() override;
 
     void fitBorderToLinesIfNeeded(); // Shrink the box in which the border paints if border-fit is set.

Source/WebCore/rendering/RenderBoxModelObject.cpp

@@ -2685,67 +2685,4 @@ void RenderBoxModelObject::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, Tra
         transformState.move(containerOffset.width(), containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
 }
 
-void RenderBoxModelObject::moveChildTo(RenderTreeBuilder& builder, RenderBoxModelObject* toBoxModelObject, RenderObject* child, RenderObject* beforeChild, NormalizeAfterInsertion normalizeAfterInsertion)
-{
-    // We assume that callers have cleared their positioned objects list for child moves so the
-    // positioned renderer maps don't become stale. It would be too slow to do the map lookup on each call.
-    ASSERT(normalizeAfterInsertion == NormalizeAfterInsertion::No || !is<RenderBlock>(*this) || !downcast<RenderBlock>(*this).hasPositionedObjects());
-
-    ASSERT(this == child->parent());
-    ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent());
-    if (normalizeAfterInsertion == NormalizeAfterInsertion::Yes && (toBoxModelObject->isRenderBlock() || toBoxModelObject->isRenderInline())) {
-        // Takes care of adding the new child correctly if toBlock and fromBlock
-        // have different kind of children (block vs inline).
-        auto childToMove = builder.takeChildFromRenderElement(*this, *child);
-        builder.insertChild(*toBoxModelObject, WTFMove(childToMove), beforeChild);
-    } else {
-        auto childToMove = builder.takeChildFromRenderElement(*this, *child);
-        builder.insertChildToRenderElementInternal(*toBoxModelObject, WTFMove(childToMove), beforeChild);
-    }
-}
-
-void RenderBoxModelObject::moveChildrenTo(RenderTreeBuilder& builder, RenderBoxModelObject* toBoxModelObject, RenderObject* startChild, RenderObject* endChild, RenderObject* beforeChild, NormalizeAfterInsertion normalizeAfterInsertion)
-{
-    // This condition is rarely hit since this function is usually called on
-    // anonymous blocks which can no longer carry positioned objects (see r120761)
-    // or when fullRemoveInsert is false.
-    if (normalizeAfterInsertion == NormalizeAfterInsertion::Yes && is<RenderBlock>(*this)) {
-        downcast<RenderBlock>(*this).removePositionedObjects(nullptr);
-        if (is<RenderBlockFlow>(*this))
-            downcast<RenderBlockFlow>(*this).removeFloatingObjects();
-    }
-
-    ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent());
-    for (RenderObject* child = startChild; child && child != endChild; ) {
-        // Save our next sibling as moveChildTo will clear it.
-        RenderObject* nextSibling = child->nextSibling();
-
-        // FIXME: This logic here fails to detect the first letter in certain cases
-        // and skips a valid sibling renderer (see webkit.org/b/163737).
-        // Check to make sure we're not saving the firstLetter as the nextSibling.
-        // When the |child| object will be moved, its firstLetter will be recreated,
-        // so saving it now in nextSibling would leave us with a stale object.
-        if (is<RenderTextFragment>(*child) && is<RenderText>(nextSibling)) {
-            RenderObject* firstLetterObj = nullptr;
-            if (RenderBlock* block = downcast<RenderTextFragment>(*child).blockForAccompanyingFirstLetter()) {
-                RenderElement* firstLetterContainer = nullptr;
-                block->getFirstLetter(firstLetterObj, firstLetterContainer, child);
-            }
-
-            // This is the first letter, skip it.
-            if (firstLetterObj == nextSibling)
-                nextSibling = nextSibling->nextSibling();
-        }
-
-        moveChildTo(builder, toBoxModelObject, child, beforeChild, normalizeAfterInsertion);
-        child = nextSibling;
-    }
-}
-
-void RenderBoxModelObject::moveAllChildrenToInternal(RenderElement& newParent)
-{
-    while (firstChild())
-        newParent.attachRendererInternal(detachRendererInternal(*firstChild()), this);
-}
-
 } // namespace WebCore

Source/WebCore/rendering/RenderBoxModelObject.h

@@ -275,30 +275,6 @@ class RenderBoxModelObject : public RenderLayerModelObject {
     void setFirstLetterRemainingText(RenderTextFragment&);
     void clearFirstLetterRemainingText();
 
-    // NormalizeAfterInsertion::Yes ensures that the destination subtree is consistent after the insertion (anonymous wrappers etc).
-    enum class NormalizeAfterInsertion { No, Yes };
-    void moveChildTo(RenderTreeBuilder&, RenderBoxModelObject* toBoxModelObject, RenderObject* child, RenderObject* beforeChild, NormalizeAfterInsertion);
-    void moveChildTo(RenderTreeBuilder& builder, RenderBoxModelObject* toBoxModelObject, RenderObject* child, NormalizeAfterInsertion normalizeAfterInsertion)
-    {
-        moveChildTo(builder, toBoxModelObject, child, nullptr, normalizeAfterInsertion);
-    }
-    void moveAllChildrenTo(RenderTreeBuilder& builder, RenderBoxModelObject* toBoxModelObject, NormalizeAfterInsertion normalizeAfterInsertion)
-    {
-        moveAllChildrenTo(builder, toBoxModelObject, nullptr, normalizeAfterInsertion);
-    }
-    void moveAllChildrenTo(RenderTreeBuilder& builder, RenderBoxModelObject* toBoxModelObject, RenderObject* beforeChild, NormalizeAfterInsertion normalizeAfterInsertion)
-    {
-        moveChildrenTo(builder, toBoxModelObject, firstChild(), nullptr, beforeChild, normalizeAfterInsertion);
-    }
-    void moveAllChildrenToInternal(RenderElement& newParent);
-    // Move all of the kids from |startChild| up to but excluding |endChild|. 0 can be passed as the |endChild| to denote
-    // that all the kids from |startChild| onwards should be moved.
-    void moveChildrenTo(RenderTreeBuilder& builder, RenderBoxModelObject* toBoxModelObject, RenderObject* startChild, RenderObject* endChild, NormalizeAfterInsertion normalizeAfterInsertion)
-    {
-        moveChildrenTo(builder, toBoxModelObject, startChild, endChild, nullptr, normalizeAfterInsertion);
-    }
-    void moveChildrenTo(RenderTreeBuilder&, RenderBoxModelObject* toBoxModelObject, RenderObject* startChild, RenderObject* endChild, RenderObject* beforeChild, NormalizeAfterInsertion);
-
     enum ScaleByEffectiveZoomOrNot { ScaleByEffectiveZoom, DoNotScaleByEffectiveZoom };
     LayoutSize calculateImageIntrinsicDimensions(StyleImage*, const LayoutSize& scaledPositioningAreaSize, ScaleByEffectiveZoomOrNot) const;
 

Source/WebCore/rendering/updating/RenderTreeBuilder.cpp

@@ -46,6 +46,7 @@
 #include "RenderTableRow.h"
 #include "RenderTableSection.h"
 #include "RenderText.h"
+#include "RenderTextFragment.h"
 #include "RenderTreeBuilderBlock.h"
 #include "RenderTreeBuilderBlockFlow.h"
 #include "RenderTreeBuilderFirstLetter.h"
@@ -376,6 +377,92 @@ void RenderTreeBuilder::insertChildToRenderElementInternal(RenderElement& parent
     newChild->setHasOutlineAutoAncestor();
 }
 
+void RenderTreeBuilder::moveChildTo(RenderBoxModelObject& from, RenderBoxModelObject* to, RenderObject* child, RenderObject* beforeChild, NormalizeAfterInsertion normalizeAfterInsertion)
+{
+    // We assume that callers have cleared their positioned objects list for child moves so the
+    // positioned renderer maps don't become stale. It would be too slow to do the map lookup on each call.
+    ASSERT(normalizeAfterInsertion == NormalizeAfterInsertion::No || !is<RenderBlock>(from) || !downcast<RenderBlock>(from).hasPositionedObjects());
+
+    ASSERT(&from == child->parent());
+    ASSERT(!beforeChild || to == beforeChild->parent());
+    if (normalizeAfterInsertion == NormalizeAfterInsertion::Yes && (to->isRenderBlock() || to->isRenderInline())) {
+        // Takes care of adding the new child correctly if toBlock and fromBlock
+        // have different kind of children (block vs inline).
+        auto childToMove = takeChildFromRenderElement(from, *child);
+        insertChild(*to, WTFMove(childToMove), beforeChild);
+    } else {
+        auto childToMove = takeChildFromRenderElement(from, *child);
+        insertChildToRenderElementInternal(*to, WTFMove(childToMove), beforeChild);
+    }
+}
+
+void RenderTreeBuilder::moveChildTo(RenderBoxModelObject& from, RenderBoxModelObject* to, RenderObject* child, NormalizeAfterInsertion normalizeAfterInsertion)
+{
+    moveChildTo(from, to, child, nullptr, normalizeAfterInsertion);
+}
+
+void RenderTreeBuilder::moveAllChildrenTo(RenderBoxModelObject& from, RenderBoxModelObject* to, NormalizeAfterInsertion normalizeAfterInsertion)
+{
+    moveAllChildrenTo(from, to, nullptr, normalizeAfterInsertion);
+}
+
+void RenderTreeBuilder::moveAllChildrenTo(RenderBoxModelObject& from, RenderBoxModelObject* to, RenderObject* beforeChild, NormalizeAfterInsertion normalizeAfterInsertion)
+{
+    moveChildrenTo(from, to, from.firstChild(), nullptr, beforeChild, normalizeAfterInsertion);
+}
+
+void RenderTreeBuilder::moveChildrenTo(RenderBoxModelObject& from, RenderBoxModelObject* to, RenderObject* startChild, RenderObject* endChild, NormalizeAfterInsertion normalizeAfterInsertion)
+{
+    moveChildrenTo(from, to, startChild, endChild, nullptr, normalizeAfterInsertion);
+}
+
+void RenderTreeBuilder::moveChildrenTo(RenderBoxModelObject& from, RenderBoxModelObject* to, RenderObject* startChild, RenderObject* endChild, RenderObject* beforeChild, NormalizeAfterInsertion normalizeAfterInsertion)
+{
+    // This condition is rarely hit since this function is usually called on
+    // anonymous blocks which can no longer carry positioned objects (see r120761)
+    // or when fullRemoveInsert is false.
+    if (normalizeAfterInsertion == NormalizeAfterInsertion::Yes && is<RenderBlock>(from)) {
+        downcast<RenderBlock>(from).removePositionedObjects(nullptr);
+        if (is<RenderBlockFlow>(from))
+            downcast<RenderBlockFlow>(from).removeFloatingObjects();
+    }
+
+    ASSERT(!beforeChild || to == beforeChild->parent());
+    for (RenderObject* child = startChild; child && child != endChild; ) {
+        // Save our next sibling as moveChildTo will clear it.
+        RenderObject* nextSibling = child->nextSibling();
+
+        // FIXME: This logic here fails to detect the first letter in certain cases
+        // and skips a valid sibling renderer (see webkit.org/b/163737).
+        // Check to make sure we're not saving the firstLetter as the nextSibling.
+        // When the |child| object will be moved, its firstLetter will be recreated,
+        // so saving it now in nextSibling would leave us with a stale object.
+        if (is<RenderTextFragment>(*child) && is<RenderText>(nextSibling)) {
+            RenderObject* firstLetterObj = nullptr;
+            if (RenderBlock* block = downcast<RenderTextFragment>(*child).blockForAccompanyingFirstLetter()) {
+                RenderElement* firstLetterContainer = nullptr;
+                block->getFirstLetter(firstLetterObj, firstLetterContainer, child);
+            }
+
+            // This is the first letter, skip it.
+            if (firstLetterObj == nextSibling)
+            nextSibling = nextSibling->nextSibling();
+        }
+
+        moveChildTo(from, to, child, beforeChild, normalizeAfterInsertion);
+        child = nextSibling;
+    }
+}
+
+void RenderTreeBuilder::moveAllChildrenIncludingFloatsTo(RenderBlock& from, RenderBlock& to, RenderTreeBuilder::NormalizeAfterInsertion normalizeAfterInsertion)
+{
+    if (is<RenderBlockFlow>(from)) {
+        blockFlowBuilder().moveAllChildrenIncludingFloatsTo(downcast<RenderBlockFlow>(from), to, normalizeAfterInsertion);
+        return;
+    }
+    moveAllChildrenTo(from, &to, normalizeAfterInsertion);
+}
+
 void RenderTreeBuilder::makeChildrenNonInline(RenderBlock& parent, RenderObject* insertionPoint)
 {
     // makeChildrenNonInline takes a block whose children are *all* inline and it
@@ -409,7 +496,7 @@ void RenderTreeBuilder::makeChildrenNonInline(RenderBlock& parent, RenderObject*
         auto newBlock = parent.createAnonymousBlock();
         auto& block = *newBlock;
         insertChildToRenderElementInternal(parent, WTFMove(newBlock), inlineRunStart);
-        parent.moveChildrenTo(*this, &block, inlineRunStart, child, RenderBoxModelObject::NormalizeAfterInsertion::No);
+        moveChildrenTo(parent, &block, inlineRunStart, child, RenderTreeBuilder::NormalizeAfterInsertion::No);
     }
 #ifndef NDEBUG
     for (RenderObject* c = parent.firstChild(); c; c = c->nextSibling())
@@ -438,7 +525,7 @@ RenderObject* RenderTreeBuilder::splitAnonymousBoxesAroundChild(RenderBox& paren
             // See for example RenderTableCell:clippedOverflowRectForRepaint.
             markBoxForRelayoutAfterSplit(*parentBox);
             insertChildToRenderElementInternal(*parentBox, WTFMove(newPostBox), boxToSplit.nextSibling());
-            boxToSplit.moveChildrenTo(*this, &postBox, beforeChild, nullptr, RenderBoxModelObject::NormalizeAfterInsertion::Yes);
+            moveChildrenTo(boxToSplit, &postBox, beforeChild, nullptr, RenderTreeBuilder::NormalizeAfterInsertion::Yes);
 
             markBoxForRelayoutAfterSplit(boxToSplit);
             markBoxForRelayoutAfterSplit(postBox);