Turn mergeContiguousAnonymousBlocks() into a proper method.

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 231 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)
+static bool isMergeableAnonymousBlock(const LayoutBlockFlow* block)
 {
-    if ((prev && (!prev->isAnonymousBlock() || toLayoutBlock(prev)->continuation() || toLayoutBlock(prev)->beingDestroyed()))
-        || (next && (!next->isAnonymousBlock() || toLayoutBlock(next)->continuation() || toLayoutBlock(next)->beingDestroyed())))
+    return block->isAnonymousBlock() && !block->continuation() && !block->beingDestroyed() && !block->isRubyRun() && !block->isRubyBase();
+}
+
+bool LayoutBlock::mergeSiblingContiguousAnonymousBlock(LayoutBlockFlow* siblingThatMayBeDeleted)
+{
+    if (!isLayoutBlockFlow())
         return false;
 
-    if ((prev && (prev->isRubyRun() || prev->isRubyBase()))
-        || (next && (next->isRubyRun() || next->isRubyBase())))
+    // Note: |this| and |siblingThatMayBeDeleted| may not be adjacent siblings at this point. There
+    // may be an object between them which is about to be removed.
+
+    if (!isMergeableAnonymousBlock(toLayoutBlockFlow(this)) || !isMergeableAnonymousBlock(siblingThatMayBeDeleted))
         return false;
 
+    setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
+
+    // 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(siblingThatMayBeDeleted->childrenInline() == childrenInline());
+    // Take all the children out of the |next| block and put them in
+    // the |prev| block.
+    siblingThatMayBeDeleted->moveAllChildrenIncludingFloatsTo(this, siblingThatMayBeDeleted->hasLayer() || hasLayer());
+    // Delete the now-empty block's lines and nuke it.
+    siblingThatMayBeDeleted->deleteLineBoxTree();
+    siblingThatMayBeDeleted->destroy();
     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;
-}
-
 void LayoutBlock::reparentSubsequentFloatingOrOutOfFlowSiblings()
 {
     if (!parent() || !parent()->isLayoutBlockFlow())
         return;
     if (beingDestroyed() || documentBeingDestroyed())
         return;
     LayoutBlockFlow* parentBlockFlow = toLayoutBlockFlow(parent());
     LayoutObject* child = nextSibling();
     while (child && child->isFloatingOrOutOfFlowPositioned()) {
         LayoutObject* sibling = child->nextSibling();
         parentBlockFlow->moveChildTo(this, child, nullptr, false);
         child = sibling;
     }
 
-    LayoutObject* next = nextSibling();
-    mergeContiguousAnonymousBlocks(this, next);
+    if (LayoutObject* next = nextSibling()) {
+        if (next->isLayoutBlockFlow())
+            mergeSiblingContiguousAnonymousBlock(toLayoutBlockFlow(next));
+    }
 }
 
 void LayoutBlock::reparentPrecedingFloatingOrOutOfFlowSiblings()
 {
     if (!parent() || !parent()->isLayoutBlockFlow())
         return;
     if (beingDestroyed() || documentBeingDestroyed())
         return;
     LayoutBlockFlow* parentBlockFlow = toLayoutBlockFlow(parent());
     LayoutObject* child = previousSibling();
@@ skipping 342 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 mergedAnonymousBlocks = !oldChild->documentBeingDestroyed() && !oldChild->isInline() && !oldChild->virtualContinuation() && mergeContiguousAnonymousBlocks(prev, next);
+    bool mergedAnonymousBlocks = false;
+    if (prev && next && !oldChild->isInline() && !oldChild->virtualContinuation() && prev->isLayoutBlockFlow() && next->isLayoutBlockFlow()) {
+        if (toLayoutBlockFlow(prev)->mergeSiblingContiguousAnonymousBlock(toLayoutBlockFlow(next))) {
+            mergedAnonymousBlocks = true;
+            next = nullptr;
+        }
+    }
 
     LayoutBox::removeChild(oldChild);
 
     LayoutObject* child = prev ? prev : next;
     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));
     }
@@ skipping 1577 matching lines @@
         for (TrackedLayoutBoxListHashSet::const_iterator it = positionedDescendantSet->begin(); it != end; ++it) {
             LayoutBox* currBox = *it;
             ASSERT(!currBox->needsLayout());
         }
     }
 }
 
 #endif
 
 } // namespace blink