Remove unnecessary anonymous blocks when splitting anonymous boxes

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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
@@ skipping 4652 matching lines @@
         // Because we may have added some sections with already computed column structures, we need to
         // sync the table structure with them now. This avoids crashes when adding new cells to the table.
         toLayoutTable(box)->forceSectionsRecalc();
     } else if (box->isTableSection()) {
         toLayoutTableSection(box)->setNeedsCellRecalc();
     }
 
     box->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::AnonymousBlockChange);
 }
 
+static bool collapseIfWillBecomeLoneAnonymousBlock(LayoutBox* child)

[mstensho (USE GERRIT), 2016/01/28 20:45:14]

I think this would fit better in LayoutBlock. Doing so much LayoutBlock-specific
stuff here isn't so great.

[rhogan, 2016/01/30 12:38:58]

Waaaah! I moved it here because you thought it should be static. :)

+{
+    if (!child->isAnonymousBlock())
+        return false;
+    LayoutBlock* childBlock = toLayoutBlock(child);
+    if (childBlock->beingDestroyed())
+        return false;
+    // We're splitting from our previousSibling().

[mstensho (USE GERRIT), 2016/01/28 20:45:14]

I'm still uneasy about this.

I think we should rather nuke superfluous anonymous blocks after the split,
rather than guessing what the tree is going to look like before making the
split.

So, basically, for each postBox (once each is created) in
LayoutBox::splitAnonymousBoxesAroundChild():
If postBox only has one child, and that child is an anonyomus block that's
collapsable, collapseAnonymousBlockChild() it!

And don't we really have to do the same thing for the other side of the split as
well? Might end up with a lone anonymous block there too:

<div style="display:table-row-group;">
    <div style="display:inline-block; width:75px; height:50%;
background:blue;"></div>
    <div id="splitter" style="display:table-row;"></div>
    <div></div>
</div>

[rhogan, 2016/01/30 12:38:57]

We're not guessing though - if we create postBox here and it has no
nextSibling() then it's a lone anonymous block and can be collapsed right away.
All good points - applied.

+    if (child->nextSibling() || childBlock->continuation())
+        return false;
+    LayoutBlock* parent = child->containingBlock();

[mstensho (USE GERRIT), 2016/01/28 20:45:14]

This should always be the same as child->parent(), or we'd be in trouble, right?

Then I think it would be safer (and slightly faster, woho!) to call
child->parent() and bail if it's not a block.

[rhogan, 2016/01/30 12:38:57]

Done.

+    if (parent->isRubyBase() || parent->isRubyRun())
+        return false;
+    LayoutBlock::collapseAnonymousBlockChild(parent, childBlock);
+    return true;
+}
+
 LayoutObject* LayoutBox::splitAnonymousBoxesAroundChild(LayoutObject* beforeChild)
 {
     bool didSplitParentAnonymousBoxes = false;
 
     while (beforeChild->parent() != this) {
         LayoutBox* boxToSplit = toLayoutBox(beforeChild->parent());
         if (boxToSplit->slowFirstChild() != beforeChild && boxToSplit->isAnonymous()) {
             didSplitParentAnonymousBoxes = true;
 
             // We have to split the parent box into two boxes and move children
             // from |beforeChild| to end into the new post box.
             LayoutBox* postBox = boxToSplit->createAnonymousBoxWithSameTypeAs(this);
             postBox->setChildrenInline(boxToSplit->childrenInline());
             LayoutBox* parentBox = toLayoutBox(boxToSplit->parent());
             // We need to invalidate the |parentBox| before inserting the new node
             // so that the table paint invalidation logic knows the structure is dirty.
             // See for example LayoutTableCell:clippedOverflowRectForPaintInvalidation.
             markBoxForRelayoutAfterSplit(parentBox);
             parentBox->virtualChildren()->insertChildNode(parentBox, postBox, boxToSplit->nextSibling());
             boxToSplit->moveChildrenTo(postBox, beforeChild, 0, true);
 
             markBoxForRelayoutAfterSplit(boxToSplit);
             markBoxForRelayoutAfterSplit(postBox);
 
             beforeChild = postBox;
         } else {
-            beforeChild = boxToSplit;
+            // If a lone anonymous block is now unnecessary collapse it away - this will make beforeChild's current
+            // grandparent its parent so no need to set it before looping.
+            if (!collapseIfWillBecomeLoneAnonymousBlock(boxToSplit))
+                beforeChild = boxToSplit;
         }
     }
 
     if (didSplitParentAnonymousBoxes)
         markBoxForRelayoutAfterSplit(this);
 
     ASSERT(beforeChild->parent() == this);
     return beforeChild;
 }
 
@@ skipping 194 matching lines @@
 }
 
 void LayoutBox::clearPreviousPaintInvalidationRects()
 {
     LayoutBoxModelObject::clearPreviousPaintInvalidationRects();
     if (PaintLayerScrollableArea* scrollableArea = this->scrollableArea())
         scrollableArea->clearPreviousPaintInvalidationRects();
 }
 
 } // namespace blink