Strip anonymous wrappers when a block flow no longer requires them

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 359 matching lines @@
         startOfContinuations->invalidateDisplayItemClient(*startOfContinuations);
 }
 
 void LayoutBlock::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutBox::invalidateDisplayItemClients(paintInvalidationContainer);
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     invalidateDisplayItemClientForStartOfContinuationsIfNeeded(*this);
 }
 
+void LayoutBlock::addAdjacentSiblingsToAnonymousBox(AdjacentSiblings siblings, LayoutBlock* anonymousBox)
+{
+    bool previousSiblings = siblings == PreviousSiblings;
+    LayoutObject* child = previousSiblings ? anonymousBox->previousSibling() : anonymousBox->nextSibling();
+    while (child && (child->isFloatingOrOutOfFlowPositioned() || (child->isAnonymousBlock() && child->childrenInline()))) {
+        LayoutObject* sibling = previousSiblings ? child->previousSibling() : child->nextSibling();
+        if (child->isAnonymousBlock()) {
+            LayoutBlockFlow* block = toLayoutBlockFlow(child);

[mstensho (USE GERRIT), 2015/09/03 08:44:30]

I still think that if we find another anonymous block on our way, we have
failed. We should have parented into it in the first place.

[rhogan, 2015/09/06 15:09:27]

Yup - addressed this by parenting floating/out-of-flow objects into adjacent
anonymous blocks at style change time. This means we never have them in the way
when looking for a previous sibling that is an anonymous block.

+            block->moveAllChildrenTo(anonymousBox, previousSiblings ? anonymousBox->firstChild() : 0, true);
+            block->destroy();
+        } else {
+            moveChildTo(anonymousBox, child, previousSiblings ? anonymousBox->firstChild() : 0, false);
+        }
+        child = sibling;
+    }
+}
+
 void LayoutBlock::addChildIgnoringContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     if (beforeChild && beforeChild->parent() != this) {
         LayoutObject* beforeChildContainer = beforeChild->parent();
         while (beforeChildContainer->parent() != this)
             beforeChildContainer = beforeChildContainer->parent();
         ASSERT(beforeChildContainer);
 
         if (beforeChildContainer->isAnonymous()) {
             // If the requested beforeChild is not one of our children, then this is because
@@ skipping 49 matching lines @@
         // If we're inserting an inline child but all of our children are blocks, then we have to make sure
         // it is put into an anomyous block box. We try to use an existing anonymous box if possible, otherwise
         // a new one is created and inserted into our list of children in the appropriate position.
         LayoutObject* afterChild = beforeChild ? beforeChild->previousSibling() : lastChild();
 
         if (afterChild && afterChild->isAnonymousBlock()) {
             afterChild->addChild(newChild);
             return;
         }
 
+        LayoutObject* nextChild = firstChild();
+        bool needsAnonymousBox = isFlexibleBoxIncludingDeprecated() || isLayoutGrid();

[mstensho (USE GERRIT), 2015/09/03 08:44:30]

I cannot find this condition anywhere else in the child insertion code. How did
you come up with it?

[rhogan, 2015/09/06 15:09:27]

These seem to be the only two layout blocks that do not allow inline children.

+        while (nextChild && !needsAnonymousBox) {

[mstensho (USE GERRIT), 2015/09/03 08:44:30]

We're walking through all children to figure out if we can be turned into an
inline-children block? Since this is a block-children block, there already has
to be a block child there, since blocks (when created) start being marked as
having inline children until someone attempts to insert a block child. No?

[rhogan, 2015/09/06 15:09:27]

Clarified what's happening in the comments - we can end up here when we have
block children but they're all out of flow or floating.

+            if (!nextChild->isFloatingOrOutOfFlowPositioned()) {
+                needsAnonymousBox = true;
+                break;
+            }
+            nextChild = nextChild->nextSibling();
+        }
+        if (!needsAnonymousBox) {
+            LayoutBox::addChild(newChild, beforeChild);
+            setChildrenInline(true);
+            return;
+        }
+
         if (newChild->isInline()) {
             // No suitable existing anonymous box - create a new one.
             LayoutBlock* newBox = createAnonymousBlock();
             LayoutBox::addChild(newBox, beforeChild);
+            // Reparent adjacent inline siblings to the new box.
+            addAdjacentSiblingsToAnonymousBox(PreviousSiblings, newBox);
             newBox->addChild(newChild);
+            addAdjacentSiblingsToAnonymousBox(NextSiblings, newBox);
             return;
         }
     }
 
     LayoutBox::addChild(newChild, beforeChild);
 
     if (madeBoxesNonInline && parent() && isAnonymousBlock() && parent()->isLayoutBlock())
         toLayoutBlock(parent())->removeLeftoverAnonymousBlock(this);
     // this object may be dead here
 }
@@ skipping 2442 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