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();
 }
 
+void LayoutBlock::collapseAnonymousBlockChildAfterMerge(LayoutObject* prev, LayoutObject* next, bool canMergeAnonymousBlocks)

[rhogan, 2016/03/03 21:48:36]

I don't see a good alternative to passing canMergeAnonymousBlocks here.

+{
+    if (!canCollapseAnonymousBlockChild())
+        return;
+
+    LayoutObject* child = prev ? prev : next;
+    if (canMergeAnonymousBlocks && 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));
+    } else if (((prev && prev->isAnonymousBlock()) || (next && next->isAnonymousBlock()))) {
+        // It's possible that the removal has knocked us down to a single anonymous
+        // block with pseudo-style element siblings (e.g. first-letter). If these
+        // are floating, then we need to pull the content up also.
+        LayoutBlock* anonymousBlock = toLayoutBlock((prev && prev->isAnonymousBlock()) ? prev : next);
+        if ((anonymousBlock->previousSibling() || anonymousBlock->nextSibling())
+            && (!anonymousBlock->previousSibling() || (anonymousBlock->previousSibling()->style()->styleType() != NOPSEUDO && anonymousBlock->previousSibling()->isFloating() && !anonymousBlock->previousSibling()->previousSibling()))
+            && (!anonymousBlock->nextSibling() || (anonymousBlock->nextSibling()->style()->styleType() != NOPSEUDO && anonymousBlock->nextSibling()->isFloating() && !anonymousBlock->nextSibling()->nextSibling()))) {
+            collapseAnonymousBlockChild(this, anonymousBlock);
+        }
+    }
+}
+
+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 void mergeContiguousAnonymousBlocks(LayoutBlock* parent, LayoutObject*& prev, LayoutObject*& next)
+{
+    ASSERT(canMergeContiguousAnonymousBlocks(prev, next));
+    if (!prev || !next)
+        return;
+
+    prev->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
+    LayoutBlockFlow* nextBlock = toLayoutBlockFlow(next);
+    LayoutBlockFlow* prevBlock = toLayoutBlockFlow(prev);
+
+    if (prev->childrenInline() != next->childrenInline()) {
+        LayoutBlock* inlineChildrenBlock = prev->childrenInline() ? prevBlock : nextBlock;
+        LayoutBlock* blockChildrenBlock = prev->childrenInline() ? nextBlock : prevBlock;
+
+        // Place the inline children block inside of the block children block instead of deleting it.
+        ASSERT(!inlineChildrenBlock->continuation());
+        bool inlineChildrenBlockHasLayer = inlineChildrenBlock->hasLayer();
+        parent->children()->removeChildNode(parent, inlineChildrenBlock, inlineChildrenBlockHasLayer);
+
+        // Now just put the inlineChildrenBlock inside the blockChildrenBlock.
+        blockChildrenBlock->children()->insertChildNode(blockChildrenBlock, inlineChildrenBlock, prev == inlineChildrenBlock ? blockChildrenBlock->firstChild() : 0,
+            inlineChildrenBlockHasLayer || blockChildrenBlock->hasLayer());
+        next->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
+
+        // inlineChildrenBlock got reparented to blockChildrenBlock, so it is no longer a child
+        // of "this". we null out prev or next so that is not used later in the function.
+        if (inlineChildrenBlock == prevBlock)
+            prev = nullptr;
+        else
+            next = nullptr;
+    } else {
+        // 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;
+    }
+}
+
 static void addNextFloatingOrOutOfFlowSiblingsToBlock(LayoutBlock* block)
 {
     if (!block->parent() || !block->parent()->isLayoutBlockFlow())
         return;
     if (block->beingDestroyed() || block->documentBeingDestroyed())
         return;
 
     LayoutObject* child = block->nextSibling();
+    LayoutBlock* parent = toLayoutBlock(block->parent());
     while (child && child->isFloatingOrOutOfFlowPositioned()) {
         LayoutObject* sibling = child->nextSibling();
-        toLayoutBlock(block->parent())->moveChildTo(block, child, nullptr, false);
+        parent->moveChildTo(block, child, nullptr, false);
         child = sibling;
     }
+
+    LayoutObject* prev = block;
+    LayoutObject* next = block->nextSibling();
+    if (canMergeContiguousAnonymousBlocks(prev, next)) {
+        mergeContiguousAnonymousBlocks(parent, prev, next);
+        parent->collapseAnonymousBlockChildAfterMerge(prev, next, true);

[rhogan, 2016/03/03 21:48:36]

Was forced into the use of parent-> by canCollapseAnonymousBlockChild() being
protected and sub-classed in a lot of places, so I can't call it from a static
function.

+    }
 }
 
 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 59 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 (prev->childrenInline() != next->childrenInline()) {
-            LayoutBlock* inlineChildrenBlock = prev->childrenInline() ? prevBlock : nextBlock;
-            LayoutBlock* blockChildrenBlock = prev->childrenInline() ? nextBlock : prevBlock;
-
-            // Place the inline children block inside of the block children block instead of deleting it.
-            ASSERT(!inlineChildrenBlock->continuation());
-            bool inlineChildrenBlockHasLayer = inlineChildrenBlock->hasLayer();
-            children()->removeChildNode(this, inlineChildrenBlock, inlineChildrenBlockHasLayer);
-
-            // Now just put the inlineChildrenBlock inside the blockChildrenBlock.
-            blockChildrenBlock->children()->insertChildNode(blockChildrenBlock, inlineChildrenBlock, prev == inlineChildrenBlock ? blockChildrenBlock->firstChild() : 0,
-                inlineChildrenBlockHasLayer || blockChildrenBlock->hasLayer());
-            next->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
-
-            // inlineChildrenBlock got reparented to blockChildrenBlock, so it is no longer a child
-            // of "this". we null out prev or next so that is not used later in the function.
-            if (inlineChildrenBlock == prevBlock)
-                prev = nullptr;
-            else
-                next = nullptr;
-        } else {
-            // 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 canMergeAnonymousBlocks = canMergeContiguousAnonymousBlocks(prev, next) && !oldChild->documentBeingDestroyed() && !oldChild->isInline() && !oldChild->virtualContinuation();
+    if (canMergeAnonymousBlocks)
+        mergeContiguousAnonymousBlocks(this, prev, next);
 
     LayoutBox::removeChild(oldChild);
 
-    LayoutObject* child = prev ? prev : next;
-    if (canMergeAnonymousBlocks && child && !child->previousSibling() && !child->nextSibling() && canCollapseAnonymousBlockChild()) {
-        // 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));
-    } else if (((prev && prev->isAnonymousBlock()) || (next && next->isAnonymousBlock())) && canCollapseAnonymousBlockChild()) {
-        // It's possible that the removal has knocked us down to a single anonymous
-        // block with pseudo-style element siblings (e.g. first-letter). If these
-        // are floating, then we need to pull the content up also.
-        LayoutBlock* anonymousBlock = toLayoutBlock((prev && prev->isAnonymousBlock()) ? prev : next);
-        if ((anonymousBlock->previousSibling() || anonymousBlock->nextSibling())
-            && (!anonymousBlock->previousSibling() || (anonymousBlock->previousSibling()->style()->styleType() != NOPSEUDO && anonymousBlock->previousSibling()->isFloating() && !anonymousBlock->previousSibling()->previousSibling()))
-            && (!anonymousBlock->nextSibling() || (anonymousBlock->nextSibling()->style()->styleType() != NOPSEUDO && anonymousBlock->nextSibling()->isFloating() && !anonymousBlock->nextSibling()->nextSibling()))) {
-            collapseAnonymousBlockChild(this, anonymousBlock);
-        }
-    }
+    collapseAnonymousBlockChildAfterMerge(prev, next, canMergeAnonymousBlocks);
 
     if (!firstChild()) {
         // If this was our last child be sure to clear out our line boxes.
         if (childrenInline())
             deleteLineBoxTree();
 
         // If we are an empty anonymous block in the continuation chain,
         // we need to remove ourself and fix the continuation chain.
         if (!beingDestroyed() && isAnonymousBlockContinuation() && !oldChild->isListMarker()) {
             LayoutObject* containingBlockIgnoringAnonymous = containingBlock();
@@ skipping 2121 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