Collapse away nested anonymous blocks

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 2385 matching lines @@
     // Skip the LayoutBlock override, since that one deals with anonymous child insertion in a way
     // that isn't sufficient for us, and can only cause trouble at this point.
     LayoutBox::addChild(newChild, beforeChild);
 
     if (madeBoxesNonInline && parent() && isAnonymousBlock() && parent()->isLayoutBlock()) {
         toLayoutBlock(parent())->removeLeftoverAnonymousBlock(this);
         // |this| may be dead now.
     }
 }
 
+static bool isMergeableAnonymousBlock(const LayoutBlockFlow* block)
+{
+    return block->isAnonymousBlock() && !block->continuation() && !block->beingDestroyed() && !block->isRubyRun() && !block->isRubyBase();
+}
+
 void LayoutBlockFlow::removeChild(LayoutObject* oldChild)
 {
     // No need to waste time in merging or removing empty anonymous blocks.
     // We can just bail out if our document is getting destroyed.
     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 = false;
     if (prev && next && !oldChild->isInline() && !oldChild->virtualContinuation() && prev->isLayoutBlockFlow() && next->isLayoutBlockFlow()) {
         if (toLayoutBlockFlow(prev)->mergeSiblingContiguousAnonymousBlock(toLayoutBlockFlow(next))) {
             mergedAnonymousBlocks = true;
             next = nullptr;
         }
     }
 
     LayoutBlock::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
+    if (child && child->isLayoutBlockFlow() && !child->previousSibling() && !child->nextSibling()) {
+        // If 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(toLayoutBlockFlow(child));
+        if (mergedAnonymousBlocks || isMergeableAnonymousBlock(toLayoutBlockFlow(child)))
+            collapseAnonymousBlockChild(toLayoutBlockFlow(child));
     }
 
     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()) {
@@ skipping 101 matching lines @@
         return;
     setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::ChildAnonymousBlockChanged);
 
     child->moveAllChildrenTo(this, child->nextSibling(), child->hasLayer());
     setChildrenInline(child->childrenInline());
 
     children()->removeChildNode(this, child, child->hasLayer());
     child->destroy();
 }
 
-static bool isMergeableAnonymousBlock(const LayoutBlockFlow* block)
-{
-    return block->isAnonymousBlock() && !block->continuation() && !block->beingDestroyed() && !block->isRubyRun() && !block->isRubyBase();
-}
-
 bool LayoutBlockFlow::mergeSiblingContiguousAnonymousBlock(LayoutBlockFlow* siblingThatMayBeDeleted)
 {
     // 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(this) || !isMergeableAnonymousBlock(siblingThatMayBeDeleted))
         return false;
 
     setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
 
@@ skipping 1203 matching lines @@
             if (!rect.isEmpty())
                 rects.append(rect);
         }
     }
 
     if (inlineElementContinuation)
         inlineElementContinuation->addOutlineRects(rects, additionalOffset + (inlineElementContinuation->containingBlock()->location() - location()), includeBlockOverflows);
 }
 
 } // namespace blink