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 253 matching lines @@
     return oldStyle.borderTopWidth() != newStyle.borderTopWidth()
         || oldStyle.borderBottomWidth() != newStyle.borderBottomWidth()
         || oldStyle.paddingTop() != newStyle.paddingTop()
         || oldStyle.paddingBottom() != newStyle.paddingBottom();
 }
 
 void LayoutBlock::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBox::styleDidChange(diff, oldStyle);
 
-    if (isFloatingOrOutOfFlowPositioned() && oldStyle && !oldStyle->isFloating() && !oldStyle->hasOutOfFlowPosition() && parent() && parent()->isLayoutBlockFlow())
+    if (isFloatingOrOutOfFlowPositioned() && oldStyle && !oldStyle->isFloating() && !oldStyle->hasOutOfFlowPosition() && parent() && parent()->isLayoutBlockFlow()) {
         toLayoutBlock(parent())->removeAnonymousWrappersIfRequired();
+        // Reparent to an adjacent anonymous block if one is available.
+        if (previousSibling() && previousSibling()->isAnonymousBlock())
+            toLayoutBlock(parent())->moveChildTo(toLayoutBlock(previousSibling()), this, 0, false);
+        if (nextSibling() && nextSibling()->isAnonymousBlock())
+            toLayoutBlock(parent())->moveChildTo(toLayoutBlock(nextSibling()), this, nextSibling()->slowFirstChild(), false);
+    }
 
     const ComputedStyle& newStyle = styleRef();
 
     if (oldStyle && parent()) {
         if (oldStyle->position() != newStyle.position() && newStyle.position() != StaticPosition) {
             // Remove our absolutely positioned descendants from their new containing block,
             // in case containingBlock() changes by the change to the position property.
             // See styleWillChange() for other cases.
             if (LayoutBlock* cb = containingBlock())
                 cb->removePositionedObjects(this, NewContainingBlock);
@@ skipping 83 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()) {
+        LayoutObject* sibling = previousSiblings ? child->previousSibling() : child->nextSibling();
+        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 43 matching lines @@
         if (beforeChild && beforeChild->parent() != this) {
             beforeChild = beforeChild->parent();
             ASSERT(beforeChild->isAnonymousBlock());
             ASSERT(beforeChild->parent() == this);
         }
     } else if (!childrenInline() && (newChild->isFloatingOrOutOfFlowPositioned() || newChild->isInline())) {
         // 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;
         }
 
+        // If we are a block that allows inline children and the child we're adding means that

[mstensho (USE GERRIT), 2015/09/07 14:01:47]

But we are not a block that allows inline children.

We're inside "if (!childrenInline() && ...)".

How do we end up with !childrenInline() and only floating or out-of-flow
children? I think that's a bug.

+        // we can now treat all children as inline without the need for anonymous blocks, then do that.
+        LayoutObject* nextChild = firstChild();
+        bool childrenAllInline = !isFlexibleBoxIncludingDeprecated() && !isLayoutGrid();
+        while (nextChild && childrenAllInline) {
+            if (!nextChild->isFloatingOrOutOfFlowPositioned()) {
+                childrenAllInline = false;
+                break;
+            }
+            nextChild = nextChild->nextSibling();
+        }
+        if (childrenAllInline) {
+            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 2462 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