Remove anonymous block wrapper when all children become inline

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 251 matching lines @@
         || 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()) {
-        toLayoutBlock(parent())->removeAnonymousWrappersIfRequired();
+        toLayoutBlock(parent())->makeChildrenInlineIfPossible();

[mstensho (USE GERRIT), 2015/10/29 10:08:49]

Note: I think this belongs in LayoutBox, not here in LayoutBlock. What if it's a
LayoutImage that goes from regular in-flow block to floated, for instance?
That's for a different CL to fix, though.

         // Reparent to an adjacent anonymous block if one is available.
         if (previousSibling() && previousSibling()->isAnonymousBlock())
             toLayoutBlock(parent())->moveChildTo(toLayoutBlock(previousSibling()), this, nullptr, false);
         else if (nextSibling() && nextSibling()->isAnonymousBlock())
             toLayoutBlock(parent())->moveChildTo(toLayoutBlock(nextSibling()), this, nextSibling()->slowFirstChild(), false);
     }
 
     const ComputedStyle& newStyle = styleRef();
 
     if (oldStyle && parent()) {
@@ skipping 314 matching lines @@
         || (next && (!next->isAnonymousBlock() || toLayoutBlock(next)->continuation() || toLayoutBlock(next)->beingDestroyed())))
         return false;
 
     if ((prev && (prev->isRubyRun() || prev->isRubyBase()))
         || (next && (next->isRubyRun() || next->isRubyBase())))
         return false;
 
     return true;
 }
 
-void LayoutBlock::removeAnonymousWrappersIfRequired()
+void LayoutBlock::makeChildrenInlineIfPossible()
 {
     ASSERT(isLayoutBlockFlow());
-    Vector<LayoutBox*, 16> blocksToRemove;
-    for (LayoutBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
+    // Collapsing away anonymous wrappers isn't relevant for the children of anonymous blocks.
+    if (isAnonymousBlock())
+        return;
+
+    Vector<LayoutBlock*, 3> blocksToRemove;
+    for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // There are still block children in the container, so any anonymous wrappers are still needed.
         if (!child->isAnonymousBlock())
             return;
         // We can't remove anonymous wrappers if they contain continuations as this means there are block children present.
         if (child->isLayoutBlock() && toLayoutBlock(child)->continuation())
             return;
         // We are only interested in removing anonymous wrappers if there are inline siblings underneath them.
         if (!child->childrenInline())
             return;
+        // Ruby elements use anonymous wrappers for ruby runs and ruby bases by design, so we don't remove them.
+        if (child->isRubyRun() || child->isRubyBase())
+            return;
 
-        if (child->isAnonymousBlock())
-            blocksToRemove.append(child);
+        blocksToRemove.append(toLayoutBlock(child));
     }
 
     for (size_t i = 0; i < blocksToRemove.size(); i++)
-        collapseAnonymousBlockChild(this, toLayoutBlock(blocksToRemove[i]));
+        collapseAnonymousBlockChild(this, blocksToRemove[i]);
+    setChildrenInline(true);
 }
 
 void LayoutBlock::collapseAnonymousBlockChild(LayoutBlock* parent, LayoutBlock* child)
 {
     // It's possible that this block's destruction may have been triggered by the
     // child's removal. Just bail if the anonymous child block is already being
     // destroyed. See crbug.com/282088
     if (child->beingDestroyed())
         return;
     parent->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::ChildAnonymousBlockChanged);
 
     child->moveAllChildrenTo(parent, child->nextSibling(), child->hasLayer());
     parent->setChildrenInline(child->childrenInline());
 
     parent->children()->removeChildNode(parent, child, child->hasLayer());
     child->destroy();
 }
 
-static inline bool shouldMakeChildrenInline(const LayoutBlock* block)
-{
-    if (!block->isLayoutBlockFlow())
-        return false;
-    LayoutObject* child = block->firstChild();
-    while (child) {
-        // TODO(rhogan): If we encounter anonymous blocks with inline children we should fold them in here.
-        if (!child->isFloatingOrOutOfFlowPositioned())
-            return false;
-        child = child->nextSibling();
-    }
-    return true;
-}
-
 void LayoutBlock::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
@@ skipping 82 matching lines @@
                 else if (curr->isLayoutBlock())
                     toLayoutBlock(curr)->setContinuation(nextContinuation);
                 else
                     ASSERT_NOT_REACHED();
 
                 break;
             }
             setContinuation(nullptr);
             destroy();
         }
-    } else if (!beingDestroyed() && !oldChild->isFloatingOrOutOfFlowPositioned() && shouldMakeChildrenInline(this)) {
+    } else if (!beingDestroyed() && !oldChild->isFloatingOrOutOfFlowPositioned() && isLayoutBlockFlow()) {
         // If the child we're removing means that we can now treat all children as inline without the need for anonymous blocks, then do that.
-        setChildrenInline(true);
+        makeChildrenInlineIfPossible();
     }
 }
 
 bool LayoutBlock::isSelfCollapsingBlock() const
 {
     // We are not self-collapsing if we
     // (a) have a non-zero height according to layout (an optimization to avoid wasting time)
     // (b) are a table,
     // (c) have border/padding,
     // (d) have a min-height
@@ skipping 2102 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