Merge contiguous anonymous blocks after removing a float or out-of-pos-element between them

third_party/WebKit/Source/core/layout/LayoutBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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 233 matching lines @@
             || oldStyle.paddingLeft() != newStyle.paddingLeft()
             || oldStyle.paddingRight() != newStyle.paddingRight();
     }
 
     return oldStyle.borderTopWidth() != newStyle.borderTopWidth()
         || oldStyle.borderBottomWidth() != newStyle.borderBottomWidth()
         || oldStyle.paddingTop() != newStyle.paddingTop()
         || oldStyle.paddingBottom() != newStyle.paddingBottom();
 }
 
+static bool canMergeContiguousAnonymousBlocks(LayoutObject* prev, LayoutObject* next)
+{
+    if ((prev && (!prev->isAnonymousBlock() || toLayoutBlock(prev)->continuation() || toLayoutBlock(prev)->beingDestroyed()))
+        || (next && (!next->isAnonymousBlock() || toLayoutBlock(next)->continuation() || toLayoutBlock(next)->beingDestroyed())))
+        return false;
+
+    if ((prev && (prev->isRubyRun() || prev->isRubyBase()))
+        || (next && (next->isRubyRun() || next->isRubyBase())))
+        return false;
+
+    return true;
+}
+
+static bool mergeContiguousAnonymousBlocks(LayoutObject* prev, LayoutObject*& next)
+{
+    if (!prev || !next || !canMergeContiguousAnonymousBlocks(prev, next))
+        return false;
+
+    prev->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
+    LayoutBlockFlow* nextBlock = toLayoutBlockFlow(next);
+    LayoutBlockFlow* prevBlock = toLayoutBlockFlow(prev);
+
+    // If the inlineness of children of the two block don't match, we'd need special code here
+    // (but there should be no need for it).
+    ASSERT(nextBlock->childrenInline() == prevBlock->childrenInline());
+    // Take all the children out of the |next| block and put them in
+    // the |prev| block.
+    nextBlock->moveAllChildrenIncludingFloatsTo(prevBlock, nextBlock->hasLayer() || prevBlock->hasLayer());
+    // Delete the now-empty block's lines and nuke it.
+    nextBlock->deleteLineBoxTree();
+    nextBlock->destroy();
+    next = nullptr;
+    return true;
+}
+
 static void addNextFloatingOrOutOfFlowSiblingsToBlock(LayoutBlock* block)
 {
     if (!block->parent() || !block->parent()->isLayoutBlockFlow())
         return;
     if (block->beingDestroyed() || block->documentBeingDestroyed())
         return;
 
     LayoutObject* child = block->nextSibling();
     while (child && child->isFloatingOrOutOfFlowPositioned()) {
         LayoutObject* sibling = child->nextSibling();
         toLayoutBlock(block->parent())->moveChildTo(block, child, nullptr, false);
         child = sibling;
     }
+
+    LayoutObject* next = block->nextSibling();
+    mergeContiguousAnonymousBlocks(block, next);
 }
 
 static void addPreviousFloatingOrOutOfFlowSiblingsToBlock(LayoutBlock* block)
 {
     if (!block->parent() || !block->parent()->isLayoutBlockFlow())
         return;
     if (block->beingDestroyed() || block->documentBeingDestroyed())
         return;
 
     LayoutObject* child = block->previousSibling();
@@ skipping 336 matching lines @@
     if (child->parent()->isLayoutGrid())
         toLayoutGrid(child->parent())->dirtyGrid();
 
     // Now remove the leftover anonymous block from the tree, and destroy it. We'll rip it out
     // manually from the tree before destroying it, because we don't want to trigger any tree
     // adjustments with regards to anonymous blocks (or any other kind of undesired chain-reaction).
     children()->removeChildNode(this, child, false);
     child->destroy();
 }
 
-static bool canMergeContiguousAnonymousBlocks(LayoutObject* oldChild, LayoutObject* prev, LayoutObject* next)
-{
-    if (oldChild->documentBeingDestroyed() || oldChild->isInline() || oldChild->virtualContinuation())
-        return false;
-
-    if ((prev && (!prev->isAnonymousBlock() || toLayoutBlock(prev)->continuation() || toLayoutBlock(prev)->beingDestroyed()))
-        || (next && (!next->isAnonymousBlock() || toLayoutBlock(next)->continuation() || toLayoutBlock(next)->beingDestroyed())))
-        return false;
-
-    if ((prev && (prev->isRubyRun() || prev->isRubyBase()))
-        || (next && (next->isRubyRun() || next->isRubyBase())))
-        return false;
-
-    return true;
-}
-
 void LayoutBlock::makeChildrenInlineIfPossible()
 {
     ASSERT(isLayoutBlockFlow());
     // Collapsing away anonymous wrappers isn't relevant for the children of anonymous blocks, unless they are ruby bases.
     if (isAnonymousBlock() && !isRubyBase())
         return;
 
     Vector<LayoutBlock*, 3> blocksToRemove;
     for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->isFloating())
@@ skipping 26 matching lines @@
     // now - they will be rebuilt at layout.
     toLayoutBlockFlow(this)->removeFloatingObjectsFromDescendants();
 
     for (size_t i = 0; i < blocksToRemove.size(); i++)
         collapseAnonymousBlockChild(this, blocksToRemove[i]);
     setChildrenInline(true);
 }
 
 void LayoutBlock::collapseAnonymousBlockChild(LayoutBlock* parent, LayoutBlock* child)
 {
+    if (!parent->canCollapseAnonymousBlockChild())
+        return;
     // It's possible that this block's destruction may have been triggered by the
     // child's removal. Just bail if the anonymous child block is already being
     // destroyed. See crbug.com/282088
     if (child->beingDestroyed())
         return;
     if (child->continuation())
         return;
     // Ruby elements use anonymous wrappers for ruby runs and ruby bases by design, so we don't remove them.
     if (child->isRubyRun() || child->isRubyBase())
         return;
@@ skipping 13 matching lines @@
     if (documentBeingDestroyed()) {
         LayoutBox::removeChild(oldChild);
         return;
     }
 
     // If this child is a block, and if our previous and next siblings are
     // both anonymous blocks with inline content, then we can go ahead and
     // fold the inline content back together.
     LayoutObject* prev = oldChild->previousSibling();
     LayoutObject* next = oldChild->nextSibling();
-    bool canMergeAnonymousBlocks = canMergeContiguousAnonymousBlocks(oldChild, prev, next);
-    if (canMergeAnonymousBlocks && prev && next) {
-        prev->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
-        LayoutBlockFlow* nextBlock = toLayoutBlockFlow(next);
-        LayoutBlockFlow* prevBlock = toLayoutBlockFlow(prev);
-
-        // If the inlineness of children of the two block don't match, we'd need special code here
-        // (but there should be no need for it).
-        ASSERT(nextBlock->childrenInline() == prevBlock->childrenInline());
-
-        // Take all the children out of the |next| block and put them in
-        // the |prev| block.
-        nextBlock->moveAllChildrenIncludingFloatsTo(prevBlock, nextBlock->hasLayer() || prevBlock->hasLayer());
-
-        // Delete the now-empty block's lines and nuke it.
-        nextBlock->deleteLineBoxTree();
-        nextBlock->destroy();
-        next = nullptr;
-    }
+    bool mergedAnonymousBlocks = !oldChild->documentBeingDestroyed() && !oldChild->isInline() && !oldChild->virtualContinuation() && mergeContiguousAnonymousBlocks(prev, next);
 
     LayoutBox::removeChild(oldChild);
 
     LayoutObject* child = prev ? prev : next;
-    if (canMergeAnonymousBlocks && child && !child->previousSibling() && !child->nextSibling() && canCollapseAnonymousBlockChild()) {
+    if (mergedAnonymousBlocks && child && !child->previousSibling() && !child->nextSibling()) {
         // The removal has knocked us down to containing only a single anonymous
         // box.  We can go ahead and pull the content right back up into our
         // box.
         collapseAnonymousBlockChild(this, toLayoutBlock(child));
     }
 
     if (!firstChild()) {
         // If this was our last child be sure to clear out our line boxes.
         if (childrenInline())
             deleteLineBoxTree();
@@ skipping 2103 matching lines @@
 void LayoutBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj) const
 {
     showLayoutObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink