Fold out-of-flow objects into anonymous blocks when removing children

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 351 matching lines @@
     if (startOfContinuations && startOfContinuations->styleRef().outlineStyleIsAuto())
         startOfContinuations->invalidateDisplayItemClient(*startOfContinuations);
 }
 
 void LayoutBlock::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const
 {
     LayoutBox::invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
     invalidateDisplayItemClientForStartOfContinuationsIfNeeded(*this);
 }
 
+static void addSubsequentFloatingSiblingsToBlock(LayoutBlock* block, LayoutBlock* container)

[mstensho (USE GERRIT), 2015/10/29 20:00:26]

FloatingOrOutOfFlowSiblings

+{
+    LayoutObject* child = block->nextSibling();
+    while (child && child->isFloatingOrOutOfFlowPositioned()) {
+        LayoutObject* sibling = child->nextSibling();
+        container->moveChildTo(block, child, nullptr, 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 46 matching lines @@
             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);
+            addSubsequentFloatingSiblingsToBlock(toLayoutBlock(afterChild), this);

[mstensho (USE GERRIT), 2015/10/29 20:00:26]

Why would there be subsequent floats or out-of-flow objects after an anonymous
block? Don't we already have code to wrap them inside such anonymous blocks?

Oh, I see... Nice testcase. :)

No, wait a minute!

The TC goes like this:

LayoutBlock (anonymous)
    BR
LayoutBlock (DIV #first .block)
LayoutBlock (DIV .float)

Then we change #first from block to inline-block. First we detach the old layout
object:

LayoutBlock (anonymous)
    BR
LayoutBlock (DIV .float)

I guess my question is: why don't we wrap the float inside the anonymous block
right away here? Why is there stuff like this to clean up when inserting the new
#first inline-block layout object? Shouldn't the final lines in
LayoutBlock::removeChild() take care of that?

             return;
         }
 
         if (newChild->isInline()) {
             // No suitable existing anonymous box - create a new one.
             LayoutBlock* newBox = createAnonymousBlock();
             LayoutBox::addChild(newBox, beforeChild);
             // Reparent adjacent floating or out-of-flow siblings to the new box.
             LayoutObject* child = newBox->previousSibling();
             while (child && child->isFloatingOrOutOfFlowPositioned()) {
                 LayoutObject* sibling = child->previousSibling();
                 moveChildTo(newBox, child, newBox->firstChild(), false);
                 child = sibling;
             }
             newBox->addChild(newChild);
-            child = newBox->nextSibling();
-            while (child && child->isFloatingOrOutOfFlowPositioned()) {
-                LayoutObject* sibling = child->nextSibling();
-                moveChildTo(newBox, child, nullptr, false);
-                child = sibling;
-            }
+            addSubsequentFloatingSiblingsToBlock(newBox, this);
             return;
         }
     }
 
     LayoutBox::addChild(newChild, beforeChild);
 
     if (madeBoxesNonInline && parent() && isAnonymousBlock() && parent()->isLayoutBlock())
         toLayoutBlock(parent())->removeLeftoverAnonymousBlock(this);
     // this object may be dead here
 }
@@ skipping 2411 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